1 package org.djunits.value.vdouble.vector;
2
3 import static org.junit.jupiter.api.Assertions.assertEquals;
4 import static org.junit.jupiter.api.Assertions.assertFalse;
5 import static org.junit.jupiter.api.Assertions.assertNotEquals;
6 import static org.junit.jupiter.api.Assertions.assertTrue;
7 import static org.junit.jupiter.api.Assertions.fail;
8
9 import org.djunits.unit.AbsoluteTemperatureUnit;
10 import org.djunits.unit.AngleUnit;
11 import org.djunits.unit.AreaUnit;
12 import org.djunits.unit.DirectionUnit;
13 import org.djunits.unit.DurationUnit;
14 import org.djunits.unit.LengthUnit;
15 import org.djunits.unit.PositionUnit;
16 import org.djunits.unit.SpeedUnit;
17 import org.djunits.unit.TemperatureUnit;
18 import org.djunits.unit.TimeUnit;
19 import org.djunits.unit.util.UnitException;
20 import org.djunits.value.ValueRuntimeException;
21 import org.djunits.value.storage.StorageType;
22 import org.djunits.value.vdouble.function.DoubleMathFunctions;
23 import org.djunits.value.vdouble.scalar.AbsoluteTemperature;
24 import org.djunits.value.vdouble.scalar.Area;
25 import org.djunits.value.vdouble.scalar.Direction;
26 import org.djunits.value.vdouble.scalar.Duration;
27 import org.djunits.value.vdouble.scalar.Position;
28 import org.djunits.value.vdouble.scalar.Time;
29 import org.djunits.value.vdouble.vector.data.DoubleVectorData;
30 import org.djutils.test.UnitTest;
31 import org.junit.jupiter.api.Test;
32
33
34
35
36
37
38
39
40
41 public class DoubleVectorMethodTest
42 {
43
44
45
46
47
48
49 @Test
50 public void testVectorMethods() throws ValueRuntimeException, UnitException
51 {
52 double[] denseTestData = DOUBLEVECTOR.denseArray(105);
53 double[] sparseTestData = DOUBLEVECTOR.sparseArray(105);
54 double[] reverseSparseTestData = new double[sparseTestData.length];
55
56 for (int index = 0; index < sparseTestData.length; index++)
57 {
58 reverseSparseTestData[reverseSparseTestData.length - 1 - index] = sparseTestData[index];
59 }
60
61 sparseTestData[10] = 123.456;
62 reverseSparseTestData[10] = sparseTestData[10];
63
64 for (int index = 20; index < 90; index++)
65 {
66 sparseTestData[index] = 10000.456 + index;
67 reverseSparseTestData[index] = 20000.567 + index;
68 }
69 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
70 {
71 for (AreaUnit au : new AreaUnit[] {AreaUnit.SQUARE_METER, AreaUnit.ACRE})
72 {
73 double[] testData = storageType.equals(StorageType.DENSE) ? denseTestData : sparseTestData;
74 AreaVector am = new AreaVector(DoubleVectorData.instantiate(testData, au.getScale(), storageType), au);
75
76
77 assertEquals(am, am.toSparse());
78 assertEquals(am, am.toDense());
79 assertEquals(am, am.toSparse().toDense());
80 assertEquals(am, am.toDense().toSparse());
81 assertEquals(am.hashCode(), am.toSparse().hashCode());
82 assertEquals(am.hashCode(), am.toDense().hashCode());
83 assertTrue(am.toDense().isDense());
84 assertFalse(am.toDense().isSparse());
85 assertTrue(am.toSparse().isSparse());
86 assertFalse(am.toSparse().isDense());
87
88
89 assertEquals(am, am);
90 assertNotEquals(am, new Object());
91 assertNotEquals(am, null);
92 assertNotEquals(am, new LengthVector(
93 DoubleVectorData.instantiate(testData, LengthUnit.METER.getScale(), storageType), LengthUnit.METER));
94 assertNotEquals(am, am.divide(2.0d));
95
96
97 assertFalse(am.isMutable());
98 AreaVector ammut = am.mutable();
99 assertTrue(ammut.isMutable());
100 assertFalse(am.isMutable());
101 AreaVector ammut2 = ammut.multiplyBy(1.0);
102 assertEquals(am, ammut2);
103 assertTrue(ammut.isMutable());
104 assertFalse(am.isMutable());
105 assertTrue(ammut2.isMutable());
106 ammut2 = ammut2.mutable().divideBy(2.0);
107 assertEquals(am, ammut);
108 assertNotEquals(am, ammut2);
109 AreaVector ammut3 = ammut2.mutable().divideBy(0.0);
110 for (int index = 0; index < ammut3.size(); index++)
111 {
112 if (ammut2.getSI(index) == 0)
113 {
114 assertTrue(Double.isNaN(ammut3.getSI(index)), "Value should be NaN");
115
116 }
117 else
118 {
119 assertTrue(Double.isInfinite(ammut3.getSI(index)), "Value should be Infinite");
120 }
121 }
122
123
124 Area zSum = am.zSum();
125 double sum = 0;
126 int card = 0;
127 for (int index = 0; index < testData.length; index++)
128 {
129 sum += testData[index];
130 card += testData[index] == 0.0d ? 0 : 1;
131 }
132 assertEquals(sum, zSum.getInUnit(), 0.1, "zSum");
133 assertEquals(card, am.cardinality(), "cardinality");
134
135
136 AreaVector amold = am.clone();
137 Area fa = Area.of(10.0d, "m^2");
138 AreaVector aminc = am.mutable().incrementBy(fa).immutable();
139 AreaVector amdec = am.mutable().decrementBy(fa).immutable();
140 AreaVector amid = aminc.mutable().decrementBy(fa);
141 assertEquals(am, amold, "immutable vector should not change when converted to mutable");
142 for (int index = 0; index < testData.length; index++)
143 {
144 assertEquals(am.getSI(index), amid.getSI(index), 0.1,
145 "increment and decrement with scalar should result in same vector");
146 assertEquals(au.getScale().toStandardUnit(testData[index]) + 10.0, aminc.getSI(index), 0.1,
147 "m + s = (m+s)");
148 assertEquals(au.getScale().toStandardUnit(testData[index]) - 10.0, amdec.getSI(index), 0.1,
149 "m - s = (m-s)");
150 }
151
152
153 AreaVector amt5 = am.mutable().multiplyBy(5.0d).immutable();
154 AreaVector amd5 = am.mutable().divideBy(5.0d).immutable();
155 AreaVector amtd = amt5.mutable().divideBy(5.0d);
156 AreaVector amtimD = am.times(5.0d);
157 AreaVector amtimF = am.times(5.0f);
158 AreaVector amdivD = am.divide(5.0d);
159 AreaVector amdivF = am.divide(5.0f);
160 for (int index = 0; index < testData.length; index++)
161 {
162 assertEquals(am.getSI(index), amtd.getSI(index), 0.1,
163 "times followed by divide with constant should result in same vector");
164 assertEquals(au.getScale().toStandardUnit(testData[index]) * 5.0d, amt5.getSI(index), 0.1,
165 "m * 5.0 = (m*5.0)");
166 assertEquals(au.getScale().toStandardUnit(testData[index]) / 5.0d, amd5.getSI(index), 0.1,
167 "m / 5.0 = (m/5.0)");
168 assertEquals(amt5.getSI(index), amtimD.getSI(index), 0.1d, "amtimD");
169 assertEquals(amt5.getSI(index), amtimF.getSI(index), 0.1d, "amtimF");
170 assertEquals(amd5.getSI(index), amdivD.getSI(index), 0.01d, "amdivD");
171 assertEquals(amd5.getSI(index), amdivF.getSI(index), 0.01d, "amdivD");
172 }
173
174
175 assertEquals(new Area(testData[2], au), am.get(2), "get()");
176 assertEquals(au.getScale().toStandardUnit(testData[2]), am.getSI(2), 0.1, "getSI()");
177 assertEquals(testData[2], am.getInUnit(2), 0.1, "getInUnit()");
178 assertEquals(AreaUnit.SQUARE_YARD.getScale().fromStandardUnit(au.getScale().toStandardUnit(testData[2])),
179 am.getInUnit(2, AreaUnit.SQUARE_YARD), 0.1, "getInUnit(unit)");
180
181
182 Area fasqft = new Area(10.5d, AreaUnit.SQUARE_FOOT);
183 AreaVector famChange = am.clone().mutable();
184 famChange.set(2, fasqft);
185 assertEquals(fasqft.si, famChange.get(2).si, 0.1d, "set()");
186 famChange = am.clone().mutable();
187 famChange.setSI(2, 123.4d);
188 assertEquals(123.4d, famChange.get(2).si, 0.1d, "setSI()");
189 famChange = am.clone().mutable();
190 famChange.setInUnit(2, 1.2d);
191 assertEquals(1.2d, famChange.getInUnit(2), 0.1d, "setInUnit()");
192 famChange = am.clone().mutable();
193 famChange.setInUnit(2, 1.5d, AreaUnit.HECTARE);
194 assertEquals(15000.0d, famChange.get(2).si, 1.0d, "setInUnit(unit)");
195
196
197 double[] valsi = am.getValuesSI();
198 double[] valunit = am.getValuesInUnit();
199 double[] valsqft = am.getValuesInUnit(AreaUnit.SQUARE_YARD);
200 Area[] valscalars = am.getScalars();
201 for (int index = 0; index < testData.length; index++)
202 {
203 assertEquals(au.getScale().toStandardUnit(testData[index]), valsi[index], 0.1, "getValuesSI()");
204 assertEquals(testData[index], valunit[index], 0.1, "getValuesInUnit()");
205 assertEquals(
206 AreaUnit.SQUARE_YARD.getScale().fromStandardUnit(au.getScale().toStandardUnit(testData[index])),
207 valsqft[index], 0.1, "getValuesInUnit(unit)");
208 assertEquals(au.getScale().toStandardUnit(testData[index]), valscalars[index].si, 0.1,
209 "getValuesInUnit(unit)");
210 }
211
212
213 AreaVector amdiv2 = am.divide(2.0d);
214 assertEquals(am.getStorageType(), amdiv2.getStorageType());
215 assertEquals(am.getDisplayUnit(), amdiv2.getDisplayUnit());
216 AreaVector amAbs = amdiv2.mutable().abs().immutable();
217 assertEquals(am.getStorageType(), amAbs.getStorageType());
218 assertEquals(am.getDisplayUnit(), amAbs.getDisplayUnit());
219 AreaVector amCeil = amdiv2.mutable().ceil().immutable();
220 assertEquals(am.getStorageType(), amCeil.getStorageType());
221 assertEquals(am.getDisplayUnit(), amCeil.getDisplayUnit());
222 AreaVector amFloor = amdiv2.mutable().floor().immutable();
223 assertEquals(am.getStorageType(), amFloor.getStorageType());
224 assertEquals(am.getDisplayUnit(), amFloor.getDisplayUnit());
225 AreaVector amNeg = amdiv2.mutable().neg().immutable();
226 assertEquals(am.getStorageType(), amNeg.getStorageType());
227 assertEquals(am.getDisplayUnit(), amNeg.getDisplayUnit());
228 AreaVector amRint = amdiv2.mutable().rint().immutable();
229 assertEquals(am.getStorageType(), amRint.getStorageType());
230 assertEquals(am.getDisplayUnit(), amRint.getDisplayUnit());
231 for (int index = 0; index < testData.length; index++)
232 {
233
234 assertEquals(au.getScale().toStandardUnit(testData[index]) / 2.0d, amdiv2.getSI(index), 0.1d, "div2");
235 assertEquals(Math.abs(au.getScale().toStandardUnit(testData[index]) / 2.0d), amAbs.getSI(index), 0.1d,
236 "abs");
237 assertEquals(Math.ceil(au.getScale().toStandardUnit(testData[index]) / 2.0d), amCeil.getSI(index), 0.1d,
238 "ceil");
239 assertEquals(Math.floor(au.getScale().toStandardUnit(testData[index]) / 2.0d), amFloor.getSI(index), 0.1d,
240 "floor");
241 assertEquals(-au.getScale().toStandardUnit(testData[index]) / 2.0d, amNeg.getSI(index), 0.1d, "neg");
242 assertEquals(Math.rint(au.getScale().toStandardUnit(testData[index]) / 2.0d), amRint.getSI(index), 0.1d,
243 "rint");
244 }
245
246
247
248 for (StorageType storageType2 : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
249 {
250 double[] testData2 = storageType2.equals(StorageType.DENSE) ? denseTestData : reverseSparseTestData;
251 for (AreaUnit au2 : new AreaUnit[] {AreaUnit.SQUARE_METER, AreaUnit.ACRE})
252 {
253
254 AreaVector am2 =
255 new AreaVector(DoubleVectorData.instantiate(testData2, au2.getScale(), storageType2), au2);
256 AreaVector amSum1 = am.plus(am2);
257 AreaVector amSum2 = am2.plus(am);
258 AreaVector amSum3 = am.mutable().incrementBy(am2).immutable();
259
260 AreaVector amSum4 = am2.mutable().incrementBy(am).immutable();
261 assertEquals(amSum1, amSum2, "a+b == b+a");
262 assertEquals(amSum1, amSum3, "a+b == b+a");
263 assertEquals(amSum1, amSum4, "a+c == c+a");
264 for (int index = 0; index < testData.length; index++)
265 {
266 double tolerance =
267 Double.isFinite(amSum1.getSI(index)) ? Math.abs(amSum1.getSI(index) / 10000.0d) : 0.1d;
268 assertEquals(
269 au.getScale().toStandardUnit(testData[index])
270 + au2.getScale().toStandardUnit(testData2[index]),
271 amSum1.getSI(index), tolerance, "value in vector matches");
272 }
273
274
275 AreaVector amDiff1 = am.minus(am2);
276 AreaVector amDiff2 = am2.minus(am).mutable().neg();
277 AreaVector amDiff3 = am.mutable().decrementBy(am2).immutable();
278
279 AreaVector amDiff4 = am2.mutable().decrementBy(am).neg().immutable();
280 assertEquals(amDiff1, amDiff2, "a-b == -(b-a)");
281 assertEquals(amDiff1, amDiff3, "a-b == -(b-a)");
282 assertEquals(amDiff1, amDiff4, "a-c == -(c-a)");
283 for (int index = 0; index < testData.length; index++)
284 {
285 double tolerance =
286 Double.isFinite(amDiff1.getSI(index)) ? Math.abs(amDiff1.getSI(index) / 10000.0d) : 0.1d;
287 assertEquals(
288 au.getScale().toStandardUnit(testData[index])
289 - au2.getScale().toStandardUnit(testData2[index]),
290 amDiff1.getSI(index), tolerance, "value in vector matches");
291 }
292
293
294 SIVector amTim = am.times(am2);
295 SIVector amDiv = am.divide(am2);
296 assertEquals("m4", amTim.getDisplayUnit().getQuantity().getSiDimensions().toString(false, false, false),
297 "unit of m2 * m2 should be m4");
298 assertEquals("", amDiv.getDisplayUnit().getQuantity().getSiDimensions().toString(false, false, false),
299 "unit of m2 / m2 should be empty string");
300 for (int index = 0; index < testData.length; index++)
301 {
302 double tolerance =
303 Double.isFinite(amTim.getSI(index)) ? Math.abs(amTim.getSI(index) / 10000.0d) : 0.1d;
304 assertEquals(
305 au.getScale().toStandardUnit(testData[index])
306 * au2.getScale().toStandardUnit(testData2[index]),
307 amTim.getSI(index), tolerance, "value in m2 * m2 matches");
308 tolerance = Double.isFinite(amDiv.getSI(index)) ? Math.abs(amDiv.getSI(index) / 10000.0d) : 0.1d;
309 assertEquals(
310 au.getScale().toStandardUnit(testData[index])
311 / au2.getScale().toStandardUnit(testData2[index]),
312 amDiv.getSI(index), tolerance, "value in m2 / m2 matches (could be NaN)");
313 }
314
315 }
316 }
317 }
318 }
319 }
320
321
322
323
324 @Test
325 public final void testSetDisplayUnit()
326 {
327 SpeedVector s = new SpeedVector(new double[] {10.0, 20.0}, SpeedUnit.KM_PER_HOUR);
328 SpeedVector t = s.setDisplayUnit(SpeedUnit.MILE_PER_HOUR);
329 assertTrue(s == t);
330 SpeedVector u = new SpeedVector(new double[] {10.0, 20.0}).setDisplayUnit(SpeedUnit.KM_PER_HOUR);
331 assertEquals(SpeedUnit.KM_PER_HOUR, u.getDisplayUnit());
332 assertEquals(10.0, u.getSI(0));
333 }
334
335
336
337
338 @Test
339 public void testImmutableVector()
340 {
341 double[] denseTestData = DOUBLEVECTOR.denseArray(105);
342 double[] sparseTestData = DOUBLEVECTOR.sparseArray(105);
343
344 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
345 {
346 for (AreaUnit au : new AreaUnit[] {AreaUnit.SQUARE_METER, AreaUnit.ACRE})
347 {
348 double[] testData = storageType.equals(StorageType.DENSE) ? denseTestData : sparseTestData;
349 AreaVector am = new AreaVector(DoubleVectorData.instantiate(testData, au.getScale(), storageType), au);
350 am = am.immutable();
351 final AreaVector amPtr = am;
352 Area fa = Area.of(10.0d, "m^2");
353 UnitTest.testFail(() -> amPtr.assign(DoubleMathFunctions.ABS),
354 "ImmutableVector.assign(...) should throw error");
355 UnitTest.testFail(() -> amPtr.decrementBy(fa), "ImmutableVector.decrementBy(scalar) should throw error");
356 UnitTest.testFail(() -> amPtr.decrementBy(amPtr), "ImmutableVector.decrementBy(vector) should throw error");
357 UnitTest.testFail(() -> amPtr.incrementBy(fa), "ImmutableVector.incrementBy(scalar) should throw error");
358 UnitTest.testFail(() -> amPtr.incrementBy(amPtr), "ImmutableVector.incrementBy(vector) should throw error");
359 UnitTest.testFail(() -> amPtr.divideBy(2.0d), "ImmutableVector.divideBy(factor) should throw error");
360 UnitTest.testFail(() -> amPtr.multiplyBy(2.0d), "ImmutableVector.multiplyBy(factor) should throw error");
361 UnitTest.testFail(() -> amPtr.set(1, fa), "ImmutableVector.set() should throw error");
362 UnitTest.testFail(() -> amPtr.setSI(1, 20.1d), "ImmutableVector.setSI() should throw error");
363 UnitTest.testFail(() -> amPtr.setInUnit(1, 15.2d), "ImmutableVector.setInUnit(f) should throw error");
364 UnitTest.testFail(() -> amPtr.setInUnit(1, 15.2d, AreaUnit.ARE),
365 "ImmutableVector.setInUnit(f, u) should throw error");
366 UnitTest.testFail(() -> amPtr.abs(), "ImmutableVector.abs() should throw error");
367 UnitTest.testFail(() -> amPtr.ceil(), "ImmutableVector.ceil() should throw error");
368 UnitTest.testFail(() -> amPtr.floor(), "ImmutableVector.floor() should throw error");
369 UnitTest.testFail(() -> amPtr.neg(), "ImmutableVector.neg() should throw error");
370 UnitTest.testFail(() -> amPtr.rint(), "ImmutableVector.rint() should throw error");
371 }
372 }
373 }
374
375
376
377
378 @Test
379 public void testVectorToString()
380 {
381 double[] denseTestData = DOUBLEVECTOR.denseArray(105);
382 double[] sparseTestData = DOUBLEVECTOR.sparseArray(105);
383
384 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
385 {
386 for (AreaUnit au : new AreaUnit[] {AreaUnit.SQUARE_METER, AreaUnit.ACRE})
387 {
388 double[] testData = storageType.equals(StorageType.DENSE) ? denseTestData : sparseTestData;
389 AreaVector am = new AreaVector(DoubleVectorData.instantiate(testData, au.getScale(), storageType), au);
390 String s1 = am.toString();
391 assertTrue(s1.contains(au.getDefaultTextualAbbreviation()));
392 String s2 = am.toString(AreaUnit.SQUARE_INCH);
393 assertTrue(s2.contains(AreaUnit.SQUARE_INCH.getDefaultTextualAbbreviation()));
394 String s3 = am.toString(AreaUnit.SQUARE_INCH, true, true);
395 assertTrue(s3.contains(AreaUnit.SQUARE_INCH.getDefaultTextualAbbreviation()));
396 if (storageType.equals(StorageType.DENSE))
397 {
398 assertTrue(s3.contains("Dense"));
399 assertFalse(s3.contains("Sparse"));
400 }
401 else
402 {
403 assertFalse(s3.contains("Dense"));
404 assertTrue(s3.contains("Sparse"));
405 }
406 assertTrue(s3.contains("Rel"));
407 assertFalse(s3.contains("Abs"));
408 assertTrue(s3.contains("Immutable"));
409 assertFalse(s3.contains("Mutable"));
410 AreaVector ammut = am.mutable();
411 String smut = ammut.toString(AreaUnit.SQUARE_INCH, true, true);
412 assertFalse(smut.contains("Immutable"));
413 assertTrue(smut.contains("Mutable"));
414 String sNotVerbose = ammut.toString(false, false);
415 assertFalse(sNotVerbose.contains("Rel"));
416 assertFalse(sNotVerbose.contains("Abs"));
417 assertFalse(sNotVerbose.contains("Immutable"));
418 assertFalse(sNotVerbose.contains("Mutable"));
419 assertFalse(sNotVerbose.contains(au.getDefaultTextualAbbreviation()));
420 }
421 }
422 TimeVector tm = new TimeVector(
423 DoubleVectorData.instantiate(denseTestData, TimeUnit.DEFAULT.getScale(), StorageType.DENSE), TimeUnit.DEFAULT);
424 String st = tm.toString(TimeUnit.DEFAULT, true, true);
425 assertFalse(st.contains("Rel"));
426 assertTrue(st.contains("Abs"));
427 LengthVector lm = new LengthVector(
428 DoubleVectorData.instantiate(denseTestData, LengthUnit.SI.getScale(), StorageType.DENSE), LengthUnit.SI);
429 String sl = lm.toString(LengthUnit.SI, true, true);
430 assertTrue(sl.contains("Rel"));
431 assertFalse(sl.contains("Abs"));
432 }
433
434
435
436
437 @Test
438 public void testSpecialVectorMethodsRelWithAbs()
439 {
440 double[] denseTestData = DOUBLEVECTOR.denseArray(105);
441 TimeVector tm = new TimeVector(
442 DoubleVectorData.instantiate(denseTestData, TimeUnit.DEFAULT.getScale(), StorageType.DENSE), TimeUnit.DEFAULT);
443 DurationVector dm = new DurationVector(
444 DoubleVectorData.instantiate(denseTestData, DurationUnit.MINUTE.getScale(), StorageType.DENSE),
445 DurationUnit.SECOND);
446 assertTrue(tm.isAbsolute());
447 assertFalse(dm.isAbsolute());
448 assertFalse(tm.isRelative());
449 assertTrue(dm.isRelative());
450
451 TimeVector absPlusRel = tm.plus(dm);
452 TimeVector absMinusRel = tm.minus(dm);
453 double[] halfDenseData = DOUBLEVECTOR.denseArray(105);
454 for (int index = 0; index < halfDenseData.length; index++)
455 {
456 halfDenseData[index] *= 0.5;
457 }
458 TimeVector halfTimeVector = new TimeVector(
459 DoubleVectorData.instantiate(halfDenseData, TimeUnit.DEFAULT.getScale(), StorageType.DENSE), TimeUnit.DEFAULT);
460 DurationVector absMinusAbs = tm.minus(halfTimeVector);
461 TimeVector absDecByRelS = tm.mutable().decrementBy(Duration.of(1.0d, "min"));
462 TimeVector absDecByRelM = tm.mutable().decrementBy(dm.divide(2.0d));
463 TimeVector relPlusAbs = dm.plus(tm);
464 for (int index = 0; index < denseTestData.length; index++)
465 {
466 assertEquals(61.0 * denseTestData[index], absPlusRel.getSI(index), 0.01, "absPlusRel");
467 assertEquals(-59.0 * denseTestData[index], absMinusRel.getSI(index), 0.01, "absMinusRel");
468 assertEquals(denseTestData[index] / 2.0, absMinusAbs.getSI(index), 0.01, "absMinusAbs");
469 assertEquals(denseTestData[index] - 60.0, absDecByRelS.getSI(index), 0.01, "absDecByRelS");
470 assertEquals(-29.0 * denseTestData[index], absDecByRelM.getSI(index), 0.01, "absDecByRelM");
471 assertEquals(61.0 * denseTestData[index], relPlusAbs.getSI(index), 0.01, "relPlusAbs");
472 }
473 for (int dLength : new int[] {-1, 1})
474 {
475 double[] other = DOUBLEVECTOR.denseArray(denseTestData.length + dLength);
476 TimeVector wrongTimeVector = new TimeVector(
477 DoubleVectorData.instantiate(other, TimeUnit.DEFAULT.getScale(), StorageType.DENSE), TimeUnit.DEFAULT);
478 try
479 {
480 tm.mutable().minus(wrongTimeVector);
481 fail("Mismatching size should have thrown a ValueRuntimeException");
482 }
483 catch (ValueRuntimeException vre)
484 {
485
486 }
487 }
488 assertTrue(DoubleVectorData.instantiate(denseTestData, TimeUnit.DEFAULT.getScale(), StorageType.DENSE).toString()
489 .startsWith("DoubleVectorData"), "toString returns something informative");
490 }
491
492
493
494
495 @Test
496 public void testInstantiateAbs()
497 {
498 double[] denseTestData = DOUBLEVECTOR.denseArray(105);
499 TimeVector timeVector = new TimeVector(
500 DoubleVectorData.instantiate(denseTestData, TimeUnit.DEFAULT.getScale(), StorageType.DENSE), TimeUnit.DEFAULT);
501 DurationVector durationVector = new DurationVector(
502 DoubleVectorData.instantiate(denseTestData, DurationUnit.MINUTE.getScale(), StorageType.DENSE),
503 DurationUnit.SECOND);
504
505 double[] halfDenseData = DOUBLEVECTOR.denseArray(105);
506 for (int index = 0; index < halfDenseData.length; index++)
507 {
508 halfDenseData[index] *= 0.5;
509 }
510 TimeVector relPlusAbsTime = durationVector.plus(timeVector);
511 for (int index = 0; index < denseTestData.length; index++)
512 {
513 assertEquals(61.0 * denseTestData[index], relPlusAbsTime.getSI(index), 0.01, "relPlusAbsTime");
514 }
515 Time time = durationVector.instantiateScalarAbsSI(123.456f, TimeUnit.EPOCH_DAY);
516 assertEquals(TimeUnit.EPOCH_DAY, time.getDisplayUnit(), "Unit of instantiateScalarAbsSI matches");
517 assertEquals(123.456f, time.si, 0.1, "Value of instantiateScalarAbsSI matches");
518
519 AngleVector angleVector = new AngleVector(
520 DoubleVectorData.instantiate(denseTestData, AngleUnit.DEGREE.getScale(), StorageType.DENSE), AngleUnit.DEGREE);
521 DirectionVector directionVector = new DirectionVector(
522 DoubleVectorData.instantiate(denseTestData, DirectionUnit.EAST_DEGREE.getScale(), StorageType.DENSE),
523 DirectionUnit.EAST_DEGREE);
524
525 DirectionVector relPlusAbsDirection = angleVector.plus(directionVector);
526 for (int index = 0; index < denseTestData.length; index++)
527 {
528 assertEquals(2.0 / 180 * Math.PI * denseTestData[index], relPlusAbsDirection.getSI(index), 0.01,
529 "relPlusAbsDirection");
530 }
531 Direction direction = angleVector.instantiateScalarAbsSI(123.456f, DirectionUnit.NORTH_RADIAN);
532 assertEquals(DirectionUnit.NORTH_RADIAN, direction.getDisplayUnit(), "Unit of instantiateScalarAbsSI matches");
533 assertEquals(123.456f, direction.si, 0.1, "Value of instantiateScalarAbsSI matches");
534
535 TemperatureVector temperatureVector = new TemperatureVector(
536 DoubleVectorData.instantiate(denseTestData, TemperatureUnit.DEGREE_FAHRENHEIT.getScale(), StorageType.DENSE),
537 TemperatureUnit.DEGREE_FAHRENHEIT);
538 AbsoluteTemperatureVector absoluteTemperatureVector = new AbsoluteTemperatureVector(
539 DoubleVectorData.instantiate(denseTestData, AbsoluteTemperatureUnit.KELVIN.getScale(), StorageType.DENSE),
540 AbsoluteTemperatureUnit.KELVIN);
541
542 AbsoluteTemperatureVector relPlusAbsTemperature = temperatureVector.plus(absoluteTemperatureVector);
543 for (int index = 0; index < denseTestData.length; index++)
544 {
545 assertEquals((1.0 + 5.0 / 9.0) * denseTestData[index], relPlusAbsTemperature.getSI(index), 0.01,
546 "relPlusAbsTemperature");
547 }
548 AbsoluteTemperature absoluteTemperature =
549 temperatureVector.instantiateScalarAbsSI(123.456f, AbsoluteTemperatureUnit.DEGREE_FAHRENHEIT);
550 assertEquals(AbsoluteTemperatureUnit.DEGREE_FAHRENHEIT, absoluteTemperature.getDisplayUnit(),
551 "Unit of instantiateScalarAbsSI matches");
552 assertEquals(123.456f, absoluteTemperature.si, 0.1, "Value of instantiateScalarAbsSI matches");
553
554 LengthVector lengthVector = new LengthVector(
555 DoubleVectorData.instantiate(denseTestData, LengthUnit.MILE.getScale(), StorageType.DENSE), LengthUnit.MILE);
556 PositionVector positionVector = new PositionVector(
557 DoubleVectorData.instantiate(denseTestData, PositionUnit.KILOMETER.getScale(), StorageType.DENSE),
558 PositionUnit.KILOMETER);
559
560 PositionVector relPlusAbsPosition = lengthVector.plus(positionVector);
561 for (int index = 0; index < denseTestData.length; index++)
562 {
563 assertEquals(2609.344 * denseTestData[index], relPlusAbsPosition.getSI(index), 1, "relPlusAbsPosition");
564 }
565 Position position = lengthVector.instantiateScalarAbsSI(123.456f, PositionUnit.ANGSTROM);
566 assertEquals(PositionUnit.ANGSTROM, position.getDisplayUnit(), "Unit of instantiateScalarAbsSI matches");
567 assertEquals(123.456f, position.si, 0.1, "Value of instantiateScalarAbsSI matches");
568 }
569
570
571
572
573 @SuppressWarnings("unlikely-arg-type")
574 @Test
575 public void testEquals()
576 {
577 double[] testData = DOUBLEVECTOR.denseArray(123);
578 testData[2] = 0;
579 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
580 {
581 DoubleVectorData dvd = DoubleVectorData.instantiate(testData, TemperatureUnit.KELVIN.getScale(), storageType);
582 assertTrue(dvd.equals(dvd), "Double vector data is equal to itself");
583 assertFalse(dvd.equals(null), "Double vector data is not equal to null");
584 assertFalse(dvd.equals("some string"), "Double vector data is not equal to some string");
585 assertTrue(dvd.equals(dvd.toSparse()), "Double vector is equal to sparse version of itself");
586 assertTrue(dvd.equals(dvd.toDense()), "Double vector is equal to dense version of itself");
587 for (StorageType storageType2 : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
588 {
589 DoubleVectorData dvd2 = DoubleVectorData.instantiate(testData, TemperatureUnit.KELVIN.getScale(), storageType2);
590 assertEquals(dvd, dvd2,
591 "Double vector data is equal to other double vector containing same values regardless of storage type");
592 double[] testData2 = DOUBLEVECTOR.denseArray(122);
593 testData2[2] = 0;
594 dvd2 = DoubleVectorData.instantiate(testData2, TemperatureUnit.KELVIN.getScale(), storageType2);
595 assertFalse(dvd.equals(dvd2),
596 "Double vector data is not equal to other double vector containing same values except last one");
597 testData2 = DOUBLEVECTOR.denseArray(123);
598 dvd2 = DoubleVectorData.instantiate(testData2, TemperatureUnit.KELVIN.getScale(), storageType2);
599 assertFalse(dvd.equals(dvd2),
600 "Double vector data is not equal to other double vector containing same values except for one zero");
601 }
602 }
603 }
604
605
606
607
608 @Test
609 public void operationTest()
610 {
611 double[] testValues = new double[] {0, 123.456d, 0, -273.15, -273.15, 0, -273.15, 234.567d, 0, 0};
612 double[] testValues2 = new double[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
613 for (AbsoluteTemperatureUnit temperatureUnit : new AbsoluteTemperatureUnit[] {AbsoluteTemperatureUnit.KELVIN,
614 AbsoluteTemperatureUnit.DEGREE_CELSIUS, AbsoluteTemperatureUnit.DEGREE_FAHRENHEIT})
615 {
616 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
617 {
618 AbsoluteTemperatureVector atv = new AbsoluteTemperatureVector(testValues, temperatureUnit, storageType);
619 for (TemperatureUnit relativeTemperatureUnit : new TemperatureUnit[] {TemperatureUnit.KELVIN,
620 TemperatureUnit.DEGREE_CELSIUS, TemperatureUnit.DEGREE_FAHRENHEIT})
621 {
622 for (StorageType storageType2 : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
623 {
624 TemperatureVector rtv = new TemperatureVector(testValues2, relativeTemperatureUnit, storageType2);
625 AbsoluteTemperatureVector sumtv = atv.plus(rtv);
626 compareSum(atv.getValuesInUnit(AbsoluteTemperatureUnit.KELVIN),
627 rtv.getValuesInUnit(TemperatureUnit.KELVIN),
628 sumtv.getValuesInUnit(AbsoluteTemperatureUnit.KELVIN));
629 AbsoluteTemperatureVector difftv = atv.minus(rtv);
630 compareSum(rtv.getValuesInUnit(TemperatureUnit.KELVIN),
631 difftv.getValuesInUnit(AbsoluteTemperatureUnit.KELVIN),
632 atv.getValuesInUnit(AbsoluteTemperatureUnit.KELVIN));
633
634 String s = atv.toString(temperatureUnit);
635 assertTrue(s.startsWith("["), "toString returns something sensible");
636 assertTrue(s.endsWith("] " + temperatureUnit.toString()), "toString returns something sensible");
637
638 s = atv.toString(true, true);
639 assertTrue(s.contains("Immutable"), "toString includes Immutable");
640 assertTrue(s.contains("Abs"), "toString includes Abs");
641 assertTrue(s.contains(atv.isDense() ? "Dense" : "Sparse"), "toString includes Dense or Sparse");
642 assertTrue(s.endsWith("] " + temperatureUnit.toString()), "toString returns something sensible");
643 s = atv.mutable().toString(true, true);
644 assertTrue(s.contains("Mutable"), "toString includes Mutable");
645
646 s = rtv.toString();
647 assertTrue(s.startsWith("["), "toString returns something sensible");
648 assertTrue(s.endsWith("] " + relativeTemperatureUnit.toString()),
649 "toString returns something sensible");
650 s = rtv.toString(true, true);
651 assertTrue(s.contains("Immutable"), "toString includes Immutable");
652 assertTrue(s.contains("Rel"), "toString includes Rel");
653 assertTrue(s.contains(rtv.isDense() ? "Dense" : "Sparse"), "toString includes Dense or Sparse");
654 assertTrue(s.endsWith("] " + relativeTemperatureUnit.toString()),
655 "toString returns something sensible");
656 s = rtv.mutable().toString(true, true);
657 assertTrue(s.contains("Mutable"), "toString includes Mutable");
658
659 }
660 }
661 }
662 }
663 }
664
665
666
667
668
669
670
671 public void compareSum(final double[] left, final double[] right, final double[] sum)
672 {
673 assertEquals(left.length, sum.length, "length of left must equal length of sum");
674 assertEquals(right.length, sum.length, "length of right must equal length of sum");
675 for (int i = 0; i < sum.length; i++)
676 {
677 assertEquals(left[i] + right[i], sum[i], 0.001, "left plus right is sum");
678 }
679 }
680
681 }