001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     * 
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     * 
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.math.linear;
018    
019    import java.io.Serializable;
020    
021    import junit.framework.Test;
022    import junit.framework.TestCase;
023    import junit.framework.TestSuite;
024    
025    import org.apache.commons.math.TestUtils;
026    
027    /**
028     * Test cases for the {@link ArrayRealVector} class.
029     *
030     * @version $Revision: 783702 $ $Date: 2009-06-11 04:54:02 -0400 (Thu, 11 Jun 2009) $
031     */
032    public class ArrayRealVectorTest extends TestCase {
033    
034        // 
035        protected double[][] ma1 = {{1d, 2d, 3d}, {4d, 5d, 6d}, {7d, 8d, 9d}};
036        protected double[] vec1 = {1d, 2d, 3d};
037        protected double[] vec2 = {4d, 5d, 6d};
038        protected double[] vec3 = {7d, 8d, 9d};
039        protected double[] vec4 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d};
040        protected double[] vec_null = {0d, 0d, 0d};
041        protected Double[] dvec1 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d};
042        protected double[][] mat1 = {{1d, 2d, 3d}, {4d, 5d, 6d},{ 7d, 8d, 9d}};
043    
044        // tolerances
045        protected double entryTolerance = 10E-16;
046        protected double normTolerance = 10E-14;
047    
048        // Testclass to test the RealVector interface 
049        // only with enough content to support the test
050        public static class RealVectorTestImpl implements RealVector, Serializable {
051    
052            /** Serializable version identifier. */
053            private static final long serialVersionUID = 4715341047369582908L;
054    
055            /** Entries of the vector. */
056            protected double data[];
057    
058            public RealVectorTestImpl(double[] d) {
059                data = d.clone();
060            }
061    
062            private UnsupportedOperationException unsupported() {
063                return new UnsupportedOperationException("Not supported, unneeded for test purposes");
064            }
065    
066            public RealVector copy() {
067                throw unsupported();
068            }
069    
070            public RealVector add(RealVector v) throws IllegalArgumentException {
071                throw unsupported();
072            }
073    
074            public RealVector add(double[] v) throws IllegalArgumentException {
075                throw unsupported();
076            }
077    
078            public RealVector subtract(RealVector v) throws IllegalArgumentException {
079                throw unsupported();
080            }
081    
082            public RealVector subtract(double[] v) throws IllegalArgumentException {
083                throw unsupported();
084            }
085    
086            public RealVector mapAdd(double d) {
087                throw unsupported();
088            }
089    
090            public RealVector mapAddToSelf(double d) {
091                throw unsupported();
092            }
093    
094            public RealVector mapSubtract(double d) {
095                throw unsupported();
096            }
097    
098            public RealVector mapSubtractToSelf(double d) {
099                throw unsupported();
100            }
101    
102            public RealVector mapMultiply(double d) {
103                double[] out = new double[data.length];
104                for (int i = 0; i < data.length; i++) {
105                    out[i] = data[i] * d;
106                }
107                return new ArrayRealVector(out);
108            }
109    
110            public RealVector mapMultiplyToSelf(double d) {
111                throw unsupported();
112            }
113    
114            public RealVector mapDivide(double d) {
115                throw unsupported();
116            }
117    
118            public RealVector mapDivideToSelf(double d) {
119                throw unsupported();
120            }
121    
122            public RealVector mapPow(double d) {
123                throw unsupported();
124            }
125    
126            public RealVector mapPowToSelf(double d) {
127                throw unsupported();
128            }
129    
130            public RealVector mapExp() {
131                throw unsupported();
132            }
133    
134            public RealVector mapExpToSelf() {
135                throw unsupported();
136            }
137    
138            public RealVector mapExpm1() {
139                throw unsupported();
140            }
141    
142            public RealVector mapExpm1ToSelf() {
143                throw unsupported();
144            }
145    
146            public RealVector mapLog() {
147                throw unsupported();
148            }
149    
150            public RealVector mapLogToSelf() {
151                throw unsupported();
152            }
153    
154            public RealVector mapLog10() {
155                throw unsupported();
156            }
157    
158            public RealVector mapLog10ToSelf() {
159                throw unsupported();
160            }
161    
162            public RealVector mapLog1p() {
163                throw unsupported();
164            }
165    
166            public RealVector mapLog1pToSelf() {
167                throw unsupported();
168            }
169    
170            public RealVector mapCosh() {
171                throw unsupported();
172            }
173    
174            public RealVector mapCoshToSelf() {
175                throw unsupported();
176            }
177    
178            public RealVector mapSinh() {
179                throw unsupported();
180            }
181    
182            public RealVector mapSinhToSelf() {
183                throw unsupported();
184            }
185    
186            public RealVector mapTanh() {
187                throw unsupported();
188            }
189    
190            public RealVector mapTanhToSelf() {
191                throw unsupported();
192            }
193    
194            public RealVector mapCos() {
195                throw unsupported();
196            }
197    
198            public RealVector mapCosToSelf() {
199                throw unsupported();
200            }
201    
202            public RealVector mapSin() {
203                throw unsupported();
204            }
205    
206            public RealVector mapSinToSelf() {
207                throw unsupported();
208            }
209    
210            public RealVector mapTan() {
211                throw unsupported();
212            }
213    
214            public RealVector mapTanToSelf() {
215                throw unsupported();
216            }
217    
218            public RealVector mapAcos() {
219                throw unsupported();
220            }
221    
222            public RealVector mapAcosToSelf() {
223                throw unsupported();
224            }
225    
226            public RealVector mapAsin() {
227                throw unsupported();
228            }
229    
230            public RealVector mapAsinToSelf() {
231                throw unsupported();
232            }
233    
234            public RealVector mapAtan() {
235                throw unsupported();
236            }
237    
238            public RealVector mapAtanToSelf() {
239                throw unsupported();
240            }
241    
242            public RealVector mapInv() {
243                throw unsupported();
244            }
245    
246            public RealVector mapInvToSelf() {
247                throw unsupported();
248            }
249    
250            public RealVector mapAbs() {
251                throw unsupported();
252            }
253    
254            public RealVector mapAbsToSelf() {
255                throw unsupported();
256            }
257    
258            public RealVector mapSqrt() {
259                throw unsupported();
260            }
261    
262            public RealVector mapSqrtToSelf() {
263                throw unsupported();
264            }
265    
266            public RealVector mapCbrt() {
267                throw unsupported();
268            }
269    
270            public RealVector mapCbrtToSelf() {
271                throw unsupported();
272            }
273    
274            public RealVector mapCeil() {
275                throw unsupported();
276            }
277    
278            public RealVector mapCeilToSelf() {
279                throw unsupported();
280            }
281    
282            public RealVector mapFloor() {
283                throw unsupported();
284            }
285    
286            public RealVector mapFloorToSelf() {
287                throw unsupported();
288            }
289    
290            public RealVector mapRint() {
291                throw unsupported();
292            }
293    
294            public RealVector mapRintToSelf() {
295                throw unsupported();
296            }
297    
298            public RealVector mapSignum() {
299                throw unsupported();
300            }
301    
302            public RealVector mapSignumToSelf() {
303                throw unsupported();
304            }
305    
306            public RealVector mapUlp() {
307                throw unsupported();
308            }
309    
310            public RealVector mapUlpToSelf() {
311                throw unsupported();
312            }
313    
314            public RealVector ebeMultiply(RealVector v) throws IllegalArgumentException {
315                throw unsupported();
316            }
317    
318            public RealVector ebeMultiply(double[] v) throws IllegalArgumentException {
319                throw unsupported();
320            }
321    
322            public RealVector ebeDivide(RealVector v) throws IllegalArgumentException {
323                throw unsupported();
324            }
325    
326            public RealVector ebeDivide(double[] v) throws IllegalArgumentException {
327                throw unsupported();
328            }
329    
330            public double[] getData() {
331                return data.clone();
332            }
333    
334            public double dotProduct(RealVector v) throws IllegalArgumentException {
335                double dot = 0;
336                for (int i = 0; i < data.length; i++) {
337                    dot += data[i] * v.getEntry(i);
338                }
339                return dot;
340            }
341    
342            public double dotProduct(double[] v) throws IllegalArgumentException {
343                double dot = 0;
344                for (int i = 0; i < data.length; i++) {
345                    dot += data[i] * v[i];
346                }
347                return dot;
348            }
349    
350            public double getNorm() {
351                throw unsupported();
352            }
353    
354            public double getL1Norm() {
355                throw unsupported();
356            }
357    
358            public double getLInfNorm() {
359                throw unsupported();
360            }
361    
362            public double getDistance(RealVector v) throws IllegalArgumentException {
363                throw unsupported();
364            }
365    
366            public double getDistance(double[] v) throws IllegalArgumentException {
367                throw unsupported();
368            }
369    
370            public double getL1Distance(RealVector v) throws IllegalArgumentException {
371                throw unsupported();
372            }
373    
374            public double getL1Distance(double[] v) throws IllegalArgumentException {
375                throw unsupported();
376            }
377    
378            public double getLInfDistance(RealVector v) throws IllegalArgumentException {
379                throw unsupported();
380            }
381    
382            public double getLInfDistance(double[] v) throws IllegalArgumentException {
383                throw unsupported();
384            }
385    
386            public RealVector unitVector() {
387                throw unsupported();
388            }
389    
390            public void unitize() {
391                throw unsupported();
392            }
393    
394            public RealVector projection(RealVector v) throws IllegalArgumentException {
395                throw unsupported();
396            }
397    
398            public RealVector projection(double[] v) throws IllegalArgumentException {
399                throw unsupported();
400            }
401    
402            public RealMatrix outerProduct(RealVector v) throws IllegalArgumentException {
403                throw unsupported();
404            }
405    
406            public RealMatrix outerProduct(double[] v) throws IllegalArgumentException {
407                throw unsupported();
408            }
409    
410            public double getEntry(int index) throws MatrixIndexException {
411                return data[index];
412            }
413    
414            public int getDimension() {
415                return data.length;
416            }
417    
418            public RealVector append(RealVector v) {
419                throw unsupported();
420            }
421    
422            public RealVector append(double d) {
423                throw unsupported();
424            }
425    
426            public RealVector append(double[] a) {
427                throw unsupported();
428            }
429    
430            public RealVector getSubVector(int index, int n) throws MatrixIndexException {
431                throw unsupported();
432            }
433    
434            public void setEntry(int index, double value) throws MatrixIndexException {
435                throw unsupported();
436            }
437    
438            public void setSubVector(int index, RealVector v) throws MatrixIndexException {
439                throw unsupported();
440            }
441    
442            public void setSubVector(int index, double[] v) throws MatrixIndexException {
443                throw unsupported();
444            }
445    
446            public void set(double value) {
447                throw unsupported();
448            }
449    
450            public double[] toArray() {
451                throw unsupported();
452            }
453    
454            public boolean isNaN() {
455                throw unsupported();
456            }
457    
458            public boolean isInfinite() {
459                throw unsupported();
460            }
461    
462        }
463    
464        public static Test suite() {
465            TestSuite suite = new TestSuite(ArrayRealVectorTest.class);
466            suite.setName("ArrayRealVector Tests");
467            return suite;
468        }
469    
470        public void testConstructors() {
471    
472            ArrayRealVector v0 = new ArrayRealVector();
473            assertEquals("testData len", 0, v0.getDimension());
474    
475            ArrayRealVector v1 = new ArrayRealVector(7);
476            assertEquals("testData len", 7, v1.getDimension());
477            assertEquals("testData is 0.0 ", 0.0, v1.getEntry(6));
478    
479            ArrayRealVector v2 = new ArrayRealVector(5, 1.23);
480            assertEquals("testData len", 5, v2.getDimension());
481            assertEquals("testData is 1.23 ", 1.23, v2.getEntry(4));
482    
483            ArrayRealVector v3 = new ArrayRealVector(vec1);
484            assertEquals("testData len", 3, v3.getDimension());
485            assertEquals("testData is 2.0 ", 2.0, v3.getEntry(1));
486    
487            ArrayRealVector v4 = new ArrayRealVector(vec4, 3, 2);
488            assertEquals("testData len", 2, v4.getDimension());
489            assertEquals("testData is 4.0 ", 4.0, v4.getEntry(0));
490            try {
491                new ArrayRealVector(vec4, 8, 3);
492                fail("IllegalArgumentException expected");
493            } catch (IllegalArgumentException ex) {
494                // expected behavior
495            } catch (Exception e) {
496                fail("wrong exception caught");
497            }
498    
499            RealVector v5_i = new ArrayRealVector(dvec1);
500            assertEquals("testData len", 9, v5_i.getDimension());
501            assertEquals("testData is 9.0 ", 9.0, v5_i.getEntry(8));
502    
503            ArrayRealVector v5 = new ArrayRealVector(dvec1);
504            assertEquals("testData len", 9, v5.getDimension());
505            assertEquals("testData is 9.0 ", 9.0, v5.getEntry(8));
506    
507            ArrayRealVector v6 = new ArrayRealVector(dvec1, 3, 2);
508            assertEquals("testData len", 2, v6.getDimension());
509            assertEquals("testData is 4.0 ", 4.0, v6.getEntry(0));
510            try {
511                new ArrayRealVector(dvec1, 8, 3);
512                fail("IllegalArgumentException expected");
513            } catch (IllegalArgumentException ex) {
514                // expected behavior
515            } catch (Exception e) {
516                fail("wrong exception caught");
517            }
518    
519            ArrayRealVector v7 = new ArrayRealVector(v1);
520            assertEquals("testData len", 7, v7.getDimension());
521            assertEquals("testData is 0.0 ", 0.0, v7.getEntry(6));
522    
523            RealVectorTestImpl v7_i = new RealVectorTestImpl(vec1);
524    
525            ArrayRealVector v7_2 = new ArrayRealVector(v7_i);
526            assertEquals("testData len", 3, v7_2.getDimension());
527            assertEquals("testData is 0.0 ", 2.0d, v7_2.getEntry(1));
528    
529            ArrayRealVector v8 = new ArrayRealVector(v1, true);
530            assertEquals("testData len", 7, v8.getDimension());
531            assertEquals("testData is 0.0 ", 0.0, v8.getEntry(6));
532            assertNotSame("testData not same object ", v1.data, v8.data);
533    
534            ArrayRealVector v8_2 = new ArrayRealVector(v1, false);
535            assertEquals("testData len", 7, v8_2.getDimension());
536            assertEquals("testData is 0.0 ", 0.0, v8_2.getEntry(6));
537            assertEquals("testData same object ", v1.data, v8_2.data);
538    
539            ArrayRealVector v9 = new ArrayRealVector(v1, v3);
540            assertEquals("testData len", 10, v9.getDimension());
541            assertEquals("testData is 1.0 ", 1.0, v9.getEntry(7));
542    
543        }
544    
545        public void testDataInOut() {
546    
547            ArrayRealVector v1 = new ArrayRealVector(vec1);
548            ArrayRealVector v2 = new ArrayRealVector(vec2);
549            ArrayRealVector v4 = new ArrayRealVector(vec4);
550            RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); 
551    
552            RealVector v_append_1 = v1.append(v2);
553            assertEquals("testData len", 6, v_append_1.getDimension());
554            assertEquals("testData is 4.0 ", 4.0, v_append_1.getEntry(3));
555    
556            RealVector v_append_2 = v1.append(2.0);
557            assertEquals("testData len", 4, v_append_2.getDimension());
558            assertEquals("testData is 2.0 ", 2.0, v_append_2.getEntry(3));
559    
560            RealVector v_append_3 = v1.append(vec2);
561            assertEquals("testData len", 6, v_append_3.getDimension());
562            assertEquals("testData is  ", 4.0, v_append_3.getEntry(3));
563    
564            RealVector v_append_4 = v1.append(v2_t);
565            assertEquals("testData len", 6, v_append_4.getDimension());
566            assertEquals("testData is 4.0 ", 4.0, v_append_4.getEntry(3));
567    
568            RealVector v_copy = v1.copy();
569            assertEquals("testData len", 3, v_copy.getDimension());
570            assertNotSame("testData not same object ", v1.data, v_copy.getData());
571    
572            double[] a_double = v1.toArray();
573            assertEquals("testData len", 3, a_double.length);
574            assertNotSame("testData not same object ", v1.data, a_double);
575    
576    
577    //      ArrayRealVector vout4 = (ArrayRealVector) v1.clone();
578    //      assertEquals("testData len", 3, vout4.getDimension());
579    //      assertEquals("testData not same object ", v1.data, vout4.data);
580    
581    
582            RealVector vout5 = v4.getSubVector(3, 3);
583            assertEquals("testData len", 3, vout5.getDimension());
584            assertEquals("testData is 4.0 ", 5.0, vout5.getEntry(1));
585            try {
586                v4.getSubVector(3, 7);
587                fail("MatrixIndexException expected");
588            } catch (MatrixIndexException ex) {
589                // expected behavior
590            } catch (Exception e) {
591                fail("wrong exception caught");
592            }
593    
594            ArrayRealVector v_set1 = (ArrayRealVector) v1.copy();
595            v_set1.setEntry(1, 11.0);
596            assertEquals("testData is 11.0 ", 11.0, v_set1.getEntry(1));
597            try {
598                v_set1.setEntry(3, 11.0);
599                fail("MatrixIndexException expected");
600            } catch (MatrixIndexException ex) {
601                // expected behavior
602            } catch (Exception e) {
603                fail("wrong exception caught");
604            }
605    
606            ArrayRealVector v_set2 = (ArrayRealVector) v4.copy();
607            v_set2.set(3, v1);
608            assertEquals("testData is 1.0 ", 1.0, v_set2.getEntry(3));
609            assertEquals("testData is 7.0 ", 7.0, v_set2.getEntry(6));
610            try {
611                v_set2.set(7, v1);
612                fail("MatrixIndexException expected");
613            } catch (MatrixIndexException ex) {
614                // expected behavior
615            } catch (Exception e) {
616                fail("wrong exception caught");
617            }
618    
619            ArrayRealVector v_set3 = (ArrayRealVector) v1.copy();
620            v_set3.set(13.0);
621            assertEquals("testData is 13.0 ", 13.0, v_set3.getEntry(2));
622    
623            try {
624                v_set3.getEntry(23);
625                fail("ArrayIndexOutOfBoundsException expected");
626            } catch (ArrayIndexOutOfBoundsException ex) {
627                // expected behavior
628            } catch (Exception e) {
629                fail("wrong exception caught");
630            }
631    
632            ArrayRealVector v_set4 = (ArrayRealVector) v4.copy();
633            v_set4.setSubVector(3, v2_t);
634            assertEquals("testData is 1.0 ", 4.0, v_set4.getEntry(3));
635            assertEquals("testData is 7.0 ", 7.0, v_set4.getEntry(6));
636            try {
637                v_set4.setSubVector(7, v2_t);
638                fail("MatrixIndexException expected");
639            } catch (MatrixIndexException ex) {
640                // expected behavior
641            } catch (Exception e) {
642                fail("wrong exception caught");
643            }
644    
645    
646            ArrayRealVector vout10 = (ArrayRealVector) v1.copy();       
647            ArrayRealVector vout10_2 = (ArrayRealVector) v1.copy();
648            assertEquals(vout10, vout10_2);
649            vout10_2.setEntry(0, 1.1);
650            assertNotSame(vout10, vout10_2);
651    
652        }
653    
654        public void testMapFunctions() { 
655            ArrayRealVector v1 = new ArrayRealVector(vec1);
656    
657            //octave =  v1 .+ 2.0
658            RealVector v_mapAdd = v1.mapAdd(2.0d);
659            double[] result_mapAdd = {3d, 4d, 5d};
660            assertClose("compare vectors" ,result_mapAdd,v_mapAdd.getData(),normTolerance);
661    
662            //octave =  v1 .+ 2.0
663            RealVector v_mapAddToSelf = v1.copy();
664            v_mapAddToSelf.mapAddToSelf(2.0d);
665            double[] result_mapAddToSelf = {3d, 4d, 5d};
666            assertClose("compare vectors" ,result_mapAddToSelf,v_mapAddToSelf.getData(),normTolerance);
667    
668            //octave =  v1 .- 2.0
669            RealVector v_mapSubtract = v1.mapSubtract(2.0d);
670            double[] result_mapSubtract = {-1d, 0d, 1d};
671            assertClose("compare vectors" ,result_mapSubtract,v_mapSubtract.getData(),normTolerance);
672    
673            //octave =  v1 .- 2.0
674            RealVector v_mapSubtractToSelf = v1.copy();
675            v_mapSubtractToSelf.mapSubtractToSelf(2.0d);
676            double[] result_mapSubtractToSelf = {-1d, 0d, 1d};
677            assertClose("compare vectors" ,result_mapSubtractToSelf,v_mapSubtractToSelf.getData(),normTolerance);
678    
679            //octave =  v1 .* 2.0
680            RealVector v_mapMultiply = v1.mapMultiply(2.0d);
681            double[] result_mapMultiply = {2d, 4d, 6d};
682            assertClose("compare vectors" ,result_mapMultiply,v_mapMultiply.getData(),normTolerance);
683    
684            //octave =  v1 .* 2.0
685            RealVector v_mapMultiplyToSelf = v1.copy();
686            v_mapMultiplyToSelf.mapMultiplyToSelf(2.0d);
687            double[] result_mapMultiplyToSelf = {2d, 4d, 6d};
688            assertClose("compare vectors" ,result_mapMultiplyToSelf,v_mapMultiplyToSelf.getData(),normTolerance);
689    
690            //octave =  v1 ./ 2.0
691            RealVector v_mapDivide = v1.mapDivide(2.0d);
692            double[] result_mapDivide = {.5d, 1d, 1.5d};
693            assertClose("compare vectors" ,result_mapDivide,v_mapDivide.getData(),normTolerance);
694    
695            //octave =  v1 ./ 2.0
696            RealVector v_mapDivideToSelf = v1.copy();
697            v_mapDivideToSelf.mapDivideToSelf(2.0d);
698            double[] result_mapDivideToSelf = {.5d, 1d, 1.5d};
699            assertClose("compare vectors" ,result_mapDivideToSelf,v_mapDivideToSelf.getData(),normTolerance);
700    
701            //octave =  v1 .^ 2.0
702            RealVector v_mapPow = v1.mapPow(2.0d);
703            double[] result_mapPow = {1d, 4d, 9d};
704            assertClose("compare vectors" ,result_mapPow,v_mapPow.getData(),normTolerance);
705    
706            //octave =  v1 .^ 2.0
707            RealVector v_mapPowToSelf = v1.copy();
708            v_mapPowToSelf.mapPowToSelf(2.0d);
709            double[] result_mapPowToSelf = {1d, 4d, 9d};
710            assertClose("compare vectors" ,result_mapPowToSelf,v_mapPowToSelf.getData(),normTolerance);
711    
712            //octave =  exp(v1)
713            RealVector v_mapExp = v1.mapExp();
714            double[] result_mapExp = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d};
715            assertClose("compare vectors" ,result_mapExp,v_mapExp.getData(),normTolerance);
716    
717            //octave =  exp(v1)
718            RealVector v_mapExpToSelf = v1.copy();
719            v_mapExpToSelf.mapExpToSelf();
720            double[] result_mapExpToSelf = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d};
721            assertClose("compare vectors" ,result_mapExpToSelf,v_mapExpToSelf.getData(),normTolerance);
722    
723    
724            //octave =  ???
725            RealVector v_mapExpm1 = v1.mapExpm1();
726            double[] result_mapExpm1 = {1.718281828459045d,6.38905609893065d, 19.085536923187668d};
727            assertClose("compare vectors" ,result_mapExpm1,v_mapExpm1.getData(),normTolerance);
728    
729            //octave =  ???
730            RealVector v_mapExpm1ToSelf = v1.copy();
731            v_mapExpm1ToSelf.mapExpm1ToSelf();
732            double[] result_mapExpm1ToSelf = {1.718281828459045d,6.38905609893065d, 19.085536923187668d};
733            assertClose("compare vectors" ,result_mapExpm1ToSelf,v_mapExpm1ToSelf.getData(),normTolerance);
734    
735            //octave =  log(v1)
736            RealVector v_mapLog = v1.mapLog();
737            double[] result_mapLog = {0d,6.931471805599453e-01d, 1.098612288668110e+00d};
738            assertClose("compare vectors" ,result_mapLog,v_mapLog.getData(),normTolerance);
739    
740            //octave =  log(v1)
741            RealVector v_mapLogToSelf = v1.copy();
742            v_mapLogToSelf.mapLogToSelf();
743            double[] result_mapLogToSelf = {0d,6.931471805599453e-01d, 1.098612288668110e+00d};
744            assertClose("compare vectors" ,result_mapLogToSelf,v_mapLogToSelf.getData(),normTolerance);
745    
746            //octave =  log10(v1)
747            RealVector v_mapLog10 = v1.mapLog10();
748            double[] result_mapLog10 = {0d,3.010299956639812e-01d, 4.771212547196624e-01d};
749            assertClose("compare vectors" ,result_mapLog10,v_mapLog10.getData(),normTolerance);
750    
751            //octave =  log(v1)
752            RealVector v_mapLog10ToSelf = v1.copy();
753            v_mapLog10ToSelf.mapLog10ToSelf();
754            double[] result_mapLog10ToSelf = {0d,3.010299956639812e-01d, 4.771212547196624e-01d};
755            assertClose("compare vectors" ,result_mapLog10ToSelf,v_mapLog10ToSelf.getData(),normTolerance);
756    
757            //octave =  ???
758            RealVector v_mapLog1p = v1.mapLog1p();
759            double[] result_mapLog1p = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d};
760            assertClose("compare vectors" ,result_mapLog1p,v_mapLog1p.getData(),normTolerance);
761    
762            //octave =  ???
763            RealVector v_mapLog1pToSelf = v1.copy();
764            v_mapLog1pToSelf.mapLog1pToSelf();
765            double[] result_mapLog1pToSelf = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d};
766            assertClose("compare vectors" ,result_mapLog1pToSelf,v_mapLog1pToSelf.getData(),normTolerance);
767    
768            //octave =  cosh(v1)
769            RealVector v_mapCosh = v1.mapCosh();
770            double[] result_mapCosh = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d};
771            assertClose("compare vectors" ,result_mapCosh,v_mapCosh.getData(),normTolerance);
772    
773            //octave =  cosh(v1)
774            RealVector v_mapCoshToSelf = v1.copy();
775            v_mapCoshToSelf.mapCoshToSelf();
776            double[] result_mapCoshToSelf = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d};
777            assertClose("compare vectors" ,result_mapCoshToSelf,v_mapCoshToSelf.getData(),normTolerance);
778    
779            //octave =  sinh(v1)
780            RealVector v_mapSinh = v1.mapSinh();
781            double[] result_mapSinh = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d};
782            assertClose("compare vectors" ,result_mapSinh,v_mapSinh.getData(),normTolerance);
783    
784            //octave =  sinh(v1)
785            RealVector v_mapSinhToSelf = v1.copy();
786            v_mapSinhToSelf.mapSinhToSelf();
787            double[] result_mapSinhToSelf = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d};
788            assertClose("compare vectors" ,result_mapSinhToSelf,v_mapSinhToSelf.getData(),normTolerance);
789    
790            //octave =  tanh(v1)
791            RealVector v_mapTanh = v1.mapTanh();
792            double[] result_mapTanh = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d};
793            assertClose("compare vectors" ,result_mapTanh,v_mapTanh.getData(),normTolerance);
794    
795            //octave =  tanh(v1)
796            RealVector v_mapTanhToSelf = v1.copy();
797            v_mapTanhToSelf.mapTanhToSelf();
798            double[] result_mapTanhToSelf = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d};
799            assertClose("compare vectors" ,result_mapTanhToSelf,v_mapTanhToSelf.getData(),normTolerance);
800    
801            //octave =  cos(v1)
802            RealVector v_mapCos = v1.mapCos();
803            double[] result_mapCos = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d};
804            assertClose("compare vectors" ,result_mapCos,v_mapCos.getData(),normTolerance);
805    
806            //octave =  cos(v1)
807            RealVector v_mapCosToSelf = v1.copy();
808            v_mapCosToSelf.mapCosToSelf();
809            double[] result_mapCosToSelf = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d};
810            assertClose("compare vectors" ,result_mapCosToSelf,v_mapCosToSelf.getData(),normTolerance);
811    
812            //octave =  sin(v1)
813            RealVector v_mapSin = v1.mapSin();
814            double[] result_mapSin = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d};
815            assertClose("compare vectors" ,result_mapSin,v_mapSin.getData(),normTolerance);
816    
817            //octave =  sin(v1)
818            RealVector v_mapSinToSelf = v1.copy();
819            v_mapSinToSelf.mapSinToSelf();
820            double[] result_mapSinToSelf = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d};
821            assertClose("compare vectors" ,result_mapSinToSelf,v_mapSinToSelf.getData(),normTolerance);
822    
823            //octave =  tan(v1)
824            RealVector v_mapTan = v1.mapTan();
825            double[] result_mapTan = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d};
826            assertClose("compare vectors" ,result_mapTan,v_mapTan.getData(),normTolerance);
827    
828            //octave =  tan(v1)
829            RealVector v_mapTanToSelf = v1.copy();
830            v_mapTanToSelf.mapTanToSelf();
831            double[] result_mapTanToSelf = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d};
832            assertClose("compare vectors" ,result_mapTanToSelf,v_mapTanToSelf.getData(),normTolerance);
833    
834            double[] vat_a = {0d, 0.5d, 1.0d};
835            ArrayRealVector vat = new ArrayRealVector(vat_a);
836    
837            //octave =  acos(vat)
838            RealVector v_mapAcos = vat.mapAcos();
839            double[] result_mapAcos = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d};
840            assertClose("compare vectors" ,result_mapAcos,v_mapAcos.getData(),normTolerance);
841    
842            //octave =  acos(vat)
843            RealVector v_mapAcosToSelf = vat.copy();
844            v_mapAcosToSelf.mapAcosToSelf();
845            double[] result_mapAcosToSelf = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d};
846            assertClose("compare vectors" ,result_mapAcosToSelf,v_mapAcosToSelf.getData(),normTolerance);
847    
848            //octave =  asin(vat)
849            RealVector v_mapAsin = vat.mapAsin();
850            double[] result_mapAsin = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d};
851            assertClose("compare vectors" ,result_mapAsin,v_mapAsin.getData(),normTolerance);
852    
853            //octave =  asin(vat)
854            RealVector v_mapAsinToSelf = vat.copy();
855            v_mapAsinToSelf.mapAsinToSelf();        
856            double[] result_mapAsinToSelf = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d};
857            assertClose("compare vectors" ,result_mapAsinToSelf,v_mapAsinToSelf.getData(),normTolerance);
858    
859            //octave =  atan(vat)
860            RealVector v_mapAtan = vat.mapAtan();
861            double[] result_mapAtan = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d};
862            assertClose("compare vectors" ,result_mapAtan,v_mapAtan.getData(),normTolerance);
863    
864            //octave =  atan(vat)
865            RealVector v_mapAtanToSelf = vat.copy();
866            v_mapAtanToSelf.mapAtanToSelf();
867            double[] result_mapAtanToSelf = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d};
868            assertClose("compare vectors" ,result_mapAtanToSelf,v_mapAtanToSelf.getData(),normTolerance);
869    
870            //octave =  v1 .^-1
871            RealVector v_mapInv = v1.mapInv();
872            double[] result_mapInv = {1d,0.5d,3.333333333333333e-01d};
873            assertClose("compare vectors" ,result_mapInv,v_mapInv.getData(),normTolerance);
874    
875            //octave =  v1 .^-1
876            RealVector v_mapInvToSelf = v1.copy();
877            v_mapInvToSelf.mapInvToSelf();
878            double[] result_mapInvToSelf = {1d,0.5d,3.333333333333333e-01d};
879            assertClose("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData(),normTolerance);
880    
881            double[] abs_a = {-1.0d, 0.0d, 1.0d};
882            ArrayRealVector abs_v = new ArrayRealVector(abs_a);
883    
884            //octave =  abs(abs_v)
885            RealVector v_mapAbs = abs_v.mapAbs();
886            double[] result_mapAbs = {1d,0d,1d};
887            assertClose("compare vectors" ,result_mapAbs,v_mapAbs.getData(),normTolerance);
888    
889            //octave = abs(abs_v)
890            RealVector v_mapAbsToSelf = abs_v.copy();
891            v_mapAbsToSelf.mapAbsToSelf();
892            double[] result_mapAbsToSelf = {1d,0d,1d};
893            assertClose("compare vectors" ,result_mapAbsToSelf,v_mapAbsToSelf.getData(),normTolerance);
894    
895            //octave =   sqrt(v1)
896            RealVector v_mapSqrt = v1.mapSqrt();
897            double[] result_mapSqrt = {1d,1.414213562373095e+00d,1.732050807568877e+00d};
898            assertClose("compare vectors" ,result_mapSqrt,v_mapSqrt.getData(),normTolerance);
899    
900            //octave =  sqrt(v1)
901            RealVector v_mapSqrtToSelf = v1.copy();
902            v_mapSqrtToSelf.mapSqrtToSelf();
903            double[] result_mapSqrtToSelf = {1d,1.414213562373095e+00d,1.732050807568877e+00d};
904            assertClose("compare vectors" ,result_mapSqrtToSelf,v_mapSqrtToSelf.getData(),normTolerance);
905    
906            double[] cbrt_a = {-2.0d, 0.0d, 2.0d};
907            ArrayRealVector cbrt_v = new ArrayRealVector(cbrt_a);
908    
909            //octave =  ???
910            RealVector v_mapCbrt = cbrt_v.mapCbrt();
911            double[] result_mapCbrt = {-1.2599210498948732d,0d,1.2599210498948732d};
912            assertClose("compare vectors" ,result_mapCbrt,v_mapCbrt.getData(),normTolerance);
913    
914            //octave = ???
915            RealVector v_mapCbrtToSelf = cbrt_v.copy();
916            v_mapCbrtToSelf.mapCbrtToSelf();
917            double[] result_mapCbrtToSelf =  {-1.2599210498948732d,0d,1.2599210498948732d};
918            assertClose("compare vectors" ,result_mapCbrtToSelf,v_mapCbrtToSelf.getData(),normTolerance);
919    
920            double[] ceil_a = {-1.1d, 0.9d, 1.1d};
921            ArrayRealVector ceil_v = new ArrayRealVector(ceil_a);
922    
923            //octave =  ceil(ceil_v)
924            RealVector v_mapCeil = ceil_v.mapCeil();
925            double[] result_mapCeil = {-1d,1d,2d};
926            assertClose("compare vectors" ,result_mapCeil,v_mapCeil.getData(),normTolerance);
927    
928            //octave = ceil(ceil_v)
929            RealVector v_mapCeilToSelf = ceil_v.copy();
930            v_mapCeilToSelf.mapCeilToSelf();
931            double[] result_mapCeilToSelf =  {-1d,1d,2d};
932            assertClose("compare vectors" ,result_mapCeilToSelf,v_mapCeilToSelf.getData(),normTolerance);
933    
934            //octave =  floor(ceil_v)
935            RealVector v_mapFloor = ceil_v.mapFloor();
936            double[] result_mapFloor = {-2d,0d,1d};
937            assertClose("compare vectors" ,result_mapFloor,v_mapFloor.getData(),normTolerance);
938    
939            //octave = floor(ceil_v)
940            RealVector v_mapFloorToSelf = ceil_v.copy();
941            v_mapFloorToSelf.mapFloorToSelf();
942            double[] result_mapFloorToSelf =  {-2d,0d,1d};
943            assertClose("compare vectors" ,result_mapFloorToSelf,v_mapFloorToSelf.getData(),normTolerance);
944    
945            //octave =  ???
946            RealVector v_mapRint = ceil_v.mapRint();
947            double[] result_mapRint = {-1d,1d,1d};
948            assertClose("compare vectors" ,result_mapRint,v_mapRint.getData(),normTolerance);
949    
950            //octave = ???
951            RealVector v_mapRintToSelf = ceil_v.copy();
952            v_mapRintToSelf.mapRintToSelf();
953            double[] result_mapRintToSelf =  {-1d,1d,1d};
954            assertClose("compare vectors" ,result_mapRintToSelf,v_mapRintToSelf.getData(),normTolerance);
955    
956            //octave =  ???
957            RealVector v_mapSignum = ceil_v.mapSignum();
958            double[] result_mapSignum = {-1d,1d,1d};
959            assertClose("compare vectors" ,result_mapSignum,v_mapSignum.getData(),normTolerance);
960    
961            //octave = ???
962            RealVector v_mapSignumToSelf = ceil_v.copy();
963            v_mapSignumToSelf.mapSignumToSelf();
964            double[] result_mapSignumToSelf =  {-1d,1d,1d};
965            assertClose("compare vectors" ,result_mapSignumToSelf,v_mapSignumToSelf.getData(),normTolerance);
966    
967    
968            // Is with the used resolutions of limited value as test
969            //octave =  ???
970            RealVector v_mapUlp = ceil_v.mapUlp();
971            double[] result_mapUlp = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d};
972            assertClose("compare vectors" ,result_mapUlp,v_mapUlp.getData(),normTolerance);
973    
974            //octave = ???
975            RealVector v_mapUlpToSelf = ceil_v.copy();
976            v_mapUlpToSelf.mapUlpToSelf();
977            double[] result_mapUlpToSelf = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d};
978            assertClose("compare vectors" ,result_mapUlpToSelf,v_mapUlpToSelf.getData(),normTolerance);
979    
980        }
981    
982        public void testBasicFunctions() { 
983            ArrayRealVector v1 = new ArrayRealVector(vec1);
984            ArrayRealVector v2 = new ArrayRealVector(vec2);
985            ArrayRealVector v_null = new ArrayRealVector(vec_null);
986    
987            RealVectorTestImpl v2_t = new RealVectorTestImpl(vec2); 
988    
989            //octave =  sqrt(sumsq(v1))
990            double d_getNorm = v1.getNorm();
991            assertEquals("compare values  ", 3.7416573867739413,d_getNorm);
992    
993            double d_getL1Norm = v1.getL1Norm();
994            assertEquals("compare values  ",6.0, d_getL1Norm);
995    
996            double d_getLInfNorm = v1.getLInfNorm();
997            assertEquals("compare values  ",6.0, d_getLInfNorm);
998    
999            //octave =  sqrt(sumsq(v1-v2))
1000            double dist = v1.getDistance(v2);
1001            assertEquals("compare values  ",v1.subtract(v2).getNorm(), dist );
1002    
1003            //octave =  sqrt(sumsq(v1-v2))
1004            double dist_2 = v1.getDistance(v2_t);
1005            assertEquals("compare values  ", v1.subtract(v2).getNorm(),dist_2 );
1006    
1007            //octave =  ???
1008            double d_getL1Distance = v1. getL1Distance(v2);
1009            assertEquals("compare values  ",9d, d_getL1Distance );
1010    
1011            double d_getL1Distance_2 = v1. getL1Distance(v2_t);
1012            assertEquals("compare values  ",9d, d_getL1Distance_2 );
1013    
1014            //octave =  ???
1015            double d_getLInfDistance = v1. getLInfDistance(v2);
1016            assertEquals("compare values  ",3d, d_getLInfDistance );
1017    
1018            double d_getLInfDistance_2 = v1. getLInfDistance(v2_t);
1019            assertEquals("compare values  ",3d, d_getLInfDistance_2 );
1020    
1021            //octave =  v1 + v2
1022            ArrayRealVector v_add = v1.add(v2);
1023            double[] result_add = {5d, 7d, 9d};
1024            assertClose("compare vect" ,v_add.getData(),result_add,normTolerance);
1025    
1026            RealVectorTestImpl vt2 = new RealVectorTestImpl(vec2);
1027            RealVector v_add_i = v1.add(vt2);
1028            double[] result_add_i = {5d, 7d, 9d};
1029            assertClose("compare vect" ,v_add_i.getData(),result_add_i,normTolerance);
1030    
1031            //octave =  v1 - v2
1032            ArrayRealVector v_subtract = v1.subtract(v2);
1033            double[] result_subtract = {-3d, -3d, -3d};
1034            assertClose("compare vect" ,v_subtract.getData(),result_subtract,normTolerance);
1035    
1036            RealVector v_subtract_i = v1.subtract(vt2);
1037            double[] result_subtract_i = {-3d, -3d, -3d};
1038            assertClose("compare vect" ,v_subtract_i.getData(),result_subtract_i,normTolerance);
1039    
1040            // octave v1 .* v2
1041            ArrayRealVector  v_ebeMultiply = v1.ebeMultiply(v2);
1042            double[] result_ebeMultiply = {4d, 10d, 18d};
1043            assertClose("compare vect" ,v_ebeMultiply.getData(),result_ebeMultiply,normTolerance);
1044    
1045            RealVector  v_ebeMultiply_2 = v1.ebeMultiply(v2_t);
1046            double[] result_ebeMultiply_2 = {4d, 10d, 18d};
1047            assertClose("compare vect" ,v_ebeMultiply_2.getData(),result_ebeMultiply_2,normTolerance);
1048    
1049            // octave v1 ./ v2
1050            ArrayRealVector  v_ebeDivide = v1.ebeDivide(v2);
1051            double[] result_ebeDivide = {0.25d, 0.4d, 0.5d};
1052            assertClose("compare vect" ,v_ebeDivide.getData(),result_ebeDivide,normTolerance);
1053    
1054            RealVector  v_ebeDivide_2 = v1.ebeDivide(v2_t);
1055            double[] result_ebeDivide_2 = {0.25d, 0.4d, 0.5d};
1056            assertClose("compare vect" ,v_ebeDivide_2.getData(),result_ebeDivide_2,normTolerance);
1057    
1058            // octave  dot(v1,v2)
1059            double dot =  v1.dotProduct(v2);
1060            assertEquals("compare val ",32d, dot);
1061    
1062            // octave  dot(v1,v2_t)
1063            double dot_2 =  v1.dotProduct(v2_t);
1064            assertEquals("compare val ",32d, dot_2);
1065    
1066            RealMatrix m_outerProduct = v1.outerProduct(v2);
1067            assertEquals("compare val ",4d, m_outerProduct.getEntry(0,0));
1068    
1069            RealMatrix m_outerProduct_2 = v1.outerProduct(v2_t);
1070            assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0));
1071    
1072            RealVector v_unitVector = v1.unitVector();
1073            RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm()); 
1074            assertClose("compare vect" ,v_unitVector.getData(),v_unitVector_2.getData(),normTolerance);
1075    
1076            try {
1077                v_null.unitVector();
1078                fail("Expecting ArithmeticException");
1079            } catch (ArithmeticException ex) {
1080                // expected behavior
1081            } catch (Exception e) {
1082                fail("wrong exception caught");
1083            }
1084    
1085            ArrayRealVector v_unitize = (ArrayRealVector)v1.copy();
1086            v_unitize.unitize();
1087            assertClose("compare vect" ,v_unitVector_2.getData(),v_unitize.getData(),normTolerance);
1088            try {
1089                v_null.unitize();
1090                fail("Expecting ArithmeticException");
1091            } catch (ArithmeticException ex) {
1092                // expected behavior
1093            } catch (Exception e) {
1094                fail("wrong exception caught");
1095            }
1096    
1097            ArrayRealVector v_projection = v1.projection(v2);
1098            double[] result_projection = {1.662337662337662, 2.0779220779220777, 2.493506493506493};
1099            assertClose("compare vect", v_projection.getData(), result_projection, normTolerance);
1100    
1101            RealVector v_projection_2 = v1.projection(v2_t);
1102            double[] result_projection_2 = {1.662337662337662, 2.0779220779220777, 2.493506493506493};
1103            assertClose("compare vect", v_projection_2.getData(), result_projection_2, normTolerance);
1104    
1105        }  
1106    
1107        public void testMisc() { 
1108            ArrayRealVector v1 = new ArrayRealVector(vec1);
1109            ArrayRealVector v4 = new ArrayRealVector(vec4);
1110            RealVector v4_2 = new ArrayRealVector(vec4);
1111    
1112            String out1 = v1.toString();
1113            assertTrue("some output ",  out1.length()!=0);
1114            /*    
1115             double[] dout1 = v1.copyOut();
1116            assertEquals("testData len", 3, dout1.length);
1117            assertNotSame("testData not same object ", v1.data, dout1);   
1118             */      
1119            try {
1120                v1.checkVectorDimensions(2); 
1121                fail("IllegalArgumentException expected");
1122            } catch (IllegalArgumentException ex) {
1123                // expected behavior
1124            } catch (Exception e) {
1125                fail("wrong exception caught");
1126            } 
1127    
1128           try {
1129                v1.checkVectorDimensions(v4); 
1130                fail("IllegalArgumentException expected");
1131            } catch (IllegalArgumentException ex) {
1132                // expected behavior
1133            } catch (Exception e) {
1134                fail("wrong exception caught");
1135            }        
1136    
1137            try {
1138                v1.checkVectorDimensions(v4_2); 
1139                fail("IllegalArgumentException expected");
1140            } catch (IllegalArgumentException ex) {
1141                // expected behavior
1142            } catch (Exception e) {
1143                fail("wrong exception caught");
1144            }        
1145    
1146        }
1147    
1148        public void testPredicates() {
1149    
1150            ArrayRealVector v = new ArrayRealVector(new double[] { 0, 1, 2 });
1151    
1152            assertFalse(v.isNaN());
1153            v.setEntry(1, Double.NaN);
1154            assertTrue(v.isNaN());
1155    
1156            assertFalse(v.isInfinite());
1157            v.setEntry(0, Double.POSITIVE_INFINITY);
1158            assertFalse(v.isInfinite());
1159            v.setEntry(1, 1);
1160            assertTrue(v.isInfinite());
1161    
1162            v.setEntry(0, 0);
1163            assertEquals(v, new ArrayRealVector(new double[] { 0, 1, 2 }));
1164            assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2 + Math.ulp(2)}));
1165            assertNotSame(v, new ArrayRealVector(new double[] { 0, 1, 2, 3 }));
1166    
1167            assertEquals(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode(),
1168                         new ArrayRealVector(new double[] { 0, Double.NaN, 2 }).hashCode());
1169    
1170            assertTrue(new ArrayRealVector(new double[] { Double.NaN, 1, 2 }).hashCode() !=
1171                       new ArrayRealVector(new double[] { 0, 1, 2 }).hashCode());
1172    
1173        }
1174    
1175        public void testSerial()  {
1176            ArrayRealVector v = new ArrayRealVector(new double[] { 0, 1, 2 });
1177            assertEquals(v,TestUtils.serializeAndRecover(v));
1178        }
1179        
1180        
1181        /** verifies that two vectors are close (sup norm) */
1182        protected void assertClose(String msg, double[] m, double[] n,
1183                double tolerance) {
1184            if (m.length != n.length) {
1185                fail("vectors have different lengths");
1186            }
1187            for (int i = 0; i < m.length; i++) {
1188                assertEquals(msg + " " +  i + " elements differ", m[i],n[i],tolerance);
1189            }
1190        }
1191    
1192    }