View Javadoc
1   package org.djunits.value.vdouble.vector;
2   
3   import java.util.List;
4   import java.util.Map;
5   
6   import org.djunits.unit.ElectricalCapacitanceUnit;
7   import org.djunits.unit.scale.IdentityScale;
8   import org.djunits.value.storage.StorageType;
9   import org.djunits.value.vdouble.scalar.ElectricalCapacitance;
10  import org.djunits.value.vdouble.vector.base.DoubleVectorRel;
11  import org.djunits.value.vdouble.vector.data.DoubleVectorData;
12  
13  import jakarta.annotation.Generated;
14  
15  /**
16   * Double ElectricalCapacitanceVector, a vector of values with a ElectricalCapacitanceUnit.
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 ElectricalCapacitanceVector
26          extends DoubleVectorRel<ElectricalCapacitanceUnit, ElectricalCapacitance, ElectricalCapacitanceVector>
27  
28  {
29      /** */
30      private static final long serialVersionUID = 20190905L;
31  
32      /**
33       * Construct an ElectricalCapacitanceVector from an internal data object.
34       * @param data DoubleVectorData; the internal data object for the vector
35       * @param displayUnit ElectricalCapacitanceUnit; the display unit of the vector data
36       */
37      public ElectricalCapacitanceVector(final DoubleVectorData data, final ElectricalCapacitanceUnit displayUnit)
38      {
39          super(data, displayUnit);
40      }
41  
42      /* CONSTRUCTORS WITH double[] */
43  
44      /**
45       * Construct an ElectricalCapacitanceVector from a double[] object. The double values are expressed in the displayUnit, and
46       * will be printed using the displayUnit.
47       * @param data double[]; the data for the vector, expressed in the displayUnit
48       * @param displayUnit ElectricalCapacitanceUnit; 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 ElectricalCapacitanceVector(final double[] data, final ElectricalCapacitanceUnit displayUnit,
52              final StorageType storageType)
53      {
54          this(DoubleVectorData.instantiate(data, displayUnit.getScale(), storageType), displayUnit);
55      }
56  
57      /**
58       * Construct an ElectricalCapacitanceVector from a double[] object. The double values are expressed in the displayUnit.
59       * Assume that the StorageType is DENSE since we offer the data as an array.
60       * @param data double[]; the data for the vector
61       * @param displayUnit ElectricalCapacitanceUnit; the unit of the values in the data array, and display unit when printing
62       */
63      public ElectricalCapacitanceVector(final double[] data, final ElectricalCapacitanceUnit displayUnit)
64      {
65          this(data, displayUnit, StorageType.DENSE);
66      }
67  
68      /**
69       * Construct an ElectricalCapacitanceVector from a double[] object with SI-unit values.
70       * @param data double[]; 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 ElectricalCapacitanceVector(final double[] data, final StorageType storageType)
74      {
75          this(data, ElectricalCapacitanceUnit.SI, storageType);
76      }
77  
78      /**
79       * Construct an ElectricalCapacitanceVector from a double[] object with SI-unit values. Assume that the StorageType is DENSE
80       * since we offer the data as an array.
81       * @param data double[]; the data for the vector, in SI units
82       */
83      public ElectricalCapacitanceVector(final double[] data)
84      {
85          this(data, StorageType.DENSE);
86      }
87  
88      /* CONSTRUCTORS WITH ElectricalCapacitance[] */
89  
90      /**
91       * Construct an ElectricalCapacitanceVector from an array of ElectricalCapacitance objects. The ElectricalCapacitance values
92       * are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit when
93       * printing.
94       * @param data ElectricalCapacitance[]; the data for the vector
95       * @param displayUnit ElectricalCapacitanceUnit; 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 ElectricalCapacitanceVector(final ElectricalCapacitance[] data, final ElectricalCapacitanceUnit displayUnit,
99              final StorageType storageType)
100     {
101         this(DoubleVectorData.instantiate(data, storageType), displayUnit);
102     }
103 
104     /**
105      * Construct an ElectricalCapacitanceVector from an array of ElectricalCapacitance objects. The ElectricalCapacitance values
106      * are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit when
107      * printing. Assume that the StorageType is DENSE since we offer the data as an array.
108      * @param data ElectricalCapacitance[]; the data for the vector
109      * @param displayUnit ElectricalCapacitanceUnit; the display unit of the values when printing
110      */
111     public ElectricalCapacitanceVector(final ElectricalCapacitance[] data, final ElectricalCapacitanceUnit displayUnit)
112     {
113         this(data, displayUnit, StorageType.DENSE);
114     }
115 
116     /**
117      * Construct an ElectricalCapacitanceVector from an array of ElectricalCapacitance objects. The ElectricalCapacitance values
118      * are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units when
119      * printing. since we offer the data as an array.
120      * @param data ElectricalCapacitance[]; the data for the vector
121      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
122      */
123     public ElectricalCapacitanceVector(final ElectricalCapacitance[] data, final StorageType storageType)
124     {
125         this(data, ElectricalCapacitanceUnit.SI, storageType);
126     }
127 
128     /**
129      * Construct an ElectricalCapacitanceVector from an array of ElectricalCapacitance objects. The ElectricalCapacitance values
130      * are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units when
131      * printing. Assume that the StorageType is DENSE since we offer the data as an array.
132      * @param data ElectricalCapacitance[]; the data for the vector
133      */
134     public ElectricalCapacitanceVector(final ElectricalCapacitance[] data)
135     {
136         this(data, StorageType.DENSE);
137     }
138 
139     /* CONSTRUCTORS WITH List<Double> or List<ElectricalCapacitance> */
140 
141     /**
142      * Construct an ElectricalCapacitanceVector from a list of Number objects or a list of ElectricalCapacitance objects. Note
143      * that the displayUnit has a different meaning depending on whether the list contains Number objects (e.g., Double objects)
144      * or ElectricalCapacitance 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      * ElectricalCapacitance objects, each ElectricalCapacitance 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;Double&gt; or List&lt;ElectricalCapacitance&gt;; the data for the vector
150      * @param displayUnit ElectricalCapacitanceUnit; the display unit of the vector data, and the unit of the data points when
151      *            the data is expressed as List&lt;Double&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 ElectricalCapacitanceVector(final List<? extends Number> data, final ElectricalCapacitanceUnit displayUnit,
155             final StorageType storageType)
156     {
157         this(data.size() == 0 ? DoubleVectorData.instantiate(new double[] {}, IdentityScale.SCALE, storageType)
158                 : data.get(0) instanceof ElectricalCapacitance
159                         ? DoubleVectorData.instantiate(data, IdentityScale.SCALE, storageType)
160                         : DoubleVectorData.instantiate(data, displayUnit.getScale(), storageType),
161                 displayUnit);
162     }
163 
164     /**
165      * Construct an ElectricalCapacitanceVector from a list of Number objects or a list of ElectricalCapacitance objects. Note
166      * that the displayUnit has a different meaning depending on whether the list contains Number objects (e.g., Double objects)
167      * or ElectricalCapacitance 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      * ElectricalCapacitance objects, each ElectricalCapacitance 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;Double&gt; or List&lt;ElectricalCapacitance&gt;; the data for the vector
173      * @param displayUnit ElectricalCapacitanceUnit; the display unit of the vector data, and the unit of the data points when
174      *            the data is expressed as List&lt;Double&gt; or List&lt;Number&gt; in general
175      */
176     public ElectricalCapacitanceVector(final List<? extends Number> data, final ElectricalCapacitanceUnit displayUnit)
177     {
178         this(data, displayUnit, StorageType.DENSE);
179     }
180 
181     /**
182      * Construct an ElectricalCapacitanceVector from a list of Number objects or a list of ElectricalCapacitance objects. When
183      * data contains numbers such as Double, assume that they are expressed using SI units. When the data consists of
184      * ElectricalCapacitance 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;Double&gt; or List&lt;ElectricalCapacitance&gt;; the data for the vector
188      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Vector
189      */
190     public ElectricalCapacitanceVector(final List<? extends Number> data, final StorageType storageType)
191     {
192         this(data, ElectricalCapacitanceUnit.SI, storageType);
193     }
194 
195     /**
196      * Construct an ElectricalCapacitanceVector from a list of Number objects or a list of ElectricalCapacitance objects. When
197      * data contains numbers such as Double, assume that they are expressed using SI units. When the data consists of
198      * ElectricalCapacitance 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;Double&gt; or List&lt;ElectricalCapacitance&gt;; the data for the vector
202      */
203     public ElectricalCapacitanceVector(final List<? extends Number> data)
204     {
205         this(data, StorageType.DENSE);
206     }
207 
208     /* CONSTRUCTORS WITH Map<Integer, Double> or Map<Integer, ElectricalCapacitance> */
209 
210     /**
211      * Construct an ElectricalCapacitanceVector from a (sparse) map of index values to Number objects or a (sparse) map of index
212      * values to of ElectricalCapacitance 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., Double objects) or
215      * ElectricalCapacitance 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      * ElectricalCapacitance objects, each ElectricalCapacitance 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, Double&gt; or Map&lt;Integer, ElectricalCapacitance&gt;; the data for the vector
221      * @param size int; the size off the vector, i.e., the highest index
222      * @param displayUnit ElectricalCapacitanceUnit; the display unit of the vector data, and the unit of the data points when
223      *            the data is expressed as List&lt;Double&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 ElectricalCapacitanceVector(final Map<Integer, ? extends Number> data, final int size,
227             final ElectricalCapacitanceUnit displayUnit, final StorageType storageType)
228     {
229         this(data.size() == 0 ? DoubleVectorData.instantiate(data, size, IdentityScale.SCALE, storageType)
230                 : data.values().iterator().next() instanceof ElectricalCapacitance
231                         ? DoubleVectorData.instantiate(data, size, IdentityScale.SCALE, storageType)
232                         : DoubleVectorData.instantiate(data, size, displayUnit.getScale(), storageType),
233                 displayUnit);
234     }
235 
236     /**
237      * Construct an ElectricalCapacitanceVector from a (sparse) map of index values to Number objects or a (sparse) map of index
238      * values to of ElectricalCapacitance 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., Double objects) or
241      * ElectricalCapacitance 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      * ElectricalCapacitance objects, each ElectricalCapacitance 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, Double&gt; or Map&lt;Integer, ElectricalCapacitance&gt;; the data for the vector
247      * @param size int; the size off the vector, i.e., the highest index
248      * @param displayUnit ElectricalCapacitanceUnit; the display unit of the vector data, and the unit of the data points when
249      *            the data is expressed as List&lt;Double&gt; or List&lt;Number&gt; in general
250      */
251     public ElectricalCapacitanceVector(final Map<Integer, ? extends Number> data, final int size,
252             final ElectricalCapacitanceUnit displayUnit)
253     {
254         this(data, size, displayUnit, StorageType.SPARSE);
255     }
256 
257     /**
258      * Construct an ElectricalCapacitanceVector from a (sparse) map of index values to Number objects or a (sparse) map of index
259      * values to of ElectricalCapacitance 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 Double, assume that they are expressed using SI units. When the data consists of
262      * ElectricalCapacitance 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, Double&gt; or Map&lt;Integer, ElectricalCapacitance&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 ElectricalCapacitanceVector(final Map<Integer, ? extends Number> data, final int size, final StorageType storageType)
270     {
271         this(data, size, ElectricalCapacitanceUnit.SI, storageType);
272     }
273 
274     /**
275      * Construct an ElectricalCapacitanceVector from a (sparse) map of index values to Number objects or a (sparse) map of index
276      * values to of ElectricalCapacitance objects. Using index values is particularly useful for sparse vectors. The size
277      * parameter indicates the size of the vector, since the largest index does not have to be part of the map. When data
278      * contains numbers such as Double, assume that they are expressed using SI units. When the data consists of
279      * ElectricalCapacitance objects, they each have their own unit, but will be printed using SI units or base units. The
280      * values but will always be internally stored as SI values or base values, and expressed using the display unit or base
281      * unit when printing. Assume the storage type is SPARSE since we offer the data as a Map.
282      * @param data Map&lt;Integer, Double&gt; or Map&lt;Integer, ElectricalCapacitance&gt;; the data for the vector
283      * @param size int; the size off the vector, i.e., the highest index
284      */
285     public ElectricalCapacitanceVector(final Map<Integer, ? extends Number> data, final int size)
286     {
287         this(data, size, StorageType.SPARSE);
288     }
289 
290     /* ****************************** Other methods ****************************** */
291 
292     @Override
293     public Class<ElectricalCapacitance> getScalarClass()
294     {
295         return ElectricalCapacitance.class;
296     }
297 
298     @Override
299     public ElectricalCapacitanceVector instantiateVector(final DoubleVectorData dvd,
300             final ElectricalCapacitanceUnit displayUnit)
301     {
302         return new ElectricalCapacitanceVector(dvd, displayUnit);
303     }
304 
305     @Override
306     public ElectricalCapacitance instantiateScalarSI(final double valueSI, final ElectricalCapacitanceUnit displayUnit)
307     {
308         ElectricalCapacitance result = ElectricalCapacitance.instantiateSI(valueSI);
309         result.setDisplayUnit(displayUnit);
310         return result;
311     }
312 
313 }