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
21 import junit.framework.Test;
22 import junit.framework.TestCase;
23 import junit.framework.TestSuite;
24
25 import org.apache.commons.math.TestUtils;
26
27
28
29
30
31
32 public class SparseRealVectorTest extends TestCase {
33
34
35 protected double[][] ma1 = {{1d, 2d, 3d}, {4d, 5d, 6d}, {7d, 8d, 9d}};
36 protected double[] vec1 = {1d, 2d, 3d};
37 protected double[] vec2 = {4d, 5d, 6d};
38 protected double[] vec3 = {7d, 8d, 9d};
39 protected double[] vec4 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d};
40 protected double[] vec_null = {0d, 0d, 0d};
41 protected Double[] dvec1 = {1d, 2d, 3d, 4d, 5d, 6d, 7d, 8d, 9d};
42 protected double[][] mat1 = {{1d, 2d, 3d}, {4d, 5d, 6d},{ 7d, 8d, 9d}};
43
44
45 protected double entryTolerance = 10E-16;
46 protected double normTolerance = 10E-14;
47
48
49
50 public static class SparseRealVectorTestImpl implements RealVector, Serializable {
51
52
53 private static final long serialVersionUID = 4715341047369582908L;
54
55
56 protected double data[];
57
58 public SparseRealVectorTestImpl(double[] d) {
59 data = d.clone();
60 }
61
62 private UnsupportedOperationException unsupported() {
63 return new UnsupportedOperationException("Not supported, unneeded for test purposes");
64 }
65
66 public RealVector copy() {
67 throw unsupported();
68 }
69
70 public RealVector add(RealVector v) throws IllegalArgumentException {
71 throw unsupported();
72 }
73
74 public RealVector add(double[] v) throws IllegalArgumentException {
75 throw unsupported();
76 }
77
78 public RealVector subtract(RealVector v) throws IllegalArgumentException {
79 throw unsupported();
80 }
81
82 public RealVector subtract(double[] v) throws IllegalArgumentException {
83 throw unsupported();
84 }
85
86 public RealVector mapAdd(double d) {
87 throw unsupported();
88 }
89
90 public RealVector mapAddToSelf(double d) {
91 throw unsupported();
92 }
93
94 public RealVector mapSubtract(double d) {
95 throw unsupported();
96 }
97
98 public RealVector mapSubtractToSelf(double d) {
99 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 OpenMapRealVector(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(SparseRealVectorTest.class);
466 suite.setName("SparseRealVector Tests");
467 return suite;
468 }
469
470 public void testConstructors() {
471
472 OpenMapRealVector v0 = new OpenMapRealVector();
473 assertEquals("testData len", 0, v0.getDimension());
474
475 OpenMapRealVector v1 = new OpenMapRealVector(7);
476 assertEquals("testData len", 7, v1.getDimension());
477 assertEquals("testData is 0.0 ", 0.0, v1.getEntry(6));
478
479 OpenMapRealVector v3 = new OpenMapRealVector(vec1);
480 assertEquals("testData len", 3, v3.getDimension());
481 assertEquals("testData is 2.0 ", 2.0, v3.getEntry(1));
482
483
484
485
486
487
488
489
490
491
492
493
494
495 RealVector v5_i = new OpenMapRealVector(dvec1);
496 assertEquals("testData len", 9, v5_i.getDimension());
497 assertEquals("testData is 9.0 ", 9.0, v5_i.getEntry(8));
498
499 OpenMapRealVector v5 = new OpenMapRealVector(dvec1);
500 assertEquals("testData len", 9, v5.getDimension());
501 assertEquals("testData is 9.0 ", 9.0, v5.getEntry(8));
502
503 OpenMapRealVector v7 = new OpenMapRealVector(v1);
504 assertEquals("testData len", 7, v7.getDimension());
505 assertEquals("testData is 0.0 ", 0.0, v7.getEntry(6));
506
507 SparseRealVectorTestImpl v7_i = new SparseRealVectorTestImpl(vec1);
508
509 OpenMapRealVector v7_2 = new OpenMapRealVector(v7_i);
510 assertEquals("testData len", 3, v7_2.getDimension());
511 assertEquals("testData is 0.0 ", 2.0d, v7_2.getEntry(1));
512
513 OpenMapRealVector v8 = new OpenMapRealVector(v1);
514 assertEquals("testData len", 7, v8.getDimension());
515 assertEquals("testData is 0.0 ", 0.0, v8.getEntry(6));
516
517 }
518
519 public void testDataInOut() {
520
521 OpenMapRealVector v1 = new OpenMapRealVector(vec1);
522 OpenMapRealVector v2 = new OpenMapRealVector(vec2);
523 OpenMapRealVector v4 = new OpenMapRealVector(vec4);
524 SparseRealVectorTestImpl v2_t = new SparseRealVectorTestImpl(vec2);
525
526 RealVector v_append_1 = v1.append(v2);
527 assertEquals("testData len", 6, v_append_1.getDimension());
528 assertEquals("testData is 4.0 ", 4.0, v_append_1.getEntry(3));
529
530 RealVector v_append_2 = v1.append(2.0);
531 assertEquals("testData len", 4, v_append_2.getDimension());
532 assertEquals("testData is 2.0 ", 2.0, v_append_2.getEntry(3));
533
534 RealVector v_append_3 = v1.append(vec2);
535 assertEquals("testData len", 6, v_append_3.getDimension());
536 assertEquals("testData is ", 4.0, v_append_3.getEntry(3));
537
538 RealVector v_append_4 = v1.append(v2_t);
539 assertEquals("testData len", 6, v_append_4.getDimension());
540 assertEquals("testData is 4.0 ", 4.0, v_append_4.getEntry(3));
541
542 RealVector vout5 = v4.getSubVector(3, 3);
543 assertEquals("testData len", 3, vout5.getDimension());
544 assertEquals("testData is 4.0 ", 5.0, vout5.getEntry(1));
545 try {
546 v4.getSubVector(3, 7);
547 fail("MatrixIndexException expected");
548 } catch (MatrixIndexException ex) {
549
550 } catch (Exception e) {
551 fail("wrong exception caught");
552 }
553
554 OpenMapRealVector v_set1 = (OpenMapRealVector) v1.copy();
555 v_set1.setEntry(1, 11.0);
556 assertEquals("testData is 11.0 ", 11.0, v_set1.getEntry(1));
557 try {
558 v_set1.setEntry(3, 11.0);
559 fail("MatrixIndexException expected");
560 } catch (MatrixIndexException ex) {
561
562 } catch (Exception e) {
563 fail("wrong exception caught");
564 }
565
566 OpenMapRealVector v_set2 = (OpenMapRealVector) v4.copy();
567 v_set2.setSubVector(3, v1);
568 assertEquals("testData is 1.0 ", 1.0, v_set2.getEntry(3));
569 assertEquals("testData is 7.0 ", 7.0, v_set2.getEntry(6));
570 try {
571 v_set2.setSubVector(7, v1);
572 fail("MatrixIndexException expected");
573 } catch (MatrixIndexException ex) {
574
575 } catch (Exception e) {
576 fail("wrong exception caught");
577 }
578
579 OpenMapRealVector v_set3 = (OpenMapRealVector) v1.copy();
580 v_set3.set(13.0);
581 assertEquals("testData is 13.0 ", 13.0, v_set3.getEntry(2));
582
583 try {
584 v_set3.getEntry(23);
585 fail("MatrixIndexException expected");
586 } catch (MatrixIndexException ex) {
587
588 } catch (Exception e) {
589 fail("wrong exception caught");
590 }
591
592 OpenMapRealVector v_set4 = (OpenMapRealVector) v4.copy();
593 v_set4.setSubVector(3, v2_t);
594 assertEquals("testData is 1.0 ", 4.0, v_set4.getEntry(3));
595 assertEquals("testData is 7.0 ", 7.0, v_set4.getEntry(6));
596 try {
597 v_set4.setSubVector(7, v2_t);
598 fail("MatrixIndexException expected");
599 } catch (MatrixIndexException ex) {
600
601 } catch (Exception e) {
602 fail("wrong exception caught");
603 }
604
605
606 }
607
608 public void testMapFunctions() {
609 OpenMapRealVector v1 = new OpenMapRealVector(vec1);
610
611
612 RealVector v_mapAdd = v1.mapAdd(2.0d);
613 double[] result_mapAdd = {3d, 4d, 5d};
614 assertClose("compare vectors" ,result_mapAdd,v_mapAdd.getData(),normTolerance);
615
616
617 RealVector v_mapAddToSelf = v1.copy();
618 v_mapAddToSelf.mapAddToSelf(2.0d);
619 double[] result_mapAddToSelf = {3d, 4d, 5d};
620 assertClose("compare vectors" ,result_mapAddToSelf,v_mapAddToSelf.getData(),normTolerance);
621
622
623 RealVector v_mapSubtract = v1.mapSubtract(2.0d);
624 double[] result_mapSubtract = {-1d, 0d, 1d};
625 assertClose("compare vectors" ,result_mapSubtract,v_mapSubtract.getData(),normTolerance);
626
627
628 RealVector v_mapSubtractToSelf = v1.copy();
629 v_mapSubtractToSelf.mapSubtractToSelf(2.0d);
630 double[] result_mapSubtractToSelf = {-1d, 0d, 1d};
631 assertClose("compare vectors" ,result_mapSubtractToSelf,v_mapSubtractToSelf.getData(),normTolerance);
632
633
634 RealVector v_mapMultiply = v1.mapMultiply(2.0d);
635 double[] result_mapMultiply = {2d, 4d, 6d};
636 assertClose("compare vectors" ,result_mapMultiply,v_mapMultiply.getData(),normTolerance);
637
638
639 RealVector v_mapMultiplyToSelf = v1.copy();
640 v_mapMultiplyToSelf.mapMultiplyToSelf(2.0d);
641 double[] result_mapMultiplyToSelf = {2d, 4d, 6d};
642 assertClose("compare vectors" ,result_mapMultiplyToSelf,v_mapMultiplyToSelf.getData(),normTolerance);
643
644
645 RealVector v_mapDivide = v1.mapDivide(2.0d);
646 double[] result_mapDivide = {.5d, 1d, 1.5d};
647 assertClose("compare vectors" ,result_mapDivide,v_mapDivide.getData(),normTolerance);
648
649
650 RealVector v_mapDivideToSelf = v1.copy();
651 v_mapDivideToSelf.mapDivideToSelf(2.0d);
652 double[] result_mapDivideToSelf = {.5d, 1d, 1.5d};
653 assertClose("compare vectors" ,result_mapDivideToSelf,v_mapDivideToSelf.getData(),normTolerance);
654
655
656 RealVector v_mapPow = v1.mapPow(2.0d);
657 double[] result_mapPow = {1d, 4d, 9d};
658 assertClose("compare vectors" ,result_mapPow,v_mapPow.getData(),normTolerance);
659
660
661 RealVector v_mapPowToSelf = v1.copy();
662 v_mapPowToSelf.mapPowToSelf(2.0d);
663 double[] result_mapPowToSelf = {1d, 4d, 9d};
664 assertClose("compare vectors" ,result_mapPowToSelf,v_mapPowToSelf.getData(),normTolerance);
665
666
667 RealVector v_mapExp = v1.mapExp();
668 double[] result_mapExp = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d};
669 assertClose("compare vectors" ,result_mapExp,v_mapExp.getData(),normTolerance);
670
671
672 RealVector v_mapExpToSelf = v1.copy();
673 v_mapExpToSelf.mapExpToSelf();
674 double[] result_mapExpToSelf = {2.718281828459045e+00d,7.389056098930650e+00d, 2.008553692318767e+01d};
675 assertClose("compare vectors" ,result_mapExpToSelf,v_mapExpToSelf.getData(),normTolerance);
676
677
678
679 RealVector v_mapExpm1 = v1.mapExpm1();
680 double[] result_mapExpm1 = {1.718281828459045d,6.38905609893065d, 19.085536923187668d};
681 assertClose("compare vectors" ,result_mapExpm1,v_mapExpm1.getData(),normTolerance);
682
683
684 RealVector v_mapExpm1ToSelf = v1.copy();
685 v_mapExpm1ToSelf.mapExpm1ToSelf();
686 double[] result_mapExpm1ToSelf = {1.718281828459045d,6.38905609893065d, 19.085536923187668d};
687 assertClose("compare vectors" ,result_mapExpm1ToSelf,v_mapExpm1ToSelf.getData(),normTolerance);
688
689
690 RealVector v_mapLog = v1.mapLog();
691 double[] result_mapLog = {0d,6.931471805599453e-01d, 1.098612288668110e+00d};
692 assertClose("compare vectors" ,result_mapLog,v_mapLog.getData(),normTolerance);
693
694
695 RealVector v_mapLogToSelf = v1.copy();
696 v_mapLogToSelf.mapLogToSelf();
697 double[] result_mapLogToSelf = {0d,6.931471805599453e-01d, 1.098612288668110e+00d};
698 assertClose("compare vectors" ,result_mapLogToSelf,v_mapLogToSelf.getData(),normTolerance);
699
700
701 RealVector v_mapLog10 = v1.mapLog10();
702 double[] result_mapLog10 = {0d,3.010299956639812e-01d, 4.771212547196624e-01d};
703 assertClose("compare vectors" ,result_mapLog10,v_mapLog10.getData(),normTolerance);
704
705
706 RealVector v_mapLog10ToSelf = v1.copy();
707 v_mapLog10ToSelf.mapLog10ToSelf();
708 double[] result_mapLog10ToSelf = {0d,3.010299956639812e-01d, 4.771212547196624e-01d};
709 assertClose("compare vectors" ,result_mapLog10ToSelf,v_mapLog10ToSelf.getData(),normTolerance);
710
711
712 RealVector v_mapLog1p = v1.mapLog1p();
713 double[] result_mapLog1p = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d};
714 assertClose("compare vectors" ,result_mapLog1p,v_mapLog1p.getData(),normTolerance);
715
716
717 RealVector v_mapLog1pToSelf = v1.copy();
718 v_mapLog1pToSelf.mapLog1pToSelf();
719 double[] result_mapLog1pToSelf = {0.6931471805599453d,1.0986122886681096d,1.3862943611198906d};
720 assertClose("compare vectors" ,result_mapLog1pToSelf,v_mapLog1pToSelf.getData(),normTolerance);
721
722
723 RealVector v_mapCosh = v1.mapCosh();
724 double[] result_mapCosh = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d};
725 assertClose("compare vectors" ,result_mapCosh,v_mapCosh.getData(),normTolerance);
726
727
728 RealVector v_mapCoshToSelf = v1.copy();
729 v_mapCoshToSelf.mapCoshToSelf();
730 double[] result_mapCoshToSelf = {1.543080634815244e+00d,3.762195691083631e+00d, 1.006766199577777e+01d};
731 assertClose("compare vectors" ,result_mapCoshToSelf,v_mapCoshToSelf.getData(),normTolerance);
732
733
734 RealVector v_mapSinh = v1.mapSinh();
735 double[] result_mapSinh = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d};
736 assertClose("compare vectors" ,result_mapSinh,v_mapSinh.getData(),normTolerance);
737
738
739 RealVector v_mapSinhToSelf = v1.copy();
740 v_mapSinhToSelf.mapSinhToSelf();
741 double[] result_mapSinhToSelf = {1.175201193643801e+00d,3.626860407847019e+00d, 1.001787492740990e+01d};
742 assertClose("compare vectors" ,result_mapSinhToSelf,v_mapSinhToSelf.getData(),normTolerance);
743
744
745 RealVector v_mapTanh = v1.mapTanh();
746 double[] result_mapTanh = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d};
747 assertClose("compare vectors" ,result_mapTanh,v_mapTanh.getData(),normTolerance);
748
749
750 RealVector v_mapTanhToSelf = v1.copy();
751 v_mapTanhToSelf.mapTanhToSelf();
752 double[] result_mapTanhToSelf = {7.615941559557649e-01d,9.640275800758169e-01d,9.950547536867305e-01d};
753 assertClose("compare vectors" ,result_mapTanhToSelf,v_mapTanhToSelf.getData(),normTolerance);
754
755
756 RealVector v_mapCos = v1.mapCos();
757 double[] result_mapCos = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d};
758 assertClose("compare vectors" ,result_mapCos,v_mapCos.getData(),normTolerance);
759
760
761 RealVector v_mapCosToSelf = v1.copy();
762 v_mapCosToSelf.mapCosToSelf();
763 double[] result_mapCosToSelf = {5.403023058681398e-01d,-4.161468365471424e-01d, -9.899924966004454e-01d};
764 assertClose("compare vectors" ,result_mapCosToSelf,v_mapCosToSelf.getData(),normTolerance);
765
766
767 RealVector v_mapSin = v1.mapSin();
768 double[] result_mapSin = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d};
769 assertClose("compare vectors" ,result_mapSin,v_mapSin.getData(),normTolerance);
770
771
772 RealVector v_mapSinToSelf = v1.copy();
773 v_mapSinToSelf.mapSinToSelf();
774 double[] result_mapSinToSelf = {8.414709848078965e-01d,9.092974268256817e-01d,1.411200080598672e-01d};
775 assertClose("compare vectors" ,result_mapSinToSelf,v_mapSinToSelf.getData(),normTolerance);
776
777
778 RealVector v_mapTan = v1.mapTan();
779 double[] result_mapTan = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d};
780 assertClose("compare vectors" ,result_mapTan,v_mapTan.getData(),normTolerance);
781
782
783 RealVector v_mapTanToSelf = v1.copy();
784 v_mapTanToSelf.mapTanToSelf();
785 double[] result_mapTanToSelf = {1.557407724654902e+00d,-2.185039863261519e+00d,-1.425465430742778e-01d};
786 assertClose("compare vectors" ,result_mapTanToSelf,v_mapTanToSelf.getData(),normTolerance);
787
788 double[] vat_a = {0d, 0.5d, 1.0d};
789 OpenMapRealVector vat = new OpenMapRealVector(vat_a);
790
791
792 RealVector v_mapAcos = vat.mapAcos();
793 double[] result_mapAcos = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d};
794 assertClose("compare vectors" ,result_mapAcos,v_mapAcos.getData(),normTolerance);
795
796
797 RealVector v_mapAcosToSelf = vat.copy();
798 v_mapAcosToSelf.mapAcosToSelf();
799 double[] result_mapAcosToSelf = {1.570796326794897e+00d,1.047197551196598e+00d, 0.0d};
800 assertClose("compare vectors" ,result_mapAcosToSelf,v_mapAcosToSelf.getData(),normTolerance);
801
802
803 RealVector v_mapAsin = vat.mapAsin();
804 double[] result_mapAsin = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d};
805 assertClose("compare vectors" ,result_mapAsin,v_mapAsin.getData(),normTolerance);
806
807
808 RealVector v_mapAsinToSelf = vat.copy();
809 v_mapAsinToSelf.mapAsinToSelf();
810 double[] result_mapAsinToSelf = {0.0d,5.235987755982989e-01d,1.570796326794897e+00d};
811 assertClose("compare vectors" ,result_mapAsinToSelf,v_mapAsinToSelf.getData(),normTolerance);
812
813
814 RealVector v_mapAtan = vat.mapAtan();
815 double[] result_mapAtan = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d};
816 assertClose("compare vectors" ,result_mapAtan,v_mapAtan.getData(),normTolerance);
817
818
819 RealVector v_mapAtanToSelf = vat.copy();
820 v_mapAtanToSelf.mapAtanToSelf();
821 double[] result_mapAtanToSelf = {0.0d,4.636476090008061e-01d,7.853981633974483e-01d};
822 assertClose("compare vectors" ,result_mapAtanToSelf,v_mapAtanToSelf.getData(),normTolerance);
823
824
825 RealVector v_mapInv = v1.mapInv();
826 double[] result_mapInv = {1d,0.5d,3.333333333333333e-01d};
827 assertClose("compare vectors" ,result_mapInv,v_mapInv.getData(),normTolerance);
828
829
830 RealVector v_mapInvToSelf = v1.copy();
831 v_mapInvToSelf.mapInvToSelf();
832 double[] result_mapInvToSelf = {1d,0.5d,3.333333333333333e-01d};
833 assertClose("compare vectors" ,result_mapInvToSelf,v_mapInvToSelf.getData(),normTolerance);
834
835 double[] abs_a = {-1.0d, 0.0d, 1.0d};
836 OpenMapRealVector abs_v = new OpenMapRealVector(abs_a);
837
838
839 RealVector v_mapAbs = abs_v.mapAbs();
840 double[] result_mapAbs = {1d,0d,1d};
841 assertClose("compare vectors" ,result_mapAbs,v_mapAbs.getData(),normTolerance);
842
843
844 RealVector v_mapAbsToSelf = abs_v.copy();
845 v_mapAbsToSelf.mapAbsToSelf();
846 double[] result_mapAbsToSelf = {1d,0d,1d};
847 assertClose("compare vectors" ,result_mapAbsToSelf,v_mapAbsToSelf.getData(),normTolerance);
848
849
850 RealVector v_mapSqrt = v1.mapSqrt();
851 double[] result_mapSqrt = {1d,1.414213562373095e+00d,1.732050807568877e+00d};
852 assertClose("compare vectors" ,result_mapSqrt,v_mapSqrt.getData(),normTolerance);
853
854
855 RealVector v_mapSqrtToSelf = v1.copy();
856 v_mapSqrtToSelf.mapSqrtToSelf();
857 double[] result_mapSqrtToSelf = {1d,1.414213562373095e+00d,1.732050807568877e+00d};
858 assertClose("compare vectors" ,result_mapSqrtToSelf,v_mapSqrtToSelf.getData(),normTolerance);
859
860 double[] cbrt_a = {-2.0d, 0.0d, 2.0d};
861 OpenMapRealVector cbrt_v = new OpenMapRealVector(cbrt_a);
862
863
864 RealVector v_mapCbrt = cbrt_v.mapCbrt();
865 double[] result_mapCbrt = {-1.2599210498948732d,0d,1.2599210498948732d};
866 assertClose("compare vectors" ,result_mapCbrt,v_mapCbrt.getData(),normTolerance);
867
868
869 RealVector v_mapCbrtToSelf = cbrt_v.copy();
870 v_mapCbrtToSelf.mapCbrtToSelf();
871 double[] result_mapCbrtToSelf = {-1.2599210498948732d,0d,1.2599210498948732d};
872 assertClose("compare vectors" ,result_mapCbrtToSelf,v_mapCbrtToSelf.getData(),normTolerance);
873
874 double[] ceil_a = {-1.1d, 0.9d, 1.1d};
875 OpenMapRealVector ceil_v = new OpenMapRealVector(ceil_a);
876
877
878 RealVector v_mapCeil = ceil_v.mapCeil();
879 double[] result_mapCeil = {-1d,1d,2d};
880 assertClose("compare vectors" ,result_mapCeil,v_mapCeil.getData(),normTolerance);
881
882
883 RealVector v_mapCeilToSelf = ceil_v.copy();
884 v_mapCeilToSelf.mapCeilToSelf();
885 double[] result_mapCeilToSelf = {-1d,1d,2d};
886 assertClose("compare vectors" ,result_mapCeilToSelf,v_mapCeilToSelf.getData(),normTolerance);
887
888
889 RealVector v_mapFloor = ceil_v.mapFloor();
890 double[] result_mapFloor = {-2d,0d,1d};
891 assertClose("compare vectors" ,result_mapFloor,v_mapFloor.getData(),normTolerance);
892
893
894 RealVector v_mapFloorToSelf = ceil_v.copy();
895 v_mapFloorToSelf.mapFloorToSelf();
896 double[] result_mapFloorToSelf = {-2d,0d,1d};
897 assertClose("compare vectors" ,result_mapFloorToSelf,v_mapFloorToSelf.getData(),normTolerance);
898
899
900 RealVector v_mapRint = ceil_v.mapRint();
901 double[] result_mapRint = {-1d,1d,1d};
902 assertClose("compare vectors" ,result_mapRint,v_mapRint.getData(),normTolerance);
903
904
905 RealVector v_mapRintToSelf = ceil_v.copy();
906 v_mapRintToSelf.mapRintToSelf();
907 double[] result_mapRintToSelf = {-1d,1d,1d};
908 assertClose("compare vectors" ,result_mapRintToSelf,v_mapRintToSelf.getData(),normTolerance);
909
910
911 RealVector v_mapSignum = ceil_v.mapSignum();
912 double[] result_mapSignum = {-1d,1d,1d};
913 assertClose("compare vectors" ,result_mapSignum,v_mapSignum.getData(),normTolerance);
914
915
916 RealVector v_mapSignumToSelf = ceil_v.copy();
917 v_mapSignumToSelf.mapSignumToSelf();
918 double[] result_mapSignumToSelf = {-1d,1d,1d};
919 assertClose("compare vectors" ,result_mapSignumToSelf,v_mapSignumToSelf.getData(),normTolerance);
920
921
922
923
924 RealVector v_mapUlp = ceil_v.mapUlp();
925 double[] result_mapUlp = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d};
926 assertClose("compare vectors" ,result_mapUlp,v_mapUlp.getData(),normTolerance);
927
928
929 RealVector v_mapUlpToSelf = ceil_v.copy();
930 v_mapUlpToSelf.mapUlpToSelf();
931 double[] result_mapUlpToSelf = {2.220446049250313E-16d,1.1102230246251565E-16d,2.220446049250313E-16d};
932 assertClose("compare vectors" ,result_mapUlpToSelf,v_mapUlpToSelf.getData(),normTolerance);
933
934 }
935
936 public void testBasicFunctions() {
937 OpenMapRealVector v1 = new OpenMapRealVector(vec1);
938 OpenMapRealVector v2 = new OpenMapRealVector(vec2);
939 OpenMapRealVector v_null = new OpenMapRealVector(vec_null);
940
941 SparseRealVectorTestImpl v2_t = new SparseRealVectorTestImpl(vec2);
942
943
944 double d_getNorm = v1.getNorm();
945 assertEquals("compare values ", 3.7416573867739413,d_getNorm);
946
947 double d_getL1Norm = v1.getL1Norm();
948 assertEquals("compare values ",6.0, d_getL1Norm);
949
950 double d_getLInfNorm = v1.getLInfNorm();
951 assertEquals("compare values ",6.0, d_getLInfNorm);
952
953
954 double dist = v1.getDistance(v2);
955 assertEquals("compare values ",v1.subtract(v2).getNorm(), dist );
956
957
958 double dist_2 = v1.getDistance(v2_t);
959 assertEquals("compare values ", v1.subtract(v2).getNorm(),dist_2 );
960
961
962 double d_getL1Distance = v1. getL1Distance(v2);
963 assertEquals("compare values ",9d, d_getL1Distance );
964
965 double d_getL1Distance_2 = v1. getL1Distance(v2_t);
966 assertEquals("compare values ",9d, d_getL1Distance_2 );
967
968
969 double d_getLInfDistance = v1. getLInfDistance(v2);
970 assertEquals("compare values ",3d, d_getLInfDistance );
971
972 double d_getLInfDistance_2 = v1. getLInfDistance(v2_t);
973 assertEquals("compare values ",3d, d_getLInfDistance_2 );
974
975
976 OpenMapRealVector v_add = v1.add(v2);
977 double[] result_add = {5d, 7d, 9d};
978 assertClose("compare vect" ,v_add.getData(),result_add,normTolerance);
979
980 SparseRealVectorTestImpl vt2 = new SparseRealVectorTestImpl(vec2);
981 RealVector v_add_i = v1.add(vt2);
982 double[] result_add_i = {5d, 7d, 9d};
983 assertClose("compare vect" ,v_add_i.getData(),result_add_i,normTolerance);
984
985
986 OpenMapRealVector v_subtract = v1.subtract(v2);
987 double[] result_subtract = {-3d, -3d, -3d};
988 assertClose("compare vect" ,v_subtract.getData(),result_subtract,normTolerance);
989
990 RealVector v_subtract_i = v1.subtract(vt2);
991 double[] result_subtract_i = {-3d, -3d, -3d};
992 assertClose("compare vect" ,v_subtract_i.getData(),result_subtract_i,normTolerance);
993
994
995 RealVector v_ebeMultiply = v1.ebeMultiply(v2);
996 double[] result_ebeMultiply = {4d, 10d, 18d};
997 assertClose("compare vect" ,v_ebeMultiply.getData(),result_ebeMultiply,normTolerance);
998
999 RealVector v_ebeMultiply_2 = v1.ebeMultiply(v2_t);
1000 double[] result_ebeMultiply_2 = {4d, 10d, 18d};
1001 assertClose("compare vect" ,v_ebeMultiply_2.getData(),result_ebeMultiply_2,normTolerance);
1002
1003
1004 RealVector v_ebeDivide = v1.ebeDivide(v2);
1005 double[] result_ebeDivide = {0.25d, 0.4d, 0.5d};
1006 assertClose("compare vect" ,v_ebeDivide.getData(),result_ebeDivide,normTolerance);
1007
1008 RealVector v_ebeDivide_2 = v1.ebeDivide(v2_t);
1009 double[] result_ebeDivide_2 = {0.25d, 0.4d, 0.5d};
1010 assertClose("compare vect" ,v_ebeDivide_2.getData(),result_ebeDivide_2,normTolerance);
1011
1012
1013 double dot = v1.dotProduct(v2);
1014 assertEquals("compare val ",32d, dot);
1015
1016
1017 double dot_2 = v1.dotProduct(v2_t);
1018 assertEquals("compare val ",32d, dot_2);
1019
1020 RealMatrix m_outerProduct = v1.outerProduct(v2);
1021 assertEquals("compare val ",4d, m_outerProduct.getEntry(0,0));
1022
1023 RealMatrix m_outerProduct_2 = v1.outerProduct(v2_t);
1024 assertEquals("compare val ",4d, m_outerProduct_2.getEntry(0,0));
1025
1026 RealVector v_unitVector = v1.unitVector();
1027 RealVector v_unitVector_2 = v1.mapDivide(v1.getNorm());
1028 assertClose("compare vect" ,v_unitVector.getData(),v_unitVector_2.getData(),normTolerance);
1029
1030 try {
1031 v_null.unitVector();
1032 fail("Expecting ArithmeticException");
1033 } catch (ArithmeticException ex) {
1034
1035 } catch (Exception e) {
1036 fail("wrong exception caught");
1037 }
1038
1039 OpenMapRealVector v_unitize = (OpenMapRealVector)v1.copy();
1040 v_unitize.unitize();
1041 assertClose("compare vect" ,v_unitVector_2.getData(),v_unitize.getData(),normTolerance);
1042 try {
1043 v_null.unitize();
1044 fail("Expecting ArithmeticException");
1045 } catch (ArithmeticException ex) {
1046
1047 } catch (Exception e) {
1048 fail("wrong exception caught");
1049 }
1050
1051 RealVector v_projection = v1.projection(v2);
1052 double[] result_projection = {1.662337662337662, 2.0779220779220777, 2.493506493506493};
1053 assertClose("compare vect", v_projection.getData(), result_projection, normTolerance);
1054
1055 RealVector v_projection_2 = v1.projection(v2_t);
1056 double[] result_projection_2 = {1.662337662337662, 2.0779220779220777, 2.493506493506493};
1057 assertClose("compare vect", v_projection_2.getData(), result_projection_2, normTolerance);
1058
1059 }
1060
1061 public void testMisc() {
1062 OpenMapRealVector v1 = new OpenMapRealVector(vec1);
1063
1064 String out1 = v1.toString();
1065 assertTrue("some output ", out1.length()!=0);
1066 try {
1067 v1.checkVectorDimensions(2);
1068 fail("IllegalArgumentException expected");
1069 } catch (IllegalArgumentException ex) {
1070
1071 } catch (Exception e) {
1072 fail("wrong exception caught");
1073 }
1074
1075
1076 }
1077
1078 public void testPredicates() {
1079
1080 OpenMapRealVector v = new OpenMapRealVector(new double[] { 0, 1, 2 });
1081
1082 assertFalse(v.isNaN());
1083 v.setEntry(1, Double.NaN);
1084 assertTrue(v.isNaN());
1085
1086 assertFalse(v.isInfinite());
1087 v.setEntry(0, Double.POSITIVE_INFINITY);
1088 assertFalse(v.isInfinite());
1089 v.setEntry(1, 1);
1090 assertTrue(v.isInfinite());
1091
1092 v.setEntry(0, 0);
1093 assertEquals(v, new OpenMapRealVector(new double[] { 0, 1, 2 }));
1094 assertNotSame(v, new OpenMapRealVector(new double[] { 0, 1, 2 + Math.ulp(2)}));
1095 assertNotSame(v, new OpenMapRealVector(new double[] { 0, 1, 2, 3 }));
1096
1097 }
1098
1099 public void testSerial() {
1100 OpenMapRealVector v = new OpenMapRealVector(new double[] { 0, 1, 2 });
1101 assertEquals(v,TestUtils.serializeAndRecover(v));
1102 }
1103
1104
1105 protected void assertClose(String msg, double[] m, double[] n,
1106 double tolerance) {
1107 if (m.length != n.length) {
1108 fail("vectors have different lengths");
1109 }
1110 for (int i = 0; i < m.length; i++) {
1111 assertEquals(msg + " " + i + " elements differ", m[i],n[i],tolerance);
1112 }
1113 }
1114
1115 }