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