View Javadoc
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   * FloatMatrixInstantiateTest.java.
43   * <p>
44   * Copyright (c) 2019-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
45   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
46   * <p>
47   * @author <a href="https://www.tudelft.nl/averbraeck" target="_blank">Alexander Verbraeck</a>
48   */
49  public class FloatMatrixInstantiateTest
50  {
51      /**
52       * Test the constructors of all matrix classes.
53       * @param <U> the unit type
54       * @param <S> the scalar type
55       * @param <V> the vector type
56       * @param <M> the matrix type
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          // Force loading of all classes
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                  // TODO next cast should be unnecessary
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      * Test the extra methods that Absolute and Relative with Absolute matrices implement.
102      * @param <AU> the absolute unit type
103      * @param <RU> the relative unit type
104      */
105     @SuppressWarnings("unchecked")
106     @Test
107     public <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>> void instantiateRelAbsMatrixTypes()
108     {
109         // Force loading of all classes
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      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
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()); // dense and sparse are the same if content is the same
191         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with sparse data (90% zeros).
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()); // dense and sparse are the same if content is the same
267         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
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()); // dense and sparse are the same if content is the same
352         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with sparse data (90% zeros).
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()); // dense and sparse are the same if content is the same
421         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
481      * @throws UnitException on error
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     // =============================================== RECTANGULAR MATRICES ===================================================
552 
553     /**
554      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
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()); // dense and sparse are the same if content is the same
580         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with sparse data (90% zeros).
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()); // dense and sparse are the same if content is the same
656         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
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()); // dense and sparse are the same if content is the same
743         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with sparse data (90% zeros).
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()); // dense and sparse are the same if content is the same
814         assertEquals(lmskm10, lmskm10.toDense()); // dense and sparse are the same if content is the same
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      * Test the instantiation of dense and sparse matrix types with dense data (no zeros).
894      * @throws UnitException on error
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     // =============================================== EDGE CASE MATRICES ===================================================
965 
966     /**
967      * Test the instantiation of dense and sparse matrix types with one row or one column, and errors with null pointers and/or
968      * zero rows/columns.
969      */
970     @Test
971     @SuppressWarnings({"checkstyle:methodlength", "checkstyle:localvariablename"})
972     public void testInstantiateEdgeCases()
973     {
974         // DENSE DATA
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         // SPARSE DATA
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         // equals
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         // 1 x 1 DENSE DATA
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         // 1 x 1 SPARSE DATA
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         // NULL / ZERO ROWS / ZERO COLS
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 }