1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.math.linear;
18
19 import java.io.Serializable;
20 import java.lang.reflect.Array;
21
22 import junit.framework.Test;
23 import junit.framework.TestCase;
24 import junit.framework.TestSuite;
25
26 import org.apache.commons.math.Field;
27 import org.apache.commons.math.FieldElement;
28 import org.apache.commons.math.TestUtils;
29 import org.apache.commons.math.fraction.Fraction;
30 import org.apache.commons.math.fraction.FractionField;
31
32
33
34
35
36
37 public class ArrayFieldVectorTest extends TestCase {
38
39
40 protected Fraction[][] ma1 = {
41 {new Fraction(1), new Fraction(2), new Fraction(3)},
42 {new Fraction(4), new Fraction(5), new Fraction(6)},
43 {new Fraction(7), new Fraction(8), new Fraction(9)}
44 };
45 protected Fraction[] vec1 = {new Fraction(1), new Fraction(2), new Fraction(3)};
46 protected Fraction[] vec2 = {new Fraction(4), new Fraction(5), new Fraction(6)};
47 protected Fraction[] vec3 = {new Fraction(7), new Fraction(8), new Fraction(9)};
48 protected Fraction[] vec4 = { new Fraction(1), new Fraction(2), new Fraction(3),
49 new Fraction(4), new Fraction(5), new Fraction(6),
50 new Fraction(7), new Fraction(8), new Fraction(9)};
51 protected Fraction[] vec_null = {new Fraction(0), new Fraction(0), new Fraction(0)};
52 protected Fraction[] dvec1 = {new Fraction(1), new Fraction(2), new Fraction(3),
53 new Fraction(4), new Fraction(5), new Fraction(6),
54 new Fraction(7), new Fraction(8), new Fraction(9)};
55 protected Fraction[][] mat1 = {
56 {new Fraction(1), new Fraction(2), new Fraction(3)},
57 {new Fraction(4), new Fraction(5), new Fraction(6)},
58 {new Fraction(7), new Fraction(8), new Fraction(9)}
59 };
60
61
62
63 public static class FieldVectorTestImpl<T extends FieldElement<T>>
64 implements FieldVector<T>, Serializable {
65
66 private static final long serialVersionUID = 3970959016014158539L;
67
68 private final Field<T> field;
69
70
71 protected T[] data;
72
73
74
75
76
77 @SuppressWarnings("unchecked")
78 private T[] buildArray(final int length) {
79 return (T[]) Array.newInstance(field.getZero().getClass(), length);
80 }
81
82 public FieldVectorTestImpl(T[] d) {
83 field = d[0].getField();
84 data = d.clone();
85 }
86
87 public Field<T> getField() {
88 return field;
89 }
90
91 private UnsupportedOperationException unsupported() {
92 return new UnsupportedOperationException("Not supported, unneeded for test purposes");
93 }
94
95 public FieldVector<T> copy() {
96 throw unsupported();
97 }
98
99 public FieldVector<T> add(FieldVector<T> v) throws IllegalArgumentException {
100 throw unsupported();
101 }
102
103 public FieldVector<T> add(T[] v) throws IllegalArgumentException {
104 throw unsupported();
105 }
106
107 public FieldVector<T> subtract(FieldVector<T> v) throws IllegalArgumentException {
108 throw unsupported();
109 }
110
111 public FieldVector<T> subtract(T[] v) throws IllegalArgumentException {
112 throw unsupported();
113 }
114
115 public FieldVector<T> mapAdd(T d) {
116 throw unsupported();
117 }
118
119 public FieldVector<T> mapAddToSelf(T d) {
120 throw unsupported();
121 }
122
123 public FieldVector<T> mapSubtract(T d) {
124 throw unsupported();
125 }
126
127 public FieldVector<T> mapSubtractToSelf(T d) {
128 throw unsupported();
129 }
130
131 public FieldVector<T> mapMultiply(T d) {
132 T[] out = buildArray(data.length);
133 for (int i = 0; i < data.length; i++) {
134 out[i] = data[i].multiply(d);
135 }
136 return new FieldVectorTestImpl<T>(out);
137 }
138
139 public FieldVector<T> mapMultiplyToSelf(T d) {
140 throw unsupported();
141 }
142
143 public FieldVector<T> mapDivide(T d) {
144 throw unsupported();
145 }
146
147 public FieldVector<T> mapDivideToSelf(T d) {
148 throw unsupported();
149 }
150
151 public FieldVector<T> mapInv() {
152 throw unsupported();
153 }
154
155 public FieldVector<T> mapInvToSelf() {
156 throw unsupported();
157 }
158
159 public FieldVector<T> ebeMultiply(FieldVector<T> v) throws IllegalArgumentException {
160 throw unsupported();
161 }
162
163 public FieldVector<T> ebeMultiply(T[] v) throws IllegalArgumentException {
164 throw unsupported();
165 }
166
167 public FieldVector<T> ebeDivide(FieldVector<T> v) throws IllegalArgumentException {
168 throw unsupported();
169 }
170
171 public FieldVector<T> ebeDivide(T[] v) throws IllegalArgumentException {
172 throw unsupported();
173 }
174
175 public T[] getData() {
176 return data.clone();
177 }
178
179 public T dotProduct(FieldVector<T> v) throws IllegalArgumentException {
180 T dot = field.getZero();
181 for (int i = 0; i < data.length; i++) {
182 dot = dot.add(data[i].multiply(v.getEntry(i)));
183 }
184 return dot;
185 }
186
187 public T dotProduct(T[] v) throws IllegalArgumentException {
188 T dot = field.getZero();
189 for (int i = 0; i < data.length; i++) {
190 dot = dot.add(data[i].multiply(v[i]));
191 }
192 return dot;
193 }
194
195 public FieldVector<T> projection(FieldVector<T> v) throws IllegalArgumentException {
196 throw unsupported();
197 }
198
199 public FieldVector<T> projection(T[] v) throws IllegalArgumentException {
200 throw unsupported();
201 }
202
203 public FieldMatrix<T> outerProduct(FieldVector<T> v) throws IllegalArgumentException {
204 throw unsupported();
205 }
206
207 public FieldMatrix<T> outerProduct(T[] v) throws IllegalArgumentException {
208 throw unsupported();
209 }
210
211 public T getEntry(int index) throws MatrixIndexException {
212 return data[index];
213 }
214
215 public int getDimension() {
216 return data.length;
217 }
218
219 public FieldVector<T> append(FieldVector<T> v) {
220 throw unsupported();
221 }
222
223 public FieldVector<T> append(T d) {
224 throw unsupported();
225 }
226
227 public FieldVector<T> append(T[] a) {
228 throw unsupported();
229 }
230
231 public FieldVector<T> getSubVector(int index, int n) throws MatrixIndexException {
232 throw unsupported();
233 }
234
235 public void setEntry(int index, T value) throws MatrixIndexException {
236 throw unsupported();
237 }
238
239 public void setSubVector(int index, FieldVector<T> v) throws MatrixIndexException {
240 throw unsupported();
241 }
242
243 public void setSubVector(int index, T[] v) throws MatrixIndexException {
244 throw unsupported();
245 }
246
247 public void set(T value) {
248 throw unsupported();
249 }
250
251 public T[] toArray() {
252 throw unsupported();
253 }
254
255 }
256
257 public static Test suite() {
258 TestSuite suite = new TestSuite(ArrayFieldVectorTest.class);
259 suite.setName("ArrayFieldVector<Fraction> Tests");
260 return suite;
261 }
262
263 public void testConstructors() {
264
265 ArrayFieldVector<Fraction> v0 = new ArrayFieldVector<Fraction>(FractionField.getInstance());
266 assertEquals(0, v0.getDimension());
267
268 ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(FractionField.getInstance(), 7);
269 assertEquals(7, v1.getDimension());
270 assertEquals(new Fraction(0), v1.getEntry(6));
271
272 ArrayFieldVector<Fraction> v2 = new ArrayFieldVector<Fraction>(5, new Fraction(123, 100));
273 assertEquals(5, v2.getDimension());
274 assertEquals(new Fraction(123, 100), v2.getEntry(4));
275
276 ArrayFieldVector<Fraction> v3 = new ArrayFieldVector<Fraction>(vec1);
277 assertEquals(3, v3.getDimension());
278 assertEquals(new Fraction(2), v3.getEntry(1));
279
280 ArrayFieldVector<Fraction> v4 = new ArrayFieldVector<Fraction>(vec4, 3, 2);
281 assertEquals(2, v4.getDimension());
282 assertEquals(new Fraction(4), v4.getEntry(0));
283 try {
284 new ArrayFieldVector<Fraction>(vec4, 8, 3);
285 fail("IllegalArgumentException expected");
286 } catch (IllegalArgumentException ex) {
287
288 } catch (Exception e) {
289 fail("wrong exception caught");
290 }
291
292 FieldVector<Fraction> v5_i = new ArrayFieldVector<Fraction>(dvec1);
293 assertEquals(9, v5_i.getDimension());
294 assertEquals(new Fraction(9), v5_i.getEntry(8));
295
296 ArrayFieldVector<Fraction> v5 = new ArrayFieldVector<Fraction>(dvec1);
297 assertEquals(9, v5.getDimension());
298 assertEquals(new Fraction(9), v5.getEntry(8));
299
300 ArrayFieldVector<Fraction> v6 = new ArrayFieldVector<Fraction>(dvec1, 3, 2);
301 assertEquals(2, v6.getDimension());
302 assertEquals(new Fraction(4), v6.getEntry(0));
303 try {
304 new ArrayFieldVector<Fraction>(dvec1, 8, 3);
305 fail("IllegalArgumentException expected");
306 } catch (IllegalArgumentException ex) {
307
308 } catch (Exception e) {
309 fail("wrong exception caught");
310 }
311
312 ArrayFieldVector<Fraction> v7 = new ArrayFieldVector<Fraction>(v1);
313 assertEquals(7, v7.getDimension());
314 assertEquals(new Fraction(0), v7.getEntry(6));
315
316 FieldVectorTestImpl<Fraction> v7_i = new FieldVectorTestImpl<Fraction>(vec1);
317
318 ArrayFieldVector<Fraction> v7_2 = new ArrayFieldVector<Fraction>(v7_i);
319 assertEquals(3, v7_2.getDimension());
320 assertEquals(new Fraction(2), v7_2.getEntry(1));
321
322 ArrayFieldVector<Fraction> v8 = new ArrayFieldVector<Fraction>(v1, true);
323 assertEquals(7, v8.getDimension());
324 assertEquals(new Fraction(0), v8.getEntry(6));
325 assertNotSame("testData not same object ", v1.data, v8.data);
326
327 ArrayFieldVector<Fraction> v8_2 = new ArrayFieldVector<Fraction>(v1, false);
328 assertEquals(7, v8_2.getDimension());
329 assertEquals(new Fraction(0), v8_2.getEntry(6));
330 assertEquals(v1.data, v8_2.data);
331
332 ArrayFieldVector<Fraction> v9 = new ArrayFieldVector<Fraction>(v1, v3);
333 assertEquals(10, v9.getDimension());
334 assertEquals(new Fraction(1), v9.getEntry(7));
335
336 }
337
338 public void testDataInOut() {
339
340 ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(vec1);
341 ArrayFieldVector<Fraction> v2 = new ArrayFieldVector<Fraction>(vec2);
342 ArrayFieldVector<Fraction> v4 = new ArrayFieldVector<Fraction>(vec4);
343 FieldVectorTestImpl<Fraction> v2_t = new FieldVectorTestImpl<Fraction>(vec2);
344
345 FieldVector<Fraction> v_append_1 = v1.append(v2);
346 assertEquals(6, v_append_1.getDimension());
347 assertEquals(new Fraction(4), v_append_1.getEntry(3));
348
349 FieldVector<Fraction> v_append_2 = v1.append(new Fraction(2));
350 assertEquals(4, v_append_2.getDimension());
351 assertEquals(new Fraction(2), v_append_2.getEntry(3));
352
353 FieldVector<Fraction> v_append_3 = v1.append(vec2);
354 assertEquals(6, v_append_3.getDimension());
355 assertEquals(new Fraction(4), v_append_3.getEntry(3));
356
357 FieldVector<Fraction> v_append_4 = v1.append(v2_t);
358 assertEquals(6, v_append_4.getDimension());
359 assertEquals(new Fraction(4), v_append_4.getEntry(3));
360
361 FieldVector<Fraction> v_copy = v1.copy();
362 assertEquals(3, v_copy.getDimension());
363 assertNotSame("testData not same object ", v1.data, v_copy.getData());
364
365 Fraction[] a_frac = v1.toArray();
366 assertEquals(3, a_frac.length);
367 assertNotSame("testData not same object ", v1.data, a_frac);
368
369
370
371
372
373
374
375 FieldVector<Fraction> vout5 = v4.getSubVector(3, 3);
376 assertEquals(3, vout5.getDimension());
377 assertEquals(new Fraction(5), vout5.getEntry(1));
378 try {
379 v4.getSubVector(3, 7);
380 fail("MatrixIndexException expected");
381 } catch (MatrixIndexException ex) {
382
383 } catch (Exception e) {
384 fail("wrong exception caught");
385 }
386
387 ArrayFieldVector<Fraction> v_set1 = (ArrayFieldVector<Fraction>) v1.copy();
388 v_set1.setEntry(1, new Fraction(11));
389 assertEquals(new Fraction(11), v_set1.getEntry(1));
390 try {
391 v_set1.setEntry(3, new Fraction(11));
392 fail("MatrixIndexException expected");
393 } catch (MatrixIndexException ex) {
394
395 } catch (Exception e) {
396 fail("wrong exception caught");
397 }
398
399 ArrayFieldVector<Fraction> v_set2 = (ArrayFieldVector<Fraction>) v4.copy();
400 v_set2.set(3, v1);
401 assertEquals(new Fraction(1), v_set2.getEntry(3));
402 assertEquals(new Fraction(7), v_set2.getEntry(6));
403 try {
404 v_set2.set(7, v1);
405 fail("MatrixIndexException expected");
406 } catch (MatrixIndexException ex) {
407
408 } catch (Exception e) {
409 fail("wrong exception caught");
410 }
411
412 ArrayFieldVector<Fraction> v_set3 = (ArrayFieldVector<Fraction>) v1.copy();
413 v_set3.set(new Fraction(13));
414 assertEquals(new Fraction(13), v_set3.getEntry(2));
415
416 try {
417 v_set3.getEntry(23);
418 fail("ArrayIndexOutOfBoundsException expected");
419 } catch (ArrayIndexOutOfBoundsException ex) {
420
421 } catch (Exception e) {
422 fail("wrong exception caught");
423 }
424
425 ArrayFieldVector<Fraction> v_set4 = (ArrayFieldVector<Fraction>) v4.copy();
426 v_set4.setSubVector(3, v2_t);
427 assertEquals(new Fraction(4), v_set4.getEntry(3));
428 assertEquals(new Fraction(7), v_set4.getEntry(6));
429 try {
430 v_set4.setSubVector(7, v2_t);
431 fail("MatrixIndexException expected");
432 } catch (MatrixIndexException ex) {
433
434 } catch (Exception e) {
435 fail("wrong exception caught");
436 }
437
438
439 ArrayFieldVector<Fraction> vout10 = (ArrayFieldVector<Fraction>) v1.copy();
440 ArrayFieldVector<Fraction> vout10_2 = (ArrayFieldVector<Fraction>) v1.copy();
441 assertEquals(vout10, vout10_2);
442 vout10_2.setEntry(0, new Fraction(11, 10));
443 assertNotSame(vout10, vout10_2);
444
445 }
446
447 public void testMapFunctions() {
448 ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(vec1);
449
450
451 FieldVector<Fraction> v_mapAdd = v1.mapAdd(new Fraction(2));
452 Fraction[] result_mapAdd = {new Fraction(3), new Fraction(4), new Fraction(5)};
453 checkArray("compare vectors" ,result_mapAdd,v_mapAdd.getData());
454
455
456 FieldVector<Fraction> v_mapAddToSelf = v1.copy();
457 v_mapAddToSelf.mapAddToSelf(new Fraction(2));
458 Fraction[] result_mapAddToSelf = {new Fraction(3), new Fraction(4), new Fraction(5)};
459 checkArray("compare vectors" ,result_mapAddToSelf,v_mapAddToSelf.getData());
460
461
462 FieldVector<Fraction> v_mapSubtract = v1.mapSubtract(new Fraction(2));
463 Fraction[] result_mapSubtract = {new Fraction(-1), new Fraction(0), new Fraction(1)};
464 checkArray("compare vectors" ,result_mapSubtract,v_mapSubtract.getData());
465
466
467 FieldVector<Fraction> v_mapSubtractToSelf = v1.copy();
468 v_mapSubtractToSelf.mapSubtractToSelf(new Fraction(2));
469 Fraction[] result_mapSubtractToSelf = {new Fraction(-1), new Fraction(0), new Fraction(1)};
470 checkArray("compare vectors" ,result_mapSubtractToSelf,v_mapSubtractToSelf.getData());
471
472
473 FieldVector<Fraction> v_mapMultiply = v1.mapMultiply(new Fraction(2));
474 Fraction[] result_mapMultiply = {new Fraction(2), new Fraction(4), new Fraction(6)};
475 checkArray("compare vectors" ,result_mapMultiply,v_mapMultiply.getData());
476
477
478 FieldVector<Fraction> v_mapMultiplyToSelf = v1.copy();
479 v_mapMultiplyToSelf.mapMultiplyToSelf(new Fraction(2));
480 Fraction[] result_mapMultiplyToSelf = {new Fraction(2), new Fraction(4), new Fraction(6)};
481 checkArray("compare vectors" ,result_mapMultiplyToSelf,v_mapMultiplyToSelf.getData());
482
483
484 FieldVector<Fraction> v_mapDivide = v1.mapDivide(new Fraction(2));
485 Fraction[] result_mapDivide = {new Fraction(1, 2), new Fraction(1), new Fraction(3, 2)};
486 checkArray("compare vectors" ,result_mapDivide,v_mapDivide.getData());
487
488
489 FieldVector<Fraction> v_mapDivideToSelf = v1.copy();
490 v_mapDivideToSelf.mapDivideToSelf(new Fraction(2));
491 Fraction[] result_mapDivideToSelf = {new Fraction(1, 2), new Fraction(1), new Fraction(3, 2)};
492 checkArray("compare vectors" ,result_mapDivideToSelf,v_mapDivideToSelf.getData());
493
494
495 FieldVector<Fraction> v_mapInv = v1.mapInv();
496 Fraction[] result_mapInv = {new Fraction(1),new Fraction(1, 2),new Fraction(1, 3)};
497 checkArray("compare vectors" ,result_mapInv,v_mapInv.getData());
498
499
500 FieldVector<Fraction> v_mapInvToSelf = v1.copy();
501 v_mapInvToSelf.mapInvToSelf();
502 Fraction[] result_mapInvToSelf = {new Fraction(1),new Fraction(1, 2),new Fraction(1, 3)};
503 checkArray("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData());
504
505 }
506
507 public void testBasicFunctions() {
508 ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(vec1);
509 ArrayFieldVector<Fraction> v2 = new ArrayFieldVector<Fraction>(vec2);
510 new ArrayFieldVector<Fraction>(vec_null);
511
512 FieldVectorTestImpl<Fraction> v2_t = new FieldVectorTestImpl<Fraction>(vec2);
513
514
515 ArrayFieldVector<Fraction> v_add = v1.add(v2);
516 Fraction[] result_add = {new Fraction(5), new Fraction(7), new Fraction(9)};
517 checkArray("compare vect" ,v_add.getData(),result_add);
518
519 FieldVectorTestImpl<Fraction> vt2 = new FieldVectorTestImpl<Fraction>(vec2);
520 FieldVector<Fraction> v_add_i = v1.add(vt2);
521 Fraction[] result_add_i = {new Fraction(5), new Fraction(7), new Fraction(9)};
522 checkArray("compare vect" ,v_add_i.getData(),result_add_i);
523
524
525 ArrayFieldVector<Fraction> v_subtract = v1.subtract(v2);
526 Fraction[] result_subtract = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
527 checkArray("compare vect" ,v_subtract.getData(),result_subtract);
528
529 FieldVector<Fraction> v_subtract_i = v1.subtract(vt2);
530 Fraction[] result_subtract_i = {new Fraction(-3), new Fraction(-3), new Fraction(-3)};
531 checkArray("compare vect" ,v_subtract_i.getData(),result_subtract_i);
532
533
534 ArrayFieldVector<Fraction> v_ebeMultiply = v1.ebeMultiply(v2);
535 Fraction[] result_ebeMultiply = {new Fraction(4), new Fraction(10), new Fraction(18)};
536 checkArray("compare vect" ,v_ebeMultiply.getData(),result_ebeMultiply);
537
538 FieldVector<Fraction> v_ebeMultiply_2 = v1.ebeMultiply(v2_t);
539 Fraction[] result_ebeMultiply_2 = {new Fraction(4), new Fraction(10), new Fraction(18)};
540 checkArray("compare vect" ,v_ebeMultiply_2.getData(),result_ebeMultiply_2);
541
542
543 ArrayFieldVector<Fraction> v_ebeDivide = v1.ebeDivide(v2);
544 Fraction[] result_ebeDivide = {new Fraction(1, 4), new Fraction(2, 5), new Fraction(1, 2)};
545 checkArray("compare vect" ,v_ebeDivide.getData(),result_ebeDivide);
546
547 FieldVector<Fraction> v_ebeDivide_2 = v1.ebeDivide(v2_t);
548 Fraction[] result_ebeDivide_2 = {new Fraction(1, 4), new Fraction(2, 5), new Fraction(1, 2)};
549 checkArray("compare vect" ,v_ebeDivide_2.getData(),result_ebeDivide_2);
550
551
552 Fraction dot = v1.dotProduct(v2);
553 assertEquals("compare val ",new Fraction(32), dot);
554
555
556 Fraction dot_2 = v1.dotProduct(v2_t);
557 assertEquals("compare val ",new Fraction(32), dot_2);
558
559 FieldMatrix<Fraction> m_outerProduct = v1.outerProduct(v2);
560 assertEquals("compare val ",new Fraction(4), m_outerProduct.getEntry(0,0));
561
562 FieldMatrix<Fraction> m_outerProduct_2 = v1.outerProduct(v2_t);
563 assertEquals("compare val ",new Fraction(4), m_outerProduct_2.getEntry(0,0));
564
565 ArrayFieldVector<Fraction> v_projection = v1.projection(v2);
566 Fraction[] result_projection = {new Fraction(128, 77), new Fraction(160, 77), new Fraction(192, 77)};
567 checkArray("compare vect", v_projection.getData(), result_projection);
568
569 FieldVector<Fraction> v_projection_2 = v1.projection(v2_t);
570 Fraction[] result_projection_2 = {new Fraction(128, 77), new Fraction(160, 77), new Fraction(192, 77)};
571 checkArray("compare vect", v_projection_2.getData(), result_projection_2);
572
573 }
574
575 public void testMisc() {
576 ArrayFieldVector<Fraction> v1 = new ArrayFieldVector<Fraction>(vec1);
577 ArrayFieldVector<Fraction> v4 = new ArrayFieldVector<Fraction>(vec4);
578 FieldVector<Fraction> v4_2 = new ArrayFieldVector<Fraction>(vec4);
579
580 String out1 = v1.toString();
581 assertTrue("some output ", out1.length()!=0);
582
583
584
585
586
587 try {
588 v1.checkVectorDimensions(2);
589 fail("IllegalArgumentException expected");
590 } catch (IllegalArgumentException ex) {
591
592 } catch (Exception e) {
593 fail("wrong exception caught");
594 }
595
596 try {
597 v1.checkVectorDimensions(v4);
598 fail("IllegalArgumentException expected");
599 } catch (IllegalArgumentException ex) {
600
601 } catch (Exception e) {
602 fail("wrong exception caught");
603 }
604
605 try {
606 v1.checkVectorDimensions(v4_2);
607 fail("IllegalArgumentException expected");
608 } catch (IllegalArgumentException ex) {
609
610 } catch (Exception e) {
611 fail("wrong exception caught");
612 }
613
614 }
615
616 public void testSerial() {
617 ArrayFieldVector<Fraction> v = new ArrayFieldVector<Fraction>(vec1);
618 assertEquals(v,TestUtils.serializeAndRecover(v));
619 }
620
621
622 protected void checkArray(String msg, Fraction[] m, Fraction[] n) {
623 if (m.length != n.length) {
624 fail("vectors have different lengths");
625 }
626 for (int i = 0; i < m.length; i++) {
627 assertEquals(msg + " " + i + " elements differ", m[i],n[i]);
628 }
629 }
630
631 }