用Java實現一個向量場

在學習微分方程的時候，以前也寫過類似的文章，可是效果不行，前幾天寫了一個，感覺不錯，分享之。

先看效果（x*x -y -2）：

再來代碼：

1. package com.math.slopfields;
3. import java.awt.Color;
4. import java.awt.Graphics;
6. import javax.swing.JFrame;
8. public class SlopFields extends JFrame {
9. protected static final int WIDTH = 800;
10. protected static final int HEIGHT = 600;
11. private java.awt.Dimension dimension = java.awt.Toolkit.getDefaultToolkit().
12. getScreenSize();
15. public SlopFields(String title, Grid g) {
16. super(title);
17. this.setSize(WIDTH, HEIGHT);
18. this.setLocation((dimension.width - WIDTH) / 2,
19. (dimension.height - HEIGHT) / 2);
21. HeartCanvas panel = new HeartCanvas(g);
22. this.add(panel);
23. }
25. public static void main(String[] args) {
26. double scale = 80;
27. double aa = 3;
28. double dd = 0.15;
30. Area area = new Area(Vector.build(-aa, aa), Vector.build(aa, -aa));
31. Vector grid = Vector.build(dd, dd);
32. CanCalc c = new CanCalc(){
33. public double doCalc(Vector v) {
34. return v.x*v.x - v.y - 2;
35. }
37. };
38. Grid g = new Grid(area, grid, c, scale);
40. SlopFields hart = new SlopFields("向量場", g);
41. hart.setVisible(true);
42. hart.setDefaultCloseOperation(hart.EXIT_ON_CLOSE);
43. }
45. }
48. class HeartCanvas extends javax.swing.JPanel {
50. private Grid grid;
52. public HeartCanvas(Grid g) {
53. this.grid = g;
54. this.grid.calcGrids();
55. this.grid.preDraw();
56. }
58. public void paintComponent(Graphics g) {
59. setBackground(Color.BLACK);
60. super.paintComponent(g);
61. g.setColor(Color.GREEN);
62. this.grid.draw(g);
63. }
64. }
67. class Grid {
68. public double scale = 100;
69. public double padding = 0.2;
70. public Vector offect = Vector.build(0.25, 0.25);
72. public Area area;
73. public Area[][] areas;
75. public Vector grid;
76. public int nx, ny;
78. private CanCalc calc;
80. public Grid(Area _area, Vector _grid, CanCalc _calc, double _scale) {
81. this.area = _area;
82. this.grid = _grid;
83. this.calc = _calc;
84. this.scale = _scale;
85. }
87. public void draw(Graphics g) {
89. int x = (int)area.ld.x;
90. int y = (int)area.ld.y;
91. Vector t = area.ru.add(area.ld.neg());
92. int width = (int)t.x;
93. int height = (int)t.y;
96. g.drawRect(x, y, width, height);
97. g.drawLine(x, (int)offect.y, x+width, (int)offect.y);
98. g.drawLine((int)offect.x, y, (int)offect.x, y+height);
99. for(Area[] al : areas) {
100. for(Area a : al) {
101. g.drawLine((int)a.ld.x, (int)a.ld.y, (int)a.ru.x, (int)a.ru.y);
102. }
103. }
104. }
106. public void preDraw() {
107. offect = offect.dotMul(this.scale).add(Vector.build(-area.ld.x*scale, area.ru.y*scale));
108. area = new Area(Vector.build(area.ld.x, -area.ru.y).dotMul(this.scale).add(offect),
109. Vector.build(area.ru.x, -area.ld.x).dotMul(this.scale).add(offect));
110. for(int i=0; i<ny; i++){
111. for(int j=0; j<nx; j++) {
112. Area tmp = areas[i][j];
113. Vector va = Vector.build(tmp.ld.x, -tmp.ld.y).dotMul(this.scale).add(offect);
114. Vector vb = Vector.build(tmp.ru.x, -tmp.ru.y).dotMul(this.scale).add(offect);
115. areas[i][j] = new Area(va, vb);
116. }
117. }
118. }
121. private void fixArea() {
122. Vector tn1 = area.ld.dotDiv(grid).intVal().abs();
123. area.ld = grid.dotMul(tn1).neg();
125. Vector tn2 = area.ru.dotDiv(grid).intVal().abs();
126. area.ru = grid.dotMul(tn2);
128. tn1 = tn1.add(tn2);
129. nx = (int)tn1.x;
130. ny = (int)tn1.y;
131. }
133. private Slop[][] initSlop(CanCalc calc) {
134. fixArea();
135. Slop[][] slops = new Slop[nx][ny];
137. Vector now = area.ld.clone();
138. now.y += grid.y/2;
139. for(int i=0; i<ny; i++) {
140. now.x = area.ld.x + grid.x/2;
141. for(int j=0; j<nx; j++) {
142. slops[i][j] = new Slop(now.clone(), calc.doCalc(now));
143. now.x += grid.x;
144. }
145. now.y += grid.y;
146. }
147. return slops;
148. }
150. public Area[][] calcGrids() {
151. Slop[][] slops = initSlop(calc);
152. areas = new Area[nx][ny];
153. for(int i=0; i<nx; i++) {
154. for(int j=0; j<ny; j++) {
155. Vector tmp = null;
156. Slop s = slops[i][j];
157. if(s.slop == grid.slop()) {
158. tmp = grid.dotDiv(2);
159. }else if(s.slop == -grid.slop()){
160. tmp = grid.dotDiv(2).dotMul(Vector.dr);
161. }else if(s.slop==0){
162. tmp = Vector.build(grid.x/2, 0);
163. }else if(s.slop<grid.slop() && s.slop>-grid.slop()) {
164. tmp = Vector.build(grid.x/2, (grid.x/2)*s.slop);
165. }else {
166. tmp = Vector.build((grid.y/2)/s.slop, grid.y/2);
167. }
168. tmp = tmp.dotMul(1-this.padding);
170. areas[i][j] = new Area(s.point.add(tmp.neg()), s.point.add(tmp));
171. }
172. }
173. return areas;
174. }
175. }
177. interface CanCalc {
178. public double doCalc(Vector v);
179. }
181. class Slop{
182. public Vector point;
183. public double slop;
184. public Slop(Vector _point, double _slop) {
185. this.point = _point;
186. this.slop = _slop;
187. }
188. public String toString() {
189. return String.format("{%s, %.2f}", point, slop);
190. }
191. }
193. class Area {
194. public Vector ld;
195. public Vector ru;
197. public Area(Vector _ld, Vector _ru) {
198. this.ld = _ld;
199. this.ru = _ru;
200. }
202. public String toString() {
203. return String.format("[%s-%s]", this.ld, this.ru);
204. }
206. public Area scale(double d) {
207. return new Area(this.ld.dotMul(d), this.ru.dotMul(d));
208. }
210. public Area add(Vector v) {
211. return new Area(this.ld.add(v), this.ru.add(v));
212. }
213. }
217. class Vector {
218. public static final double infinite = Double.MAX_VALUE;
220. public double x;
221. public double y;
223. public static final Vector zero = Vector.build(0, 0);
224. public static final Vector up = Vector.build(0, 1);
225. public static final Vector down = Vector.build(0, -1);
226. public static final Vector left = Vector.build(-1, 0);
227. public static final Vector right = Vector.build(1, 0);
228. public static final Vector ul = Vector.build(-1, 1);
229. public static final Vector ur = Vector.build(1, 1);
230. public static final Vector dl = Vector.build(-1, -1);
231. public static final Vector dr = Vector.build(1, -1);
233. public static Vector build(double x, double y) {
234. return new Vector(x, y);
235. }
237. public Vector clone() {
238. return Vector.build(this.x, this.y);
239. }
241. public double slop() {
242. if(this.x == 0) {
243. return Vector.infinite;
244. }
245. return this.y / this.x;
246. }
248. public Vector(double _x, double _y) {
249. this.x = _x;
250. this.y = _y;
251. }
253. public Vector intVal() {
254. return new Vector((int)this.x, (int)this.y);
255. }
257. public Vector abs() {
258. return Vector.build((x>=0?x:-x), (y>=0?y:-y));
259. }
261. public Vector add(Vector v) {
262. return new Vector(this.x+v.x, this.y+v.y);
263. }
265. public Vector neg() {
266. return new Vector(-this.x, -this.y);
267. }
269. public Vector mul(double m) {
270. return new Vector(m*this.x, m*this.y);
271. }
273. public Vector dotMul(Vector m) {
274. return new Vector(this.x * m.x, this.y * m.y);
275. }
276. public Vector dotMul(double m) {
277. return Vector.build(this.x*m, this.y*m);
278. }
280. public Vector dotDiv(Vector m) {
281. return new Vector(this.x/m.x, this.y/m.y);
282. }
284. public Vector dotDiv(double d) {
285. return Vector.build(this.x/d, this.y/d);
286. }
288. public String toString() {
289. return String.format("<%.2f, %.2f>", x, y);
290. }
292. }

配置代碼，可以查看不同的效果：

1. double scale = 80;
2. double aa = 3;
3. double dd = 0.15;
5. Area area = new Area(Vector.build(-aa, aa), Vector.build(aa, -aa));
6. Vector grid = Vector.build(dd, dd);
7. CanCalc c = new CanCalc(){
8. public double doCalc(Vector v) {
9. return v.x*v.x - v.y - 2;
10. }
12. };