View Javadoc
1   package org.djunits.value.vfloat.matrix;
2   
3   import java.util.Collection;
4   
5   import org.djunits.unit.EquivalentDoseUnit;
6   import org.djunits.value.storage.StorageType;
7   import org.djunits.value.vfloat.matrix.base.FloatMatrixRel;
8   import org.djunits.value.vfloat.matrix.base.FloatSparseValue;
9   import org.djunits.value.vfloat.matrix.data.FloatMatrixData;
10  import org.djunits.value.vfloat.scalar.FloatEquivalentDose;
11  import org.djunits.value.vfloat.vector.FloatEquivalentDoseVector;
12  import org.djunits.value.vfloat.vector.data.FloatVectorData;
13  
14  import jakarta.annotation.Generated;
15  
16  /**
17   * Immutable FloatFloatEquivalentDoseMatrix, a matrix of values with a EquivalentDoseUnit.
18   * <p>
19   * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
20   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
21   * </p>
22   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
23   * @author <a href="https://www.tudelft.nl/staff/p.knoppers/">Peter Knoppers</a>
24   */
25  @Generated(value = "org.djunits.generator.GenerateDJUNIT", date = "2023-07-23T14:06:38.224104100Z")
26  public class FloatEquivalentDoseMatrix
27          extends FloatMatrixRel<EquivalentDoseUnit, FloatEquivalentDose, FloatEquivalentDoseVector, FloatEquivalentDoseMatrix>
28  
29  {
30      /** */
31      private static final long serialVersionUID = 20151109L;
32  
33      /**
34       * Construct a FloatEquivalentDoseMatrix from an internal data object.
35       * @param data FloatMatrixData; the internal data object for the matrix
36       * @param displayUnit EquivalentDoseUnit; the display unit of the matrix data
37       */
38      public FloatEquivalentDoseMatrix(final FloatMatrixData data, final EquivalentDoseUnit displayUnit)
39      {
40          super(data, displayUnit);
41      }
42  
43      /* CONSTRUCTORS WITH float[][] */
44  
45      /**
46       * Construct a FloatEquivalentDoseMatrix from a float[][] object. The float values are expressed in the displayUnit, and
47       * will be printed using the displayUnit.
48       * @param data float[][]; the data for the matrix, expressed in the displayUnit
49       * @param displayUnit EquivalentDoseUnit; the unit of the values in the data array, and display unit when printing
50       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
51       */
52      public FloatEquivalentDoseMatrix(final float[][] data, final EquivalentDoseUnit displayUnit, final StorageType storageType)
53      {
54          this(FloatMatrixData.instantiate(data, displayUnit.getScale(), storageType), displayUnit);
55      }
56  
57      /**
58       * Construct a FloatEquivalentDoseMatrix from a float[][] object. The float values are expressed in the displayUnit. Assume
59       * that the StorageType is DENSE since we offer the data as an array of an array.
60       * @param data float[][]; the data for the matrix
61       * @param displayUnit EquivalentDoseUnit; the unit of the values in the data array, and display unit when printing
62       */
63      public FloatEquivalentDoseMatrix(final float[][] data, final EquivalentDoseUnit displayUnit)
64      {
65          this(data, displayUnit, StorageType.DENSE);
66      }
67  
68      /**
69       * Construct a FloatEquivalentDoseMatrix from a float[][] object with SI-unit values.
70       * @param data float[][]; the data for the matrix, in SI units
71       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
72       */
73      public FloatEquivalentDoseMatrix(final float[][] data, final StorageType storageType)
74      {
75          this(data, EquivalentDoseUnit.SI, storageType);
76      }
77  
78      /**
79       * Construct a FloatEquivalentDoseMatrix from a float[][] object with SI-unit values. Assume that the StorageType is DENSE
80       * since we offer the data as an array of an array.
81       * @param data float[][]; the data for the matrix, in SI units
82       */
83      public FloatEquivalentDoseMatrix(final float[][] data)
84      {
85          this(data, StorageType.DENSE);
86      }
87  
88      /* CONSTRUCTORS WITH EquivalentDose[][] */
89  
90      /**
91       * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose
92       * values are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit
93       * when printing.
94       * @param data FloatEquivalentDose[][]; the data for the matrix
95       * @param displayUnit EquivalentDoseUnit; the display unit of the values when printing
96       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
97       */
98      public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final EquivalentDoseUnit displayUnit,
99              final StorageType storageType)
100     {
101         this(FloatMatrixData.instantiate(data, storageType), displayUnit);
102     }
103 
104     /**
105      * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose
106      * values are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit
107      * when printing. Assume that the StorageType is DENSE since we offer the data as an array of an array.
108      * @param data FloatEquivalentDose[][]; the data for the matrix
109      * @param displayUnit EquivalentDoseUnit; the display unit of the values when printing
110      */
111     public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final EquivalentDoseUnit displayUnit)
112     {
113         this(data, displayUnit, StorageType.DENSE);
114     }
115 
116     /**
117      * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose
118      * values are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units
119      * when printing. since we offer the data as an array of an array.
120      * @param data FloatEquivalentDose[][]; the data for the matrix
121      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
122      */
123     public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final StorageType storageType)
124     {
125         this(data, EquivalentDoseUnit.SI, storageType);
126     }
127 
128     /**
129      * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose
130      * values are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units
131      * when printing. Assume that the StorageType is DENSE since we offer the data as an array of an array.
132      * @param data FloatEquivalentDose[][]; the data for the matrix
133      */
134     public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data)
135     {
136         this(data, StorageType.DENSE);
137     }
138 
139     /* CONSTRUCTORS WITH Collection<FloatSparseValue> */
140 
141     /**
142      * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates
143      * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed.
144      * @param data Collection&lt;FloatSparseValue&gt;; the data for the matrix
145      * @param displayUnit EquivalentDoseUnit; the display unit of the matrix data, and the unit of the data points
146      * @param rows int; the number of rows of the matrix
147      * @param cols int; the number of columns of the matrix
148      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
149      */
150     public FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data,
151             final EquivalentDoseUnit displayUnit, final int rows, final int cols, final StorageType storageType)
152     {
153         this(FloatMatrixData.instantiate(data, rows, cols, storageType), displayUnit);
154     }
155 
156     /**
157      * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates
158      * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Assume
159      * the storage type is SPARSE, since we offer the data as a collection.
160      * @param data Collection&lt;FloatSparseValue&gt;; the data for the matrix
161      * @param displayUnit EquivalentDoseUnit; the display unit of the matrix data, and the unit of the data points
162      * @param rows int; the number of rows of the matrix
163      * @param cols int; the number of columns of the matrix
164      */
165     public FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data,
166             final EquivalentDoseUnit displayUnit, final int rows, final int cols)
167     {
168         this(data, displayUnit, rows, cols, StorageType.SPARSE);
169     }
170 
171     /**
172      * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates
173      * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the
174      * SI unit or base unit as the displayUnit.
175      * @param data Collection&lt;FloatSparseValue&gt;; the data for the matrix
176      * @param rows int; the number of rows of the matrix
177      * @param cols int; the number of columns of the matrix
178      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
179      */
180     public FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data,
181             final int rows, final int cols, final StorageType storageType)
182     {
183         this(data, EquivalentDoseUnit.SI, rows, cols, storageType);
184     }
185 
186     /**
187      * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates
188      * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the
189      * SI unit or base unit as the displayUnit. Assume the storage type is SPARSE, since we offer the data as a collection.
190      * @param data Collection&lt;FloatSparseValue&gt;; the data for the matrix
191      * @param rows int; the number of rows of the matrix
192      * @param cols int; the number of columns of the matrix
193      */
194     public FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data,
195             final int rows, final int cols)
196     {
197         this(data, EquivalentDoseUnit.SI, rows, cols, StorageType.SPARSE);
198     }
199 
200     @Override
201     public Class<FloatEquivalentDose> getScalarClass()
202     {
203         return FloatEquivalentDose.class;
204     }
205 
206     @Override
207     public Class<FloatEquivalentDoseVector> getVectorClass()
208     {
209         return FloatEquivalentDoseVector.class;
210     }
211 
212     @Override
213     public FloatEquivalentDoseMatrix instantiateMatrix(final FloatMatrixData fmd, final EquivalentDoseUnit displayUnit)
214     {
215         return new FloatEquivalentDoseMatrix(fmd, displayUnit);
216     }
217 
218     @Override
219     public FloatEquivalentDoseVector instantiateVector(final FloatVectorData fvd, final EquivalentDoseUnit displayUnit)
220     {
221         return new FloatEquivalentDoseVector(fvd, displayUnit);
222     }
223 
224     @Override
225     public FloatEquivalentDose instantiateScalarSI(final float valueSI, final EquivalentDoseUnit displayUnit)
226     {
227         FloatEquivalentDose result = FloatEquivalentDose.instantiateSI(valueSI);
228         result.setDisplayUnit(displayUnit);
229         return result;
230     }
231 
232 }