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