1 package org.djunits.value.vfloat.matrix;
2
3 import static org.junit.Assert.assertArrayEquals;
4 import static org.junit.Assert.assertEquals;
5 import static org.junit.Assert.assertNotEquals;
6 import static org.junit.Assert.assertTrue;
7 import static org.junit.Assert.fail;
8
9 import org.djunits.Try;
10 import org.djunits.unit.AbsoluteLinearUnit;
11 import org.djunits.unit.AreaUnit;
12 import org.djunits.unit.LengthUnit;
13 import org.djunits.unit.SIUnit;
14 import org.djunits.unit.SpeedUnit;
15 import org.djunits.unit.Unit;
16 import org.djunits.unit.quantity.Quantities;
17 import org.djunits.unit.quantity.Quantity;
18 import org.djunits.unit.util.UNITS;
19 import org.djunits.unit.util.UnitException;
20 import org.djunits.value.CLASSNAMES;
21 import org.djunits.value.ValueRuntimeException;
22 import org.djunits.value.storage.StorageType;
23 import org.djunits.value.vfloat.matrix.base.AbstractFloatMatrixAbs;
24 import org.djunits.value.vfloat.matrix.base.AbstractFloatMatrixRelWithAbs;
25 import org.djunits.value.vfloat.matrix.base.FloatMatrix;
26 import org.djunits.value.vfloat.matrix.base.FloatMatrixInterface;
27 import org.djunits.value.vfloat.matrix.data.FloatMatrixData;
28 import org.djunits.value.vfloat.scalar.FloatArea;
29 import org.djunits.value.vfloat.scalar.FloatLength;
30 import org.djunits.value.vfloat.scalar.FloatSIScalar;
31 import org.djunits.value.vfloat.scalar.base.AbstractFloatScalarAbs;
32 import org.djunits.value.vfloat.scalar.base.AbstractFloatScalarRelWithAbs;
33 import org.djunits.value.vfloat.scalar.base.FloatScalarInterface;
34 import org.djunits.value.vfloat.vector.FloatSIVector;
35 import org.djunits.value.vfloat.vector.base.AbstractFloatVectorAbs;
36 import org.djunits.value.vfloat.vector.base.AbstractFloatVectorRelWithAbs;
37 import org.djunits.value.vfloat.vector.base.FloatVectorInterface;
38 import org.djunits.value.vfloat.vector.data.FloatVectorData;
39 import org.junit.Test;
40
41
42
43
44
45
46
47
48
49 public class FloatMatrixInstantiateTest
50 {
51
52
53
54
55
56
57
58 @Test
59 public <U extends Unit<U>, S extends FloatScalarInterface<U, S>, V extends FloatVectorInterface<U, S, V>,
60 M extends FloatMatrixInterface<U, S, V, M>> void instatiateAllMatrixTypes()
61 {
62
63 LengthUnit length = UNITS.METER;
64 if (length == null)
65 {
66 fail();
67 }
68
69 for (String scalarName : CLASSNAMES.ALL_LIST)
70 {
71 @SuppressWarnings("unchecked")
72 Quantity<U> quantity = (Quantity<U>) Quantities.INSTANCE.getQuantity(scalarName + "Unit");
73 U standardUnit = quantity.getStandardUnit();
74 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
75 {
76 float[][] testValues = FLOATMATRIX.denseRectArrays(5, 10);
77 FloatMatrixData dmd = FloatMatrixData.instantiate(testValues, standardUnit.getScale(), storageType);
78 FloatMatrixInterface<U, S, V, M> floatMatrix = FloatMatrix.instantiate(testValues, standardUnit, storageType);
79 Class<S> scalarClass = floatMatrix.getScalarClass();
80 assertEquals("scalar class should have the right name", "Float" + scalarName, scalarClass.getSimpleName());
81 Class<V> vectorClass = floatMatrix.getVectorClass();
82 assertEquals("vector class should have the right name", "Float" + scalarName + "Vector",
83 vectorClass.getSimpleName());
84 FloatMatrixInterface<U, S, V, M> floatMatrix2 = floatMatrix.instantiateMatrix(dmd, standardUnit);
85 assertEquals("matrix constructed from FloatMatrixData should be equal to matrix constructed from float[][]",
86 floatMatrix, floatMatrix2);
87 FloatVectorData dvd =
88 FloatVectorData.instantiate(floatMatrix.getRowSI(0), standardUnit.getScale(), storageType);
89 FloatVectorInterface<U, S, V> floatVector = floatMatrix.instantiateVector(dvd, standardUnit);
90 assertArrayEquals("Float vector contains values from row 0", new float[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
91 floatVector.getValuesSI(), 0.001f);
92
93 FloatScalarInterface<U, S> floatScalar = floatMatrix.instantiateScalarSI(1.234f, standardUnit);
94 assertEquals("Constructed scalar has correct value", 1.234f, floatScalar.getSI(), 0.001);
95 assertEquals("Constructed scalar has correct unit", standardUnit, floatScalar.getDisplayUnit());
96 }
97 }
98 }
99
100
101
102
103
104
105 @SuppressWarnings("unchecked")
106 @Test
107 public <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>> void instantiateRelAbsMatrixTypes()
108 {
109
110 LengthUnit length = UNITS.METER;
111 if (length == null)
112 {
113 fail();
114 }
115
116 for (int classIndex = 0; classIndex < CLASSNAMES.REL_WITH_ABS_LIST.size(); classIndex++)
117 {
118 String relScalarName = CLASSNAMES.REL_WITH_ABS_LIST.get(classIndex);
119 String absScalarName = CLASSNAMES.ABS_LIST.get(classIndex);
120 Quantity<RU> relQuantity = (Quantity<RU>) Quantities.INSTANCE.getQuantity(relScalarName + "Unit");
121 Quantity<AU> absQuantity = (Quantity<AU>) Quantities.INSTANCE.getQuantity(absScalarName + "Unit");
122 RU relStandardUnit = relQuantity.getStandardUnit();
123 AU absStandardUnit = absQuantity.getStandardUnit();
124 for (StorageType storageType : new StorageType[] {StorageType.DENSE, StorageType.SPARSE})
125 {
126 float[][] testValues = FLOATMATRIX.denseRectArrays(5, 10);
127 FloatMatrixData dmd = FloatMatrixData.instantiate(testValues, relStandardUnit.getScale(), storageType);
128 AbstractFloatMatrixRelWithAbs<AU, ?, ?, ?, RU, ?, ?, ?> relFloatMatrix = (AbstractFloatMatrixRelWithAbs<AU, ?,
129 ?, ?, RU, ?, ?, ?>) FloatMatrix.instantiate(testValues, relStandardUnit, storageType);
130 AbstractFloatMatrixAbs<AU, ?, ?, ?, RU, ?, ?, ?> absFloatMatrix = (AbstractFloatMatrixAbs<AU, ?, ?, ?, RU, ?, ?,
131 ?>) FloatMatrix.instantiate(testValues, absStandardUnit, storageType);
132
133 FloatMatrixInterface<AU, ?, ?, ?> absFloatMatrix2 = relFloatMatrix.instantiateMatrixAbs(dmd, absStandardUnit);
134 assertEquals("matrix constructed from FloatMatrixData should be equal to matrix constructed from float[][]",
135 absFloatMatrix, absFloatMatrix2);
136 FloatVectorData dvd =
137 FloatVectorData.instantiate(relFloatMatrix.getRowSI(0), relStandardUnit.getScale(), storageType);
138 AbstractFloatVectorAbs<AU, ?, ?, RU, ?, ?> absFloatVector =
139 relFloatMatrix.instantiateVectorAbs(dvd, absStandardUnit);
140 assertArrayEquals("Float vector contains values from row 0", new float[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
141 absFloatVector.getValuesSI(), 0.001f);
142 AbstractFloatScalarAbs<AU, ?, RU, ?> absFloatScalar =
143 relFloatMatrix.instantiateScalarAbsSI(1.234f, absStandardUnit);
144 assertEquals("Constructed scalar has correct value", 1.234f, absFloatScalar.si, 0.001f);
145 assertEquals("Constructed scalar has correct unit", absStandardUnit, absFloatScalar.getDisplayUnit());
146
147 FloatMatrixInterface<RU, ?, ?, ?> relFloatMatrix2 = absFloatMatrix.instantiateMatrixRel(dmd, relStandardUnit);
148 assertEquals("matrix constructed from FloatMatrixData should be equal to matrix constructed from float[][]",
149 relFloatMatrix, relFloatMatrix2);
150 dvd = FloatVectorData.instantiate(absFloatMatrix.getRowSI(0), absStandardUnit.getScale(), storageType);
151 AbstractFloatVectorRelWithAbs<AU, ?, ?, RU, ?, ?> relFloatVector =
152 absFloatMatrix.instantiateVectorRel(dvd, relStandardUnit);
153 assertArrayEquals("Float vector contains values from row 0", new float[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
154 relFloatVector.getValuesSI(), 0.001f);
155 AbstractFloatScalarRelWithAbs<AU, ?, RU, ?> relFloatScalar =
156 absFloatMatrix.instantiateScalarRelSI(1.234f, relStandardUnit);
157 assertEquals("Constructed scalar has correct value", 1.234f, relFloatScalar.si, 0.001f);
158 assertEquals("Constructed scalar has correct unit", relStandardUnit, relFloatScalar.getDisplayUnit());
159
160 }
161 }
162 }
163
164
165
166
167 @Test
168 public void testInstantiateSquareDenseData()
169 {
170 FloatLengthMatrix lmdkm10 =
171 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), LengthUnit.KILOMETER, StorageType.DENSE);
172 assertEquals(10, lmdkm10.rows());
173 assertEquals(10, lmdkm10.cols());
174 assertEquals(100, lmdkm10.cardinality());
175 assertEquals(50 * 101 * 1000.0, lmdkm10.zSum().getSI(), 0.001);
176 assertEquals(LengthUnit.KILOMETER, lmdkm10.getDisplayUnit());
177
178 FloatLengthMatrix lmskm10 =
179 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), LengthUnit.KILOMETER, StorageType.SPARSE);
180 assertEquals(10, lmskm10.rows());
181 assertEquals(10, lmskm10.cols());
182 assertEquals(100, lmskm10.cardinality());
183 assertEquals(50 * 101 * 1000.0, lmskm10.zSum().getSI(), 0.001);
184 assertEquals(LengthUnit.KILOMETER, lmskm10.getDisplayUnit());
185
186 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
187 assertEquals(lmskm10, lmskm10.toDense().toSparse());
188 assertEquals(lmdkm10, lmskm10.toDense());
189 assertEquals(lmskm10, lmdkm10.toSparse());
190 assertEquals(lmdkm10, lmdkm10.toSparse());
191 assertEquals(lmskm10, lmskm10.toDense());
192 assertEquals(lmdkm10, lmdkm10.toDense());
193 assertEquals(lmskm10, lmskm10.toSparse());
194
195 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
196 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
197 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
198 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
199 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
200 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
201 assertEquals(lmdkm10.hashCode(), lmdkm10.toDense().hashCode());
202 assertEquals(lmskm10.hashCode(), lmskm10.toSparse().hashCode());
203
204 assertTrue(lmdkm10.isDense());
205 assertTrue(lmskm10.isSparse());
206
207 FloatLengthMatrix lmdsi10 =
208 FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(10, 10), LengthUnit.CENTIMETER, StorageType.DENSE);
209 assertEquals(10, lmdsi10.rows());
210 assertEquals(10, lmdsi10.cols());
211 assertEquals(100, lmdsi10.cardinality());
212 assertEquals(50 * 101, lmdsi10.zSum().getSI(), 0.001);
213 assertEquals(LengthUnit.CENTIMETER, lmdsi10.getDisplayUnit());
214
215 FloatLengthMatrix lmssi10 =
216 FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(10, 10), LengthUnit.CENTIMETER, StorageType.SPARSE);
217 assertEquals(10, lmssi10.rows());
218 assertEquals(10, lmssi10.cols());
219 assertEquals(100, lmssi10.cardinality());
220 assertEquals(50 * 101, lmssi10.zSum().getSI(), 0.001);
221 assertEquals(LengthUnit.CENTIMETER, lmssi10.getDisplayUnit());
222
223 FloatLengthMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(10, 10, FloatLength.class),
224 LengthUnit.HECTOMETER, StorageType.DENSE);
225 assertEquals(10, lmdsc10.rows());
226 assertEquals(10, lmdsc10.cols());
227 assertEquals(100, lmdsc10.cardinality());
228 assertEquals(50 * 101, lmdsc10.zSum().getSI(), 0.001);
229 assertEquals(LengthUnit.HECTOMETER, lmdsc10.getDisplayUnit());
230
231 FloatLengthMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(10, 10, FloatLength.class),
232 LengthUnit.HECTOMETER, StorageType.SPARSE);
233 assertEquals(10, lmssc10.rows());
234 assertEquals(10, lmssc10.cols());
235 assertEquals(100, lmssc10.cardinality());
236 assertEquals(50 * 101, lmssc10.zSum().getSI(), 0.001);
237 assertEquals(LengthUnit.HECTOMETER, lmssc10.getDisplayUnit());
238 }
239
240
241
242
243 @Test
244 public void testInstantiatSquareSparseData()
245 {
246 FloatLengthMatrix lmdkm10 =
247 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), LengthUnit.KILOMETER, StorageType.DENSE);
248 assertEquals(10, lmdkm10.rows());
249 assertEquals(10, lmdkm10.cols());
250 assertEquals(10, lmdkm10.cardinality());
251 assertEquals(5 * 11 * 1000.0, lmdkm10.zSum().getSI(), 0.001);
252 assertEquals(LengthUnit.KILOMETER, lmdkm10.getDisplayUnit());
253
254 FloatLengthMatrix lmskm10 =
255 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), LengthUnit.KILOMETER, StorageType.SPARSE);
256 assertEquals(10, lmskm10.rows());
257 assertEquals(10, lmskm10.cols());
258 assertEquals(10, lmskm10.cardinality());
259 assertEquals(5 * 11 * 1000.0, lmskm10.zSum().getSI(), 0.001);
260 assertEquals(LengthUnit.KILOMETER, lmskm10.getDisplayUnit());
261
262 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
263 assertEquals(lmskm10, lmskm10.toDense().toSparse());
264 assertEquals(lmdkm10, lmskm10.toDense());
265 assertEquals(lmskm10, lmdkm10.toSparse());
266 assertEquals(lmdkm10, lmdkm10.toSparse());
267 assertEquals(lmskm10, lmskm10.toDense());
268
269 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
270 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
271 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
272 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
273 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
274 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
275
276 FloatLengthMatrix lmdsi10 =
277 FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(10, 10), LengthUnit.CENTIMETER, StorageType.DENSE);
278 assertEquals(10, lmdsi10.rows());
279 assertEquals(10, lmdsi10.cols());
280 assertEquals(10, lmdsi10.cardinality());
281 assertEquals(5 * 11, lmdsi10.zSum().getSI(), 0.001);
282 assertEquals(LengthUnit.CENTIMETER, lmdsi10.getDisplayUnit());
283
284 FloatLengthMatrix lmssi10 =
285 FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(10, 10), LengthUnit.CENTIMETER, StorageType.SPARSE);
286 assertEquals(10, lmssi10.rows());
287 assertEquals(10, lmssi10.cols());
288 assertEquals(10, lmssi10.cardinality());
289 assertEquals(5 * 11, lmssi10.zSum().getSI(), 0.001);
290 assertEquals(LengthUnit.CENTIMETER, lmssi10.getDisplayUnit());
291
292 FloatLengthMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(10, 10, FloatLength.class),
293 LengthUnit.HECTOMETER, StorageType.DENSE);
294 assertEquals(10, lmdsc10.rows());
295 assertEquals(10, lmdsc10.cols());
296 assertEquals(10, lmdsc10.cardinality());
297 assertEquals(5 * 11, lmdsc10.zSum().getSI(), 0.001);
298 assertEquals(LengthUnit.HECTOMETER, lmdsc10.getDisplayUnit());
299
300 FloatLengthMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(10, 10, FloatLength.class),
301 LengthUnit.HECTOMETER, StorageType.SPARSE);
302 assertEquals(10, lmssc10.rows());
303 assertEquals(10, lmssc10.cols());
304 assertEquals(10, lmssc10.cardinality());
305 assertEquals(5 * 11, lmssc10.zSum().getSI(), 0.001);
306 assertEquals(LengthUnit.HECTOMETER, lmssc10.getDisplayUnit());
307
308 FloatLengthMatrix lmdtu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(10, 10, FloatLength.class), 10, 10,
309 LengthUnit.NANOMETER, StorageType.DENSE);
310 assertEquals(10, lmdtu10.rows());
311 assertEquals(10, lmdtu10.cols());
312 assertEquals(10, lmdtu10.cardinality());
313 assertEquals(5 * 11, lmdtu10.zSum().getSI(), 0.001);
314 assertEquals(LengthUnit.NANOMETER, lmdtu10.getDisplayUnit());
315
316 FloatLengthMatrix lmstu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(10, 10, FloatLength.class), 10, 10,
317 LengthUnit.NANOMETER, StorageType.SPARSE);
318 assertEquals(10, lmstu10.rows());
319 assertEquals(10, lmstu10.cols());
320 assertEquals(10, lmstu10.cardinality());
321 assertEquals(5 * 11, lmstu10.zSum().getSI(), 0.001);
322 assertEquals(LengthUnit.NANOMETER, lmstu10.getDisplayUnit());
323 }
324
325
326
327
328 @Test
329 public void testInstantiateSquareDenseDataWithClass()
330 {
331 FloatAreaMatrix lmdkm10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), AreaUnit.SQUARE_KILOMETER,
332 StorageType.DENSE, FloatAreaMatrix.class);
333 assertEquals(10, lmdkm10.rows());
334 assertEquals(10, lmdkm10.cols());
335 assertEquals(100, lmdkm10.cardinality());
336 assertEquals(50 * 101 * 1.0E6, lmdkm10.zSum().getSI(), 1000);
337 assertEquals(AreaUnit.SQUARE_KILOMETER, lmdkm10.getDisplayUnit());
338
339 FloatAreaMatrix lmskm10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), AreaUnit.SQUARE_KILOMETER,
340 StorageType.SPARSE, FloatAreaMatrix.class);
341 assertEquals(10, lmskm10.rows());
342 assertEquals(10, lmskm10.cols());
343 assertEquals(100, lmskm10.cardinality());
344 assertEquals(50 * 101 * 1.0E6, lmskm10.zSum().getSI(), 1000);
345 assertEquals(AreaUnit.SQUARE_KILOMETER, lmskm10.getDisplayUnit());
346
347 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
348 assertEquals(lmskm10, lmskm10.toDense().toSparse());
349 assertEquals(lmdkm10, lmskm10.toDense());
350 assertEquals(lmskm10, lmdkm10.toSparse());
351 assertEquals(lmdkm10, lmdkm10.toSparse());
352 assertEquals(lmskm10, lmskm10.toDense());
353
354 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
355 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
356 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
357 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
358 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
359 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
360
361 FloatAreaMatrix lmdsi10 = FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(10, 10), AreaUnit.SQUARE_CENTIMETER,
362 StorageType.DENSE, FloatAreaMatrix.class);
363 assertEquals(10, lmdsi10.rows());
364 assertEquals(10, lmdsi10.cols());
365 assertEquals(100, lmdsi10.cardinality());
366 assertEquals(50 * 101, lmdsi10.zSum().getSI(), 0.001);
367 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmdsi10.getDisplayUnit());
368
369 FloatAreaMatrix lmssi10 = FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(10, 10), AreaUnit.SQUARE_CENTIMETER,
370 StorageType.SPARSE, FloatAreaMatrix.class);
371 assertEquals(10, lmssi10.rows());
372 assertEquals(10, lmssi10.cols());
373 assertEquals(100, lmssi10.cardinality());
374 assertEquals(50 * 101, lmssi10.zSum().getSI(), 0.001);
375 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmssi10.getDisplayUnit());
376
377 FloatAreaMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(10, 10, FloatArea.class),
378 AreaUnit.SQUARE_HECTOMETER, StorageType.DENSE, FloatAreaMatrix.class);
379 assertEquals(10, lmdsc10.rows());
380 assertEquals(10, lmdsc10.cols());
381 assertEquals(100, lmdsc10.cardinality());
382 assertEquals(50 * 101, lmdsc10.zSum().getSI(), 0.001);
383 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmdsc10.getDisplayUnit());
384
385 FloatAreaMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(10, 10, FloatArea.class),
386 AreaUnit.SQUARE_HECTOMETER, StorageType.SPARSE, FloatAreaMatrix.class);
387 assertEquals(10, lmssc10.rows());
388 assertEquals(10, lmssc10.cols());
389 assertEquals(100, lmssc10.cardinality());
390 assertEquals(50 * 101, lmssc10.zSum().getSI(), 0.001);
391 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmssc10.getDisplayUnit());
392 }
393
394
395
396
397 @Test
398 public void testInstantiatSquareSparseDataWithClass()
399 {
400 FloatAreaMatrix lmdkm10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), AreaUnit.SQUARE_KILOMETER,
401 StorageType.DENSE, FloatAreaMatrix.class);
402 assertEquals(10, lmdkm10.rows());
403 assertEquals(10, lmdkm10.cols());
404 assertEquals(10, lmdkm10.cardinality());
405 assertEquals(5 * 11 * 1.0E6, lmdkm10.zSum().getSI(), 0.1);
406 assertEquals(AreaUnit.SQUARE_KILOMETER, lmdkm10.getDisplayUnit());
407
408 FloatAreaMatrix lmskm10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), AreaUnit.SQUARE_KILOMETER,
409 StorageType.SPARSE, FloatAreaMatrix.class);
410 assertEquals(10, lmskm10.rows());
411 assertEquals(10, lmskm10.cols());
412 assertEquals(10, lmskm10.cardinality());
413 assertEquals(5 * 11 * 1.0E6, lmskm10.zSum().getSI(), 0.1);
414 assertEquals(AreaUnit.SQUARE_KILOMETER, lmskm10.getDisplayUnit());
415
416 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
417 assertEquals(lmskm10, lmskm10.toDense().toSparse());
418 assertEquals(lmdkm10, lmskm10.toDense());
419 assertEquals(lmskm10, lmdkm10.toSparse());
420 assertEquals(lmdkm10, lmdkm10.toSparse());
421 assertEquals(lmskm10, lmskm10.toDense());
422
423 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
424 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
425 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
426 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
427 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
428 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
429
430 FloatAreaMatrix lmdsi10 = FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(10, 10), AreaUnit.SQUARE_CENTIMETER,
431 StorageType.DENSE, FloatAreaMatrix.class);
432 assertEquals(10, lmdsi10.rows());
433 assertEquals(10, lmdsi10.cols());
434 assertEquals(10, lmdsi10.cardinality());
435 assertEquals(5 * 11, lmdsi10.zSum().getSI(), 0.001);
436 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmdsi10.getDisplayUnit());
437
438 FloatAreaMatrix lmssi10 = FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(10, 10), AreaUnit.SQUARE_CENTIMETER,
439 StorageType.SPARSE, FloatAreaMatrix.class);
440 assertEquals(10, lmssi10.rows());
441 assertEquals(10, lmssi10.cols());
442 assertEquals(10, lmssi10.cardinality());
443 assertEquals(5 * 11, lmssi10.zSum().getSI(), 0.001);
444 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmssi10.getDisplayUnit());
445
446 FloatAreaMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(10, 10, FloatArea.class),
447 AreaUnit.SQUARE_HECTOMETER, StorageType.DENSE, FloatAreaMatrix.class);
448 assertEquals(10, lmdsc10.rows());
449 assertEquals(10, lmdsc10.cols());
450 assertEquals(10, lmdsc10.cardinality());
451 assertEquals(5 * 11, lmdsc10.zSum().getSI(), 0.001);
452 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmdsc10.getDisplayUnit());
453
454 FloatAreaMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(10, 10, FloatArea.class),
455 AreaUnit.SQUARE_HECTOMETER, StorageType.SPARSE, FloatAreaMatrix.class);
456 assertEquals(10, lmssc10.rows());
457 assertEquals(10, lmssc10.cols());
458 assertEquals(10, lmssc10.cardinality());
459 assertEquals(5 * 11, lmssc10.zSum().getSI(), 0.001);
460 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmssc10.getDisplayUnit());
461
462 FloatAreaMatrix lmdtu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(10, 10, FloatArea.class), 10, 10,
463 AreaUnit.ACRE, StorageType.DENSE, FloatAreaMatrix.class);
464 assertEquals(10, lmdtu10.rows());
465 assertEquals(10, lmdtu10.cols());
466 assertEquals(10, lmdtu10.cardinality());
467 assertEquals(5 * 11, lmdtu10.zSum().getSI(), 0.001);
468 assertEquals(AreaUnit.ACRE, lmdtu10.getDisplayUnit());
469
470 FloatAreaMatrix lmstu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(10, 10, FloatArea.class), 10, 10,
471 AreaUnit.ACRE, StorageType.SPARSE, FloatAreaMatrix.class);
472 assertEquals(10, lmstu10.rows());
473 assertEquals(10, lmstu10.cols());
474 assertEquals(10, lmstu10.cardinality());
475 assertEquals(5 * 11, lmstu10.zSum().getSI(), 0.001);
476 assertEquals(AreaUnit.ACRE, lmstu10.getDisplayUnit());
477 }
478
479
480
481
482
483 @Test
484 public void testInstantiateSquareSIUnit() throws UnitException
485 {
486 FloatSIMatrix si10dd =
487 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), SIUnit.of("m2/s3"), StorageType.DENSE);
488 assertEquals(10, si10dd.rows());
489 assertEquals(10, si10dd.cols());
490 assertEquals(100, si10dd.cardinality());
491 assertEquals(50 * 101, si10dd.zSum().getSI(), 0.001);
492 assertEquals("m2/s3", si10dd.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
493
494 FloatSIMatrix si10ds =
495 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 10), SIUnit.of("m2/s3"), StorageType.SPARSE);
496 assertEquals(10, si10ds.rows());
497 assertEquals(10, si10ds.cols());
498 assertEquals(100, si10ds.cardinality());
499 assertEquals(50 * 101, si10ds.zSum().getSI(), 0.001);
500 assertEquals("m2/s3", si10ds.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
501
502 FloatSIMatrix si10sd =
503 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), SIUnit.of("m2/s3"), StorageType.DENSE);
504 assertEquals(10, si10sd.rows());
505 assertEquals(10, si10sd.cols());
506 assertEquals(10, si10sd.cardinality());
507 assertEquals(5 * 11, si10sd.zSum().getSI(), 0.001);
508 assertEquals("m2/s3", si10sd.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
509
510 FloatSIMatrix si10ss =
511 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 10), SIUnit.of("m2/s3"), StorageType.SPARSE);
512 assertEquals(10, si10ss.rows());
513 assertEquals(10, si10ss.cols());
514 assertEquals(10, si10ss.cardinality());
515 assertEquals(5 * 11, si10ss.zSum().getSI(), 0.001);
516 assertEquals("m2/s3", si10ss.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
517
518 assertEquals(si10dd, si10ds.toDense());
519 assertEquals(si10ds, si10dd.toSparse());
520 assertEquals(si10dd, si10dd.toDense());
521 assertEquals(si10ds, si10ds.toSparse());
522 assertEquals(si10dd, si10dd.toSparse().toDense());
523 assertEquals(si10ds, si10ds.toDense().toSparse());
524
525 assertEquals(si10dd.hashCode(), si10ds.toDense().hashCode());
526 assertEquals(si10ds.hashCode(), si10dd.toSparse().hashCode());
527 assertEquals(si10dd.hashCode(), si10dd.toDense().hashCode());
528 assertEquals(si10ds.hashCode(), si10ds.toSparse().hashCode());
529 assertEquals(si10dd.hashCode(), si10dd.toSparse().toDense().hashCode());
530 assertEquals(si10ds.hashCode(), si10ds.toDense().toSparse().hashCode());
531 assertEquals(si10dd.hashCode(), si10dd.toSparse().hashCode());
532 assertEquals(si10ds.hashCode(), si10ds.toDense().hashCode());
533
534 assertEquals(si10sd, si10ss.toDense());
535 assertEquals(si10ss, si10sd.toSparse());
536 assertEquals(si10sd, si10sd.toDense());
537 assertEquals(si10ss, si10ss.toSparse());
538 assertEquals(si10sd, si10sd.toSparse().toDense());
539 assertEquals(si10ss, si10ss.toDense().toSparse());
540
541 assertEquals(si10sd.hashCode(), si10ss.toDense().hashCode());
542 assertEquals(si10ss.hashCode(), si10sd.toSparse().hashCode());
543 assertEquals(si10sd.hashCode(), si10sd.toDense().hashCode());
544 assertEquals(si10ss.hashCode(), si10ss.toSparse().hashCode());
545 assertEquals(si10sd.hashCode(), si10sd.toSparse().toDense().hashCode());
546 assertEquals(si10ss.hashCode(), si10ss.toDense().toSparse().hashCode());
547 assertEquals(si10sd.hashCode(), si10sd.toSparse().hashCode());
548 assertEquals(si10ss.hashCode(), si10ss.toDense().hashCode());
549 }
550
551
552
553
554
555
556 @Test
557 public void testInstantiateRectDenseData()
558 {
559 FloatLengthMatrix lmdkm10 =
560 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), LengthUnit.KILOMETER, StorageType.DENSE);
561 assertEquals(20, lmdkm10.rows());
562 assertEquals(10, lmdkm10.cols());
563 assertEquals(200, lmdkm10.cardinality());
564 assertEquals(100 * 201 * 1000.0, lmdkm10.zSum().getSI(), 0.001);
565 assertEquals(LengthUnit.KILOMETER, lmdkm10.getDisplayUnit());
566
567 FloatLengthMatrix lmskm10 =
568 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), LengthUnit.KILOMETER, StorageType.SPARSE);
569 assertEquals(20, lmskm10.rows());
570 assertEquals(10, lmskm10.cols());
571 assertEquals(200, lmskm10.cardinality());
572 assertEquals(100 * 201 * 1000.0, lmskm10.zSum().getSI(), 0.001);
573 assertEquals(LengthUnit.KILOMETER, lmskm10.getDisplayUnit());
574
575 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
576 assertEquals(lmskm10, lmskm10.toDense().toSparse());
577 assertEquals(lmdkm10, lmskm10.toDense());
578 assertEquals(lmskm10, lmdkm10.toSparse());
579 assertEquals(lmdkm10, lmdkm10.toSparse());
580 assertEquals(lmskm10, lmskm10.toDense());
581 assertEquals(lmdkm10, lmdkm10.toDense());
582 assertEquals(lmskm10, lmskm10.toSparse());
583
584 assertTrue(lmdkm10.isDense());
585 assertTrue(lmskm10.isSparse());
586
587 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
588 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
589 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
590 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
591 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
592 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
593 assertEquals(lmdkm10.hashCode(), lmdkm10.toDense().hashCode());
594 assertEquals(lmskm10.hashCode(), lmskm10.toSparse().hashCode());
595
596 FloatLengthMatrix lmdsi10 =
597 FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(20, 10), LengthUnit.CENTIMETER, StorageType.DENSE);
598 assertEquals(20, lmdsi10.rows());
599 assertEquals(10, lmdsi10.cols());
600 assertEquals(200, lmdsi10.cardinality());
601 assertEquals(100 * 201, lmdsi10.zSum().getSI(), 0.001);
602 assertEquals(LengthUnit.CENTIMETER, lmdsi10.getDisplayUnit());
603
604 FloatLengthMatrix lmssi10 =
605 FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(20, 10), LengthUnit.CENTIMETER, StorageType.SPARSE);
606 assertEquals(20, lmssi10.rows());
607 assertEquals(10, lmssi10.cols());
608 assertEquals(200, lmssi10.cardinality());
609 assertEquals(100 * 201, lmssi10.zSum().getSI(), 0.001);
610 assertEquals(LengthUnit.CENTIMETER, lmssi10.getDisplayUnit());
611
612 FloatLengthMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(20, 10, FloatLength.class),
613 LengthUnit.HECTOMETER, StorageType.DENSE);
614 assertEquals(20, lmdsc10.rows());
615 assertEquals(10, lmdsc10.cols());
616 assertEquals(200, lmdsc10.cardinality());
617 assertEquals(100 * 201, lmdsc10.zSum().getSI(), 0.001);
618 assertEquals(LengthUnit.HECTOMETER, lmdsc10.getDisplayUnit());
619
620 FloatLengthMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(20, 10, FloatLength.class),
621 LengthUnit.HECTOMETER, StorageType.SPARSE);
622 assertEquals(20, lmssc10.rows());
623 assertEquals(10, lmssc10.cols());
624 assertEquals(200, lmssc10.cardinality());
625 assertEquals(100 * 201, lmssc10.zSum().getSI(), 0.001);
626 assertEquals(LengthUnit.HECTOMETER, lmssc10.getDisplayUnit());
627 }
628
629
630
631
632 @Test
633 public void testInstantiatRectSparseData()
634 {
635 FloatLengthMatrix lmdkm10 =
636 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), LengthUnit.KILOMETER, StorageType.DENSE);
637 assertEquals(20, lmdkm10.rows());
638 assertEquals(10, lmdkm10.cols());
639 assertEquals(10, lmdkm10.cardinality());
640 assertEquals(5 * 11 * 1000.0, lmdkm10.zSum().getSI(), 0.001);
641 assertEquals(LengthUnit.KILOMETER, lmdkm10.getDisplayUnit());
642
643 FloatLengthMatrix lmskm10 =
644 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), LengthUnit.KILOMETER, StorageType.SPARSE);
645 assertEquals(20, lmskm10.rows());
646 assertEquals(10, lmskm10.cols());
647 assertEquals(10, lmskm10.cardinality());
648 assertEquals(5 * 11 * 1000.0, lmskm10.zSum().getSI(), 0.001);
649 assertEquals(LengthUnit.KILOMETER, lmskm10.getDisplayUnit());
650
651 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
652 assertEquals(lmskm10, lmskm10.toDense().toSparse());
653 assertEquals(lmdkm10, lmskm10.toDense());
654 assertEquals(lmskm10, lmdkm10.toSparse());
655 assertEquals(lmdkm10, lmdkm10.toSparse());
656 assertEquals(lmskm10, lmskm10.toDense());
657
658 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
659 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
660 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
661 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
662 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
663 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
664 assertEquals(lmdkm10.hashCode(), lmdkm10.toDense().hashCode());
665 assertEquals(lmskm10.hashCode(), lmskm10.toSparse().hashCode());
666
667 FloatLengthMatrix lmdsi10 =
668 FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(20, 10), LengthUnit.CENTIMETER, StorageType.DENSE);
669 assertEquals(20, lmdsi10.rows());
670 assertEquals(10, lmdsi10.cols());
671 assertEquals(10, lmdsi10.cardinality());
672 assertEquals(5 * 11, lmdsi10.zSum().getSI(), 0.001);
673 assertEquals(LengthUnit.CENTIMETER, lmdsi10.getDisplayUnit());
674
675 FloatLengthMatrix lmssi10 =
676 FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(20, 10), LengthUnit.CENTIMETER, StorageType.SPARSE);
677 assertEquals(20, lmssi10.rows());
678 assertEquals(10, lmssi10.cols());
679 assertEquals(10, lmssi10.cardinality());
680 assertEquals(5 * 11, lmssi10.zSum().getSI(), 0.001);
681 assertEquals(LengthUnit.CENTIMETER, lmssi10.getDisplayUnit());
682
683 FloatLengthMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(20, 10, FloatLength.class),
684 LengthUnit.HECTOMETER, StorageType.DENSE);
685 assertEquals(20, lmdsc10.rows());
686 assertEquals(10, lmdsc10.cols());
687 assertEquals(10, lmdsc10.cardinality());
688 assertEquals(5 * 11, lmdsc10.zSum().getSI(), 0.001);
689 assertEquals(LengthUnit.HECTOMETER, lmdsc10.getDisplayUnit());
690
691 FloatLengthMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(20, 10, FloatLength.class),
692 LengthUnit.HECTOMETER, StorageType.SPARSE);
693 assertEquals(20, lmssc10.rows());
694 assertEquals(10, lmssc10.cols());
695 assertEquals(10, lmssc10.cardinality());
696 assertEquals(5 * 11, lmssc10.zSum().getSI(), 0.001);
697 assertEquals(LengthUnit.HECTOMETER, lmssc10.getDisplayUnit());
698
699 FloatLengthMatrix lmdtu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(20, 10, FloatLength.class), 20, 10,
700 LengthUnit.NANOMETER, StorageType.DENSE);
701 assertEquals(20, lmdtu10.rows());
702 assertEquals(10, lmdtu10.cols());
703 assertEquals(10, lmdtu10.cardinality());
704 assertEquals(5 * 11, lmdtu10.zSum().getSI(), 0.001);
705 assertEquals(LengthUnit.NANOMETER, lmdtu10.getDisplayUnit());
706
707 FloatLengthMatrix lmstu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(20, 10, FloatLength.class), 20, 10,
708 LengthUnit.NANOMETER, StorageType.SPARSE);
709 assertEquals(20, lmstu10.rows());
710 assertEquals(10, lmstu10.cols());
711 assertEquals(10, lmstu10.cardinality());
712 assertEquals(5 * 11, lmstu10.zSum().getSI(), 0.001);
713 assertEquals(LengthUnit.NANOMETER, lmstu10.getDisplayUnit());
714 }
715
716
717
718
719 @Test
720 public void testInstantiateRectDenseDataWithClass()
721 {
722 FloatAreaMatrix lmdkm10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), AreaUnit.SQUARE_KILOMETER,
723 StorageType.DENSE, FloatAreaMatrix.class);
724 assertEquals(20, lmdkm10.rows());
725 assertEquals(10, lmdkm10.cols());
726 assertEquals(200, lmdkm10.cardinality());
727 assertEquals(100 * 201 * 1.0E6, lmdkm10.zSum().getSI(), 1000);
728 assertEquals(AreaUnit.SQUARE_KILOMETER, lmdkm10.getDisplayUnit());
729
730 FloatAreaMatrix lmskm10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), AreaUnit.SQUARE_KILOMETER,
731 StorageType.SPARSE, FloatAreaMatrix.class);
732 assertEquals(20, lmskm10.rows());
733 assertEquals(10, lmskm10.cols());
734 assertEquals(200, lmskm10.cardinality());
735 assertEquals(100 * 201 * 1.0E6, lmskm10.zSum().getSI(), 1000);
736 assertEquals(AreaUnit.SQUARE_KILOMETER, lmskm10.getDisplayUnit());
737
738 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
739 assertEquals(lmskm10, lmskm10.toDense().toSparse());
740 assertEquals(lmdkm10, lmskm10.toDense());
741 assertEquals(lmskm10, lmdkm10.toSparse());
742 assertEquals(lmdkm10, lmdkm10.toSparse());
743 assertEquals(lmskm10, lmskm10.toDense());
744
745 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
746 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
747 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
748 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
749 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
750 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
751 assertEquals(lmdkm10.hashCode(), lmdkm10.toDense().hashCode());
752 assertEquals(lmskm10.hashCode(), lmskm10.toSparse().hashCode());
753
754 FloatAreaMatrix lmdsi10 = FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(20, 10), AreaUnit.SQUARE_CENTIMETER,
755 StorageType.DENSE, FloatAreaMatrix.class);
756 assertEquals(20, lmdsi10.rows());
757 assertEquals(10, lmdsi10.cols());
758 assertEquals(200, lmdsi10.cardinality());
759 assertEquals(100 * 201, lmdsi10.zSum().getSI(), 0.001);
760 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmdsi10.getDisplayUnit());
761
762 FloatAreaMatrix lmssi10 = FloatMatrix.instantiateSI(FLOATMATRIX.denseRectArrays(20, 10), AreaUnit.SQUARE_CENTIMETER,
763 StorageType.SPARSE, FloatAreaMatrix.class);
764 assertEquals(20, lmssi10.rows());
765 assertEquals(10, lmssi10.cols());
766 assertEquals(200, lmssi10.cardinality());
767 assertEquals(100 * 201, lmssi10.zSum().getSI(), 0.001);
768 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmssi10.getDisplayUnit());
769
770 FloatAreaMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(20, 10, FloatArea.class),
771 AreaUnit.SQUARE_HECTOMETER, StorageType.DENSE, FloatAreaMatrix.class);
772 assertEquals(20, lmdsc10.rows());
773 assertEquals(10, lmdsc10.cols());
774 assertEquals(200, lmdsc10.cardinality());
775 assertEquals(100 * 201, lmdsc10.zSum().getSI(), 0.001);
776 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmdsc10.getDisplayUnit());
777
778 FloatAreaMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.denseRectScalarArrays(20, 10, FloatArea.class),
779 AreaUnit.SQUARE_HECTOMETER, StorageType.SPARSE, FloatAreaMatrix.class);
780 assertEquals(20, lmssc10.rows());
781 assertEquals(10, lmssc10.cols());
782 assertEquals(200, lmssc10.cardinality());
783 assertEquals(100 * 201, lmssc10.zSum().getSI(), 0.001);
784 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmssc10.getDisplayUnit());
785 }
786
787
788
789
790 @Test
791 public void testInstantiatRectSparseDataWithClass()
792 {
793 FloatAreaMatrix lmdkm10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), AreaUnit.SQUARE_KILOMETER,
794 StorageType.DENSE, FloatAreaMatrix.class);
795 assertEquals(20, lmdkm10.rows());
796 assertEquals(10, lmdkm10.cols());
797 assertEquals(10, lmdkm10.cardinality());
798 assertEquals(5 * 11 * 1.0E6, lmdkm10.zSum().getSI(), 0.1);
799 assertEquals(AreaUnit.SQUARE_KILOMETER, lmdkm10.getDisplayUnit());
800
801 FloatAreaMatrix lmskm10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), AreaUnit.SQUARE_KILOMETER,
802 StorageType.SPARSE, FloatAreaMatrix.class);
803 assertEquals(20, lmskm10.rows());
804 assertEquals(10, lmskm10.cols());
805 assertEquals(10, lmskm10.cardinality());
806 assertEquals(5 * 11 * 1.0E6, lmskm10.zSum().getSI(), 0.1);
807 assertEquals(AreaUnit.SQUARE_KILOMETER, lmskm10.getDisplayUnit());
808
809 assertEquals(lmdkm10, lmdkm10.toSparse().toDense());
810 assertEquals(lmskm10, lmskm10.toDense().toSparse());
811 assertEquals(lmdkm10, lmskm10.toDense());
812 assertEquals(lmskm10, lmdkm10.toSparse());
813 assertEquals(lmdkm10, lmdkm10.toSparse());
814 assertEquals(lmskm10, lmskm10.toDense());
815
816 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().toDense().hashCode());
817 assertEquals(lmskm10.hashCode(), lmskm10.toDense().toSparse().hashCode());
818 assertEquals(lmdkm10.hashCode(), lmskm10.toDense().hashCode());
819 assertEquals(lmskm10.hashCode(), lmdkm10.toSparse().hashCode());
820 assertEquals(lmdkm10.hashCode(), lmdkm10.toSparse().hashCode());
821 assertEquals(lmskm10.hashCode(), lmskm10.toDense().hashCode());
822 assertEquals(lmdkm10.hashCode(), lmdkm10.toDense().hashCode());
823 assertEquals(lmskm10.hashCode(), lmskm10.toSparse().hashCode());
824
825 FloatAreaMatrix lmdsi10 = FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(20, 10), AreaUnit.SQUARE_CENTIMETER,
826 StorageType.DENSE, FloatAreaMatrix.class);
827 assertEquals(20, lmdsi10.rows());
828 assertEquals(10, lmdsi10.cols());
829 assertEquals(10, lmdsi10.cardinality());
830 assertEquals(5 * 11, lmdsi10.zSum().getSI(), 0.001);
831 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmdsi10.getDisplayUnit());
832
833 FloatAreaMatrix lmssi10 = FloatMatrix.instantiateSI(FLOATMATRIX.sparseRectArrays(20, 10), AreaUnit.SQUARE_CENTIMETER,
834 StorageType.SPARSE, FloatAreaMatrix.class);
835 assertEquals(20, lmssi10.rows());
836 assertEquals(10, lmssi10.cols());
837 assertEquals(10, lmssi10.cardinality());
838 assertEquals(5 * 11, lmssi10.zSum().getSI(), 0.001);
839 assertEquals(AreaUnit.SQUARE_CENTIMETER, lmssi10.getDisplayUnit());
840
841 FloatAreaMatrix lmdsc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(20, 10, FloatArea.class),
842 AreaUnit.SQUARE_HECTOMETER, StorageType.DENSE, FloatAreaMatrix.class);
843 assertEquals(20, lmdsc10.rows());
844 assertEquals(10, lmdsc10.cols());
845 assertEquals(10, lmdsc10.cardinality());
846 assertEquals(5 * 11, lmdsc10.zSum().getSI(), 0.001);
847 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmdsc10.getDisplayUnit());
848
849 FloatAreaMatrix lmssc10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectScalarArrays(20, 10, FloatArea.class),
850 AreaUnit.SQUARE_HECTOMETER, StorageType.SPARSE, FloatAreaMatrix.class);
851 assertEquals(20, lmssc10.rows());
852 assertEquals(10, lmssc10.cols());
853 assertEquals(10, lmssc10.cardinality());
854 assertEquals(5 * 11, lmssc10.zSum().getSI(), 0.001);
855 assertEquals(AreaUnit.SQUARE_HECTOMETER, lmssc10.getDisplayUnit());
856
857 FloatAreaMatrix lmdtu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(20, 10, FloatArea.class), 20, 10,
858 AreaUnit.ACRE, StorageType.DENSE, FloatAreaMatrix.class);
859 assertEquals(20, lmdtu10.rows());
860 assertEquals(10, lmdtu10.cols());
861 assertEquals(10, lmdtu10.cardinality());
862 assertEquals(5 * 11, lmdtu10.zSum().getSI(), 0.001);
863 assertEquals(AreaUnit.ACRE, lmdtu10.getDisplayUnit());
864
865 FloatAreaMatrix lmstu10 = FloatMatrix.instantiate(FLOATMATRIX.sparseRectTuples(20, 10, FloatArea.class), 20, 10,
866 AreaUnit.ACRE, StorageType.SPARSE, FloatAreaMatrix.class);
867 assertEquals(20, lmstu10.rows());
868 assertEquals(10, lmstu10.cols());
869 assertEquals(10, lmstu10.cardinality());
870 assertEquals(5 * 11, lmstu10.zSum().getSI(), 0.001);
871 assertEquals(AreaUnit.ACRE, lmstu10.getDisplayUnit());
872
873 assertNotEquals(lmdkm10, lmdsi10);
874 assertNotEquals(lmdkm10, lmssi10);
875 assertNotEquals(lmskm10, lmdsi10);
876 assertNotEquals(lmskm10, lmssi10);
877 assertNotEquals(lmdkm10, lmdtu10);
878 assertNotEquals(lmdkm10, lmstu10);
879 assertNotEquals(lmskm10, lmdtu10);
880 assertNotEquals(lmskm10, lmstu10);
881
882 assertNotEquals(lmdkm10.hashCode(), lmdsi10.hashCode());
883 assertNotEquals(lmdkm10.hashCode(), lmssi10.hashCode());
884 assertNotEquals(lmskm10.hashCode(), lmdsi10.hashCode());
885 assertNotEquals(lmskm10.hashCode(), lmssi10.hashCode());
886 assertNotEquals(lmdkm10.hashCode(), lmdtu10.hashCode());
887 assertNotEquals(lmdkm10.hashCode(), lmstu10.hashCode());
888 assertNotEquals(lmskm10.hashCode(), lmdtu10.hashCode());
889 assertNotEquals(lmskm10.hashCode(), lmstu10.hashCode());
890 }
891
892
893
894
895
896 @Test
897 public void testInstantiateRectSIUnit() throws UnitException
898 {
899 FloatSIMatrix si10dd =
900 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), SIUnit.of("m2/s3"), StorageType.DENSE);
901 assertEquals(20, si10dd.rows());
902 assertEquals(10, si10dd.cols());
903 assertEquals(200, si10dd.cardinality());
904 assertEquals(100 * 201, si10dd.zSum().getSI(), 0.001);
905 assertEquals("m2/s3", si10dd.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
906 assertEquals("getScalarClass returns FloatSIScalar", FloatSIScalar.class, si10dd.getScalarClass());
907 assertEquals("getVectorClass returns FloatSIVector", FloatSIVector.class, si10dd.getVectorClass());
908
909 FloatSIMatrix si10ds =
910 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(20, 10), SIUnit.of("m2/s3"), StorageType.SPARSE);
911 assertEquals(20, si10ds.rows());
912 assertEquals(10, si10ds.cols());
913 assertEquals(200, si10ds.cardinality());
914 assertEquals(100 * 201, si10ds.zSum().getSI(), 0.001);
915 assertEquals("m2/s3", si10ds.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
916
917 FloatSIMatrix si10sd =
918 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), SIUnit.of("m2/s3"), StorageType.DENSE);
919 assertEquals(20, si10sd.rows());
920 assertEquals(10, si10sd.cols());
921 assertEquals(10, si10sd.cardinality());
922 assertEquals(5 * 11, si10sd.zSum().getSI(), 0.001);
923 assertEquals("m2/s3", si10sd.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
924
925 FloatSIMatrix si10ss =
926 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(20, 10), SIUnit.of("m2/s3"), StorageType.SPARSE);
927 assertEquals(20, si10ss.rows());
928 assertEquals(10, si10ss.cols());
929 assertEquals(10, si10ss.cardinality());
930 assertEquals(5 * 11, si10ss.zSum().getSI(), 0.001);
931 assertEquals("m2/s3", si10ss.getDisplayUnit().getQuantity().getSiDimensions().toString(true, false, false));
932
933 assertEquals(si10dd, si10ds.toDense());
934 assertEquals(si10ds, si10dd.toSparse());
935 assertEquals(si10dd, si10dd.toDense());
936 assertEquals(si10ds, si10ds.toSparse());
937 assertEquals(si10dd, si10dd.toSparse().toDense());
938 assertEquals(si10ds, si10ds.toDense().toSparse());
939
940 assertEquals(si10sd, si10ss.toDense());
941 assertEquals(si10ss, si10sd.toSparse());
942 assertEquals(si10sd, si10sd.toDense());
943 assertEquals(si10ss, si10ss.toSparse());
944 assertEquals(si10sd, si10sd.toSparse().toDense());
945 assertEquals(si10ss, si10ss.toDense().toSparse());
946
947 assertEquals(si10dd.hashCode(), si10ds.toDense().hashCode());
948 assertEquals(si10ds.hashCode(), si10dd.toSparse().hashCode());
949 assertEquals(si10dd.hashCode(), si10dd.toDense().hashCode());
950 assertEquals(si10ds.hashCode(), si10ds.toSparse().hashCode());
951 assertEquals(si10dd.hashCode(), si10dd.toSparse().toDense().hashCode());
952 assertEquals(si10ds.hashCode(), si10ds.toDense().toSparse().hashCode());
953 assertEquals(si10dd.hashCode(), si10dd.toSparse().hashCode());
954 assertEquals(si10ds.hashCode(), si10ds.toDense().hashCode());
955
956 assertEquals(si10sd.hashCode(), si10ss.toDense().hashCode());
957 assertEquals(si10ss.hashCode(), si10sd.toSparse().hashCode());
958 assertEquals(si10sd.hashCode(), si10sd.toDense().hashCode());
959 assertEquals(si10ss.hashCode(), si10ss.toSparse().hashCode());
960 assertEquals(si10sd.hashCode(), si10sd.toSparse().hashCode());
961 assertEquals(si10ss.hashCode(), si10ss.toDense().hashCode());
962 }
963
964
965
966
967
968
969
970 @Test
971 @SuppressWarnings({"checkstyle:methodlength", "checkstyle:localvariablename"})
972 public void testInstantiateEdgeCases()
973 {
974
975
976 FloatSpeedMatrix row1dd =
977 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 10), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
978 assertEquals(1, row1dd.rows());
979 assertEquals(10, row1dd.cols());
980 assertEquals(10, row1dd.cardinality());
981 assertEquals(5 * 11, row1dd.zSum().getSI(), 0.001);
982 assertEquals(SpeedUnit.METER_PER_SECOND, row1dd.getDisplayUnit());
983
984 FloatSpeedMatrix col1dd =
985 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
986 assertEquals(10, col1dd.rows());
987 assertEquals(1, col1dd.cols());
988 assertEquals(10, col1dd.cardinality());
989 assertEquals(5 * 11, col1dd.zSum().getSI(), 0.001);
990 assertEquals(SpeedUnit.METER_PER_SECOND, col1dd.getDisplayUnit());
991
992 FloatSpeedMatrix row1ds =
993 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 10), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
994 assertEquals(1, row1ds.rows());
995 assertEquals(10, row1ds.cols());
996 assertEquals(10, row1ds.cardinality());
997 assertEquals(5 * 11, row1ds.zSum().getSI(), 0.001);
998 assertEquals(SpeedUnit.METER_PER_SECOND, row1ds.getDisplayUnit());
999
1000 FloatSpeedMatrix col1ds =
1001 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(10, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1002 assertEquals(10, col1ds.rows());
1003 assertEquals(1, col1ds.cols());
1004 assertEquals(10, col1ds.cardinality());
1005 assertEquals(5 * 11, col1ds.zSum().getSI(), 0.001);
1006 assertEquals(SpeedUnit.METER_PER_SECOND, col1ds.getDisplayUnit());
1007
1008
1009
1010 FloatSpeedMatrix row1sd =
1011 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 10), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1012 assertEquals(1, row1sd.rows());
1013 assertEquals(10, row1sd.cols());
1014 assertEquals(1, row1sd.cardinality());
1015 assertEquals(1, row1sd.zSum().getSI(), 0.001);
1016 assertEquals(SpeedUnit.METER_PER_SECOND, row1sd.getDisplayUnit());
1017
1018 FloatSpeedMatrix col1sd =
1019 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1020 assertEquals(10, col1sd.rows());
1021 assertEquals(1, col1sd.cols());
1022 assertEquals(1, col1sd.cardinality());
1023 assertEquals(1, col1sd.zSum().getSI(), 0.001);
1024 assertEquals(SpeedUnit.METER_PER_SECOND, col1sd.getDisplayUnit());
1025
1026 FloatSpeedMatrix row1ss =
1027 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 10), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1028 assertEquals(1, row1ss.rows());
1029 assertEquals(10, row1ss.cols());
1030 assertEquals(1, row1ss.cardinality());
1031 assertEquals(1, row1ss.zSum().getSI(), 0.001);
1032 assertEquals(SpeedUnit.METER_PER_SECOND, row1ss.getDisplayUnit());
1033
1034 FloatSpeedMatrix col1ss =
1035 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(10, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1036 assertEquals(10, col1ss.rows());
1037 assertEquals(1, col1ss.cols());
1038 assertEquals(1, col1ss.cardinality());
1039 assertEquals(1, col1ss.zSum().getSI(), 0.001);
1040 assertEquals(SpeedUnit.METER_PER_SECOND, col1ss.getDisplayUnit());
1041
1042
1043
1044 assertEquals(row1dd, row1dd);
1045 assertEquals(row1ss, row1ss);
1046 assertEquals(row1dd, row1ds);
1047 assertEquals(col1dd, col1ds);
1048 assertEquals(row1sd, row1ss);
1049 assertEquals(col1sd, col1ss);
1050 assertEquals(row1ds, row1dd);
1051 assertEquals(col1ds, col1dd);
1052 assertEquals(row1ss, row1sd);
1053 assertEquals(col1ss, col1sd);
1054 assertNotEquals(row1dd, col1dd);
1055 assertNotEquals(col1dd, row1dd);
1056 assertNotEquals(row1ss, col1ss);
1057 assertNotEquals(col1ss, row1ss);
1058 assertNotEquals(row1ds, col1sd);
1059 assertNotEquals(col1ds, row1sd);
1060 assertNotEquals(row1sd, col1ds);
1061 assertNotEquals(col1sd, row1ds);
1062
1063 assertEquals(row1dd.hashCode(), row1dd.hashCode());
1064 assertEquals(row1ss.hashCode(), row1ss.hashCode());
1065 assertEquals(row1dd.hashCode(), row1ds.hashCode());
1066 assertEquals(col1dd.hashCode(), col1ds.hashCode());
1067 assertEquals(row1sd.hashCode(), row1ss.hashCode());
1068 assertEquals(col1sd.hashCode(), col1ss.hashCode());
1069 assertEquals(row1ds.hashCode(), row1dd.hashCode());
1070 assertEquals(col1ds.hashCode(), col1dd.hashCode());
1071 assertEquals(row1ss.hashCode(), row1sd.hashCode());
1072 assertEquals(col1ss.hashCode(), col1sd.hashCode());
1073 assertNotEquals(row1dd.hashCode(), col1dd.hashCode());
1074 assertNotEquals(col1dd.hashCode(), row1dd.hashCode());
1075 assertNotEquals(row1ss.hashCode(), col1ss.hashCode());
1076 assertNotEquals(col1ss.hashCode(), row1ss.hashCode());
1077 assertNotEquals(row1ds.hashCode(), col1sd.hashCode());
1078 assertNotEquals(col1ds.hashCode(), row1sd.hashCode());
1079 assertNotEquals(row1sd.hashCode(), col1ds.hashCode());
1080 assertNotEquals(col1sd.hashCode(), row1ds.hashCode());
1081
1082
1083
1084 FloatSpeedMatrix row11dd =
1085 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1086 assertEquals(1, row11dd.rows());
1087 assertEquals(1, row11dd.cols());
1088 assertEquals(1, row11dd.cardinality());
1089 assertEquals(1, row11dd.zSum().getSI(), 0.001);
1090 assertEquals(SpeedUnit.METER_PER_SECOND, row11dd.getDisplayUnit());
1091
1092 FloatSpeedMatrix col11dd =
1093 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1094 assertEquals(1, col11dd.rows());
1095 assertEquals(1, col11dd.cols());
1096 assertEquals(1, col11dd.cardinality());
1097 assertEquals(1, col11dd.zSum().getSI(), 0.001);
1098 assertEquals(SpeedUnit.METER_PER_SECOND, col11dd.getDisplayUnit());
1099
1100 FloatSpeedMatrix row11ds =
1101 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1102 assertEquals(1, row11ds.rows());
1103 assertEquals(1, row11ds.cols());
1104 assertEquals(1, row11ds.cardinality());
1105 assertEquals(1, row11ds.zSum().getSI(), 0.001);
1106 assertEquals(SpeedUnit.METER_PER_SECOND, row11ds.getDisplayUnit());
1107
1108 FloatSpeedMatrix col11ds =
1109 FloatMatrix.instantiate(FLOATMATRIX.denseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1110 assertEquals(1, col11ds.rows());
1111 assertEquals(1, col11ds.cols());
1112 assertEquals(1, col11ds.cardinality());
1113 assertEquals(1, col11ds.zSum().getSI(), 0.001);
1114 assertEquals(SpeedUnit.METER_PER_SECOND, col11ds.getDisplayUnit());
1115
1116
1117
1118 FloatSpeedMatrix row11sd =
1119 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1120 assertEquals(1, row11sd.rows());
1121 assertEquals(1, row11sd.cols());
1122 assertEquals(1, row11sd.cardinality());
1123 assertEquals(1, row11sd.zSum().getSI(), 0.001);
1124 assertEquals(SpeedUnit.METER_PER_SECOND, row11sd.getDisplayUnit());
1125
1126 FloatSpeedMatrix col11sd =
1127 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1128 assertEquals(1, col11sd.rows());
1129 assertEquals(1, col11sd.cols());
1130 assertEquals(1, col11sd.cardinality());
1131 assertEquals(1, col11sd.zSum().getSI(), 0.001);
1132 assertEquals(SpeedUnit.METER_PER_SECOND, col11sd.getDisplayUnit());
1133
1134 FloatSpeedMatrix row11ss =
1135 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1136 assertEquals(1, row11ss.rows());
1137 assertEquals(1, row11ss.cols());
1138 assertEquals(1, row11ss.cardinality());
1139 assertEquals(1, row11ss.zSum().getSI(), 0.001);
1140 assertEquals(SpeedUnit.METER_PER_SECOND, row11ss.getDisplayUnit());
1141
1142 FloatSpeedMatrix col11ss =
1143 FloatMatrix.instantiate(FLOATMATRIX.sparseRectArrays(1, 1), SpeedUnit.METER_PER_SECOND, StorageType.SPARSE);
1144 assertEquals(1, col11ss.rows());
1145 assertEquals(1, col11ss.cols());
1146 assertEquals(1, col11ss.cardinality());
1147 assertEquals(1, col11ss.zSum().getSI(), 0.001);
1148 assertEquals(SpeedUnit.METER_PER_SECOND, col11ss.getDisplayUnit());
1149
1150
1151
1152 float[][] d0_1 = new float[0][1];
1153 float[][] d1_0 = new float[1][];
1154 d1_0[0] = new float[0];
1155 float[][] d0_0 = new float[0][0];
1156 float[][] d1_1 = new float[1][];
1157 d1_1[0] = new float[1];
1158
1159 new Try()
1160 {
1161 @Override
1162 public void execute()
1163 {
1164 FloatMatrix.instantiate(d0_1, SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1165 }
1166 }.test("constructing matrix with zero rows should have thrown an exception", ValueRuntimeException.class);
1167
1168 new Try()
1169 {
1170 @Override
1171 public void execute()
1172 {
1173 FloatMatrix.instantiate(d1_0, SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1174 }
1175 }.test("constructing matrix with zero columns should have thrown an exception", ValueRuntimeException.class);
1176
1177 new Try()
1178 {
1179 @Override
1180 public void execute()
1181 {
1182 FloatMatrix.instantiate(d0_0, SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1183 }
1184 }.test("constructing matrix with zero rows and cols should have thrown an exception", ValueRuntimeException.class);
1185
1186 new Try()
1187 {
1188 @Override
1189 public void execute()
1190 {
1191 FloatMatrix.instantiate((float[][]) null, SpeedUnit.METER_PER_SECOND, StorageType.DENSE);
1192 }
1193 }.test("constructing matrix with null input should have thrown an exception", NullPointerException.class);
1194
1195 new Try()
1196 {
1197 @Override
1198 public void execute()
1199 {
1200 FloatMatrix.instantiate(d1_1, null, StorageType.DENSE);
1201 }
1202 }.test("constructing matrix with null unit should have thrown an exception", NullPointerException.class);
1203
1204 new Try()
1205 {
1206 @Override
1207 public void execute()
1208 {
1209 FloatMatrix.instantiate(d1_1, SpeedUnit.METER_PER_SECOND, null);
1210 }
1211 }.test("constructing matrix with null storage type should have thrown an exception", NullPointerException.class);
1212 }
1213 }