1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * Test cases for the {@link ArrayFieldVector} class.
34   *
35   * @version $Revision: 783702 $ $Date: 2009-06-11 04:54:02 -0400 (Thu, 11 Jun 2009) $
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      // Testclass to test the FieldVector<Fraction> interface 
62      // only with enough content to support the test
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          /** Entries of the vector. */
71          protected T[] data;
72  
73          /** Build an array of elements.
74           * @param length size of the array to build
75           * @return a new array
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             // expected behavior
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             // expected behavior
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 //      ArrayFieldVector<Fraction> vout4 = (ArrayFieldVector<Fraction>) v1.clone();
371 //      assertEquals(3, vout4.getDimension());
372 //      assertEquals(v1.data, vout4.data);
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             // expected behavior
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             // expected behavior
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             // expected behavior
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             // expected behavior
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             // expected behavior
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         //octave =  v1 .+ 2.0
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         //octave =  v1 .+ 2.0
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         //octave =  v1 .- 2.0
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         //octave =  v1 .- 2.0
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         //octave =  v1 .* 2.0
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         //octave =  v1 .* 2.0
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         //octave =  v1 ./ 2.0
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         //octave =  v1 ./ 2.0
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         //octave =  v1 .^-1
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         //octave =  v1 .^-1
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         //octave =  v1 + v2
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         //octave =  v1 - v2
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         // octave v1 .* v2
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         // octave v1 ./ v2
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         // octave  dot(v1,v2)
552         Fraction dot =  v1.dotProduct(v2);
553         assertEquals("compare val ",new Fraction(32), dot);
554 
555         // octave  dot(v1,v2_t)
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          Fraction[] dout1 = v1.copyOut();
584         assertEquals(3, dout1.length);
585         assertNotSame("testData not same object ", v1.data, dout1);   
586          */      
587         try {
588             v1.checkVectorDimensions(2); 
589             fail("IllegalArgumentException expected");
590         } catch (IllegalArgumentException ex) {
591             // expected behavior
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             // expected behavior
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             // expected behavior
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     /** verifies that two vectors are equals */
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 }