View Javadoc
1   package org.djunits.value.vfloat.vector;
2   
3   import java.util.List;
4   import java.util.Map;
5   
6   import org.djunits.unit.CatalyticActivityUnit;
7   import org.djunits.unit.scale.IdentityScale;
8   import org.djunits.value.storage.StorageType;
9   import org.djunits.value.vfloat.scalar.FloatCatalyticActivity;
10  import org.djunits.value.vfloat.vector.base.FloatVectorRel;
11  import org.djunits.value.vfloat.vector.data.FloatVectorData;
12  
13  import jakarta.annotation.Generated;
14  
15  /**
16   * Immutable Float FloatCatalyticActivityVector, a vector of values with a CatalyticActivityUnit.
17   * <p>
18   * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
19   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
20   * </p>
21   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
22   * @author <a href="https://www.tudelft.nl/staff/p.knoppers/">Peter Knoppers</a>
23   */
24  @Generated(value = "org.djunits.generator.GenerateDJUNIT", date = "2023-07-23T14:06:38.224104100Z")
25  public class FloatCatalyticActivityVector
26          extends FloatVectorRel<CatalyticActivityUnit, FloatCatalyticActivity, FloatCatalyticActivityVector>
27  
28  {
29      /** */
30      private static final long serialVersionUID = 20190905L;
31  
32      /**
33       * Construct a FloatCatalyticActivityVector from an internal data object.
34       * @param data FloatVectorData; the internal data object for the vector
35       * @param displayUnit CatalyticActivityUnit; the display unit of the vector data
36       */
37      public FloatCatalyticActivityVector(final FloatVectorData data, final CatalyticActivityUnit displayUnit)
38      {
39          super(data, displayUnit);
40      }
41  
42      /* CONSTRUCTORS WITH float[] */
43  
44      /**
45       * Construct a FloatCatalyticActivityVector from a float[] object. The Float values are expressed in the displayUnit, and
46       * will be printed using the displayUnit.
47       * @param data float[]; the data for the vector, expressed in the displayUnit
48       * @param displayUnit CatalyticActivityUnit; the unit of the values in the data array, and display unit when printing
49       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
50       */
51      public FloatCatalyticActivityVector(final float[] data, final CatalyticActivityUnit displayUnit,
52              final StorageType storageType)
53      {
54          this(FloatVectorData.instantiate(data, displayUnit.getScale(), storageType), displayUnit);
55      }
56  
57      /**
58       * Construct a FloatCatalyticActivityVector 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.
60       * @param data float[]; the data for the vector
61       * @param displayUnit CatalyticActivityUnit; the unit of the values in the data array, and display unit when printing
62       */
63      public FloatCatalyticActivityVector(final float[] data, final CatalyticActivityUnit displayUnit)
64      {
65          this(data, displayUnit, StorageType.DENSE);
66      }
67  
68      /**
69       * Construct a FloatCatalyticActivityVector from a float[] object with SI-unit values.
70       * @param data float[]; the data for the vector, in SI units
71       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
72       */
73      public FloatCatalyticActivityVector(final float[] data, final StorageType storageType)
74      {
75          this(data, CatalyticActivityUnit.SI, storageType);
76      }
77  
78      /**
79       * Construct a FloatCatalyticActivityVector from a float[] object with SI-unit values. Assume that the StorageType is DENSE
80       * since we offer the data as an array.
81       * @param data float[]; the data for the vector, in SI units
82       */
83      public FloatCatalyticActivityVector(final float[] data)
84      {
85          this(data, StorageType.DENSE);
86      }
87  
88      /* CONSTRUCTORS WITH FloatCatalyticActivity[] */
89  
90      /**
91       * Construct a FloatCatalyticActivityVector from an array of FloatCatalyticActivity objects. The FloatCatalyticActivity
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 FloatCatalyticActivity[]; the data for the vector
95       * @param displayUnit CatalyticActivityUnit; the display unit of the values when printing
96       * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
97       */
98      public FloatCatalyticActivityVector(final FloatCatalyticActivity[] data, final CatalyticActivityUnit displayUnit,
99              final StorageType storageType)
100     {
101         this(FloatVectorData.instantiate(data, storageType), displayUnit);
102     }
103 
104     /**
105      * Construct a FloatCatalyticActivityVector from an array of FloatCatalyticActivity objects. The FloatCatalyticActivity
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.
108      * @param data FloatCatalyticActivity[]; the data for the vector
109      * @param displayUnit CatalyticActivityUnit; the display unit of the values when printing
110      */
111     public FloatCatalyticActivityVector(final FloatCatalyticActivity[] data, final CatalyticActivityUnit displayUnit)
112     {
113         this(data, displayUnit, StorageType.DENSE);
114     }
115 
116     /**
117      * Construct a FloatCatalyticActivityVector from an array of FloatCatalyticActivity objects. The FloatCatalyticActivity
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.
120      * @param data FloatCatalyticActivity[]; the data for the vector
121      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
122      */
123     public FloatCatalyticActivityVector(final FloatCatalyticActivity[] data, final StorageType storageType)
124     {
125         this(data, CatalyticActivityUnit.SI, storageType);
126     }
127 
128     /**
129      * Construct a FloatCatalyticActivityVector from an array of FloatCatalyticActivity objects. The FloatCatalyticActivity
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.
132      * @param data FloatCatalyticActivity[]; the data for the vector
133      */
134     public FloatCatalyticActivityVector(final FloatCatalyticActivity[] data)
135     {
136         this(data, StorageType.DENSE);
137     }
138 
139     /* CONSTRUCTORS WITH List<Float> or List<CatalyticActivity> */
140 
141     /**
142      * Construct a FloatCatalyticActivityVector from a list of Number objects or a list of FloatCatalyticActivity objects. Note
143      * that the displayUnit has a different meaning depending on whether the list contains Number objects (e.g., Float objects)
144      * or FloatCatalyticActivity objects. In case the list contains Number objects, the displayUnit indicates the unit in which
145      * the values in the list are expressed, as well as the unit in which they will be printed. In case the list contains
146      * FloatCatalyticActivity objects, each FloatCatalyticActivity has its own unit, and the displayUnit is just used for
147      * printing. The values but will always be internally stored as SI values or base values, and expressed using the display
148      * unit or base unit when printing.
149      * @param data List&lt;Float&gt; or List&lt;CatalyticActivity&gt;; the data for the vector
150      * @param displayUnit CatalyticActivityUnit; the display unit of the vector data, and the unit of the data points when the
151      *            data is expressed as List&lt;Float&gt; or List&lt;Number&gt; in general
152      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
153      */
154     public FloatCatalyticActivityVector(final List<? extends Number> data, final CatalyticActivityUnit displayUnit,
155             final StorageType storageType)
156     {
157         this(data.size() == 0 ? FloatVectorData.instantiate(new float[] {}, IdentityScale.SCALE, storageType)
158                 : data.get(0) instanceof FloatCatalyticActivity
159                         ? FloatVectorData.instantiate(data, IdentityScale.SCALE, storageType)
160                         : FloatVectorData.instantiate(data, displayUnit.getScale(), storageType),
161                 displayUnit);
162     }
163 
164     /**
165      * Construct a FloatCatalyticActivityVector from a list of Number objects or a list of FloatCatalyticActivity objects. Note
166      * that the displayUnit has a different meaning depending on whether the list contains Number objects (e.g., Float objects)
167      * or FloatCatalyticActivity objects. In case the list contains Number objects, the displayUnit indicates the unit in which
168      * the values in the list are expressed, as well as the unit in which they will be printed. In case the list contains
169      * FloatCatalyticActivity objects, each FloatCatalyticActivity has its own unit, and the displayUnit is just used for
170      * printing. The values but will always be internally stored as SI values or base values, and expressed using the display
171      * unit or base unit when printing. Assume the storage type is DENSE since we offer the data as a List.
172      * @param data List&lt;Float&gt; or List&lt;CatalyticActivity&gt;; the data for the vector
173      * @param displayUnit CatalyticActivityUnit; the display unit of the vector data, and the unit of the data points when the
174      *            data is expressed as List&lt;Float&gt; or List&lt;Number&gt; in general
175      */
176     public FloatCatalyticActivityVector(final List<? extends Number> data, final CatalyticActivityUnit displayUnit)
177     {
178         this(data, displayUnit, StorageType.DENSE);
179     }
180 
181     /**
182      * Construct a FloatCatalyticActivityVector from a list of Number objects or a list of FloatCatalyticActivity objects. When
183      * data contains numbers such as Float, assume that they are expressed using SI units. When the data consists of
184      * FloatCatalyticActivity objects, they each have their own unit, but will be printed using SI units or base units. The
185      * values but will always be internally stored as SI values or base values, and expressed using the display unit or base
186      * unit when printing.
187      * @param data List&lt;Float&gt; or List&lt;CatalyticActivity&gt;; the data for the vector
188      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
189      */
190     public FloatCatalyticActivityVector(final List<? extends Number> data, final StorageType storageType)
191     {
192         this(data, CatalyticActivityUnit.SI, storageType);
193     }
194 
195     /**
196      * Construct a FloatCatalyticActivityVector from a list of Number objects or a list of FloatCatalyticActivity objects. When
197      * data contains numbers such as Float, assume that they are expressed using SI units. When the data consists of
198      * FloatCatalyticActivity objects, they each have their own unit, but will be printed using SI units or base units. The
199      * values but will always be internally stored as SI values or base values, and expressed using the display unit or base
200      * unit when printing. Assume the storage type is DENSE since we offer the data as a List.
201      * @param data List&lt;Float&gt; or List&lt;CatalyticActivity&gt;; the data for the vector
202      */
203     public FloatCatalyticActivityVector(final List<? extends Number> data)
204     {
205         this(data, StorageType.DENSE);
206     }
207 
208     /* CONSTRUCTORS WITH Map<Integer, Float> or Map<Integer, FloatCatalyticActivity> */
209 
210     /**
211      * Construct a FloatCatalyticActivityVector from a (sparse) map of index values to Number objects or a (sparse) map of index
212      * values to of FloatCatalyticActivity objects. Using index values is particularly useful for sparse vectors. The size
213      * parameter indicates the size of the vector, since the largest index does not have to be part of the map. Note that the
214      * displayUnit has a different meaning depending on whether the map contains Number objects (e.g., Float objects) or
215      * FloatCatalyticActivity objects. In case the map contains Number objects, the displayUnit indicates the unit in which the
216      * values in the map are expressed, as well as the unit in which they will be printed. In case the map contains
217      * FloatCatalyticActivity objects, each FloatCatalyticActivity has its own unit, and the displayUnit is just used for
218      * printing. The values but will always be internally stored as SI values or base values, and expressed using the display
219      * unit or base unit when printing.
220      * @param data Map&lt;Integer, Float&gt; or Map&lt;Integer, FloatCatalyticActivity&gt;; the data for the vector
221      * @param size int; the size off the vector, i.e., the highest index
222      * @param displayUnit CatalyticActivityUnit; the display unit of the vector data, and the unit of the data points when the
223      *            data is expressed as List&lt;Float&gt; or List&lt;Number&gt; in general
224      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
225      */
226     public FloatCatalyticActivityVector(final Map<Integer, ? extends Number> data, final int size,
227             final CatalyticActivityUnit displayUnit, final StorageType storageType)
228     {
229         this(data.size() == 0 ? FloatVectorData.instantiate(data, size, IdentityScale.SCALE, storageType)
230                 : data.values().iterator().next() instanceof FloatCatalyticActivity
231                         ? FloatVectorData.instantiate(data, size, IdentityScale.SCALE, storageType)
232                         : FloatVectorData.instantiate(data, size, displayUnit.getScale(), storageType),
233                 displayUnit);
234     }
235 
236     /**
237      * Construct a FloatCatalyticActivityVector from a (sparse) map of index values to Number objects or a (sparse) map of index
238      * values to of FloatCatalyticActivity objects. Using index values is particularly useful for sparse vectors. The size
239      * parameter indicates the size of the vector, since the largest index does not have to be part of the map. Note that the
240      * displayUnit has a different meaning depending on whether the map contains Number objects (e.g., Float objects) or
241      * FloatCatalyticActivity objects. In case the map contains Number objects, the displayUnit indicates the unit in which the
242      * values in the map are expressed, as well as the unit in which they will be printed. In case the map contains
243      * FloatCatalyticActivity objects, each FloatCatalyticActivity has its own unit, and the displayUnit is just used for
244      * printing. The values but will always be internally stored as SI values or base values, and expressed using the display
245      * unit or base unit when printing. Assume the storage type is SPARSE since we offer the data as a Map.
246      * @param data Map&lt;Integer, Float&gt; or Map&lt;Integer, FloatCatalyticActivity&gt;; the data for the vector
247      * @param size int; the size off the vector, i.e., the highest index
248      * @param displayUnit CatalyticActivityUnit; the display unit of the vector data, and the unit of the data points when the
249      *            data is expressed as List&lt;Float&gt; or List&lt;Number&gt; in general
250      */
251     public FloatCatalyticActivityVector(final Map<Integer, ? extends Number> data, final int size,
252             final CatalyticActivityUnit displayUnit)
253     {
254         this(data, size, displayUnit, StorageType.SPARSE);
255     }
256 
257     /**
258      * Construct a FloatCatalyticActivityVector from a (sparse) map of index values to Number objects or a (sparse) map of index
259      * values to of FloatCatalyticActivity objects. Using index values is particularly useful for sparse vectors. The size
260      * parameter indicates the size of the vector, since the largest index does not have to be part of the map. When data
261      * contains numbers such as Float, assume that they are expressed using SI units. When the data consists of
262      * FloatCatalyticActivity objects, they each have their own unit, but will be printed using SI units or base units. The
263      * values but will always be internally stored as SI values or base values, and expressed using the display unit or base
264      * unit when printing.
265      * @param data Map&lt;Integer, Float&gt; or Map&lt;Integer, FloatCatalyticActivity&gt;; the data for the vector
266      * @param size int; the size off the vector, i.e., the highest index
267      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
268      */
269     public FloatCatalyticActivityVector(final Map<Integer, ? extends Number> data, final int size,
270             final StorageType storageType)
271     {
272         this(data, size, CatalyticActivityUnit.SI, storageType);
273     }
274 
275     /**
276      * Construct a FloatCatalyticActivityVector from a (sparse) map of index values to Number objects or a (sparse) map of index
277      * values to of FloatCatalyticActivity objects. Using index values is particularly useful for sparse vectors. The size
278      * parameter indicates the size of the vector, since the largest index does not have to be part of the map. When data
279      * contains numbers such as Float, assume that they are expressed using SI units. When the data consists of
280      * FloatCatalyticActivity objects, they each have their own unit, but will be printed using SI units or base units. The
281      * values but will always be internally stored as SI values or base values, and expressed using the display unit or base
282      * unit when printing. Assume the storage type is SPARSE since we offer the data as a Map.
283      * @param data Map&lt;Integer, Float&gt; or Map&lt;Integer, FloatCatalyticActivity&gt;; the data for the vector
284      * @param size int; the size off the vector, i.e., the highest index
285      */
286     public FloatCatalyticActivityVector(final Map<Integer, ? extends Number> data, final int size)
287     {
288         this(data, size, StorageType.SPARSE);
289     }
290 
291     /* ****************************** Other methods ****************************** */
292 
293     @Override
294     public Class<FloatCatalyticActivity> getScalarClass()
295     {
296         return FloatCatalyticActivity.class;
297     }
298 
299     @Override
300     public FloatCatalyticActivityVector instantiateVector(final FloatVectorData fvd, final CatalyticActivityUnit displayUnit)
301     {
302         return new FloatCatalyticActivityVector(fvd, displayUnit);
303     }
304 
305     @Override
306     public FloatCatalyticActivity instantiateScalarSI(final float valueSI, final CatalyticActivityUnit displayUnit)
307     {
308         FloatCatalyticActivity result = FloatCatalyticActivity.instantiateSI(valueSI);
309         result.setDisplayUnit(displayUnit);
310         return result;
311     }
312 
313 }