View Javadoc
1   package org.djunits.value.vdouble.matrix;
2   
3   import java.util.Collection;
4   
5   import org.djunits.unit.LengthUnit;
6   import org.djunits.unit.PositionUnit;
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.Length;
12  import org.djunits.value.vdouble.scalar.Position;
13  import org.djunits.value.vdouble.vector.LengthVector;
14  import org.djunits.value.vdouble.vector.PositionVector;
15  import org.djunits.value.vdouble.vector.data.DoubleVectorData;
16  
17  import jakarta.annotation.Generated;
18  
19  /**
20   * Immutable Position 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 PositionMatrix extends
30          DoubleMatrixAbs<PositionUnit, Position, PositionVector, PositionMatrix, LengthUnit, Length, LengthVector, LengthMatrix>
31  {
32      /** */
33      private static final long serialVersionUID = 20151006L;
34  
35      /**
36       * Construct a PositionMatrix from an internal data object.
37       * @param data DoubleMatrixData; the internal data object for the matrix
38       * @param displayUnit PositionUnit; the display unit of the matrix data
39       */
40      public PositionMatrix(final DoubleMatrixData data, final PositionUnit displayUnit)
41      {
42          super(data, displayUnit);
43      }
44  
45      /* CONSTRUCTORS WITH double[][] */
46  
47      /**
48       * Construct a PositionMatrix from a double[][] object. The double values are expressed in the displayUnit, and will be
49       * printed using the displayUnit.
50       * @param data double[][]; the data for the matrix, expressed in the displayUnit
51       * @param displayUnit PositionUnit; 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 PositionMatrix(final double[][] data, final PositionUnit displayUnit, final StorageType storageType)
55      {
56          this(DoubleMatrixData.instantiate(data, displayUnit.getScale(), storageType), displayUnit);
57      }
58  
59      /**
60       * Construct a PositionMatrix 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 PositionUnit; the unit of the values in the data array, and display unit when printing
64       */
65      public PositionMatrix(final double[][] data, final PositionUnit displayUnit)
66      {
67          this(data, displayUnit, StorageType.DENSE);
68      }
69  
70      /**
71       * Construct a PositionMatrix 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 PositionMatrix(final double[][] data, final StorageType storageType)
76      {
77          this(data, PositionUnit.BASE.getStandardUnit(), storageType);
78      }
79  
80      /**
81       * Construct a PositionMatrix from a double[][] object with SI-unit values. Assume that the StorageType is DENSE since we
82       * offer the data as an array of an array.
83       * @param data double[][]; the data for the matrix, in SI units
84       */
85      public PositionMatrix(final double[][] data)
86      {
87          this(data, StorageType.DENSE);
88      }
89  
90      /* CONSTRUCTORS WITH Position[][] */
91  
92      /**
93       * Construct a PositionMatrix from an array of an array of Position objects. The Position values are each expressed in their
94       * own unit, but will be internally stored as SI values, all expressed in the displayUnit when printing.
95       * @param data Position[][]; the data for the matrix
96       * @param displayUnit PositionUnit; 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 PositionMatrix(final Position[][] data, final PositionUnit displayUnit, final StorageType storageType)
100     {
101         this(DoubleMatrixData.instantiate(data, storageType), displayUnit);
102     }
103 
104     /**
105      * Construct a PositionMatrix from an array of an array of Position objects. The Position values are each expressed in their
106      * own unit, but will be internally stored as SI values, all expressed in the displayUnit when printing. Assume that the
107      * StorageType is DENSE since we offer the data as an array of an array.
108      * @param data Position[][]; the data for the matrix
109      * @param displayUnit PositionUnit; the display unit of the values when printing
110      */
111     public PositionMatrix(final Position[][] data, final PositionUnit displayUnit)
112     {
113         this(data, displayUnit, StorageType.DENSE);
114     }
115 
116     /**
117      * Construct a PositionMatrix from an array of an array of Position objects. The Position values are each expressed in their
118      * own unit, but will be internally stored as SI values, and expressed using SI units when printing. since we offer the data
119      * as an array of an array.
120      * @param data Position[][]; the data for the matrix
121      * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix
122      */
123     public PositionMatrix(final Position[][] data, final StorageType storageType)
124     {
125         this(data, PositionUnit.BASE.getStandardUnit(), storageType);
126     }
127 
128     /**
129      * Construct a PositionMatrix from an array of an array of Position objects. The Position values are each expressed in their
130      * own unit, but will be internally stored as SI values, and expressed using SI units when printing. Assume that the
131      * StorageType is DENSE since we offer the data as an array of an array.
132      * @param data Position[][]; the data for the matrix
133      */
134     public PositionMatrix(final Position[][] data)
135     {
136         this(data, StorageType.DENSE);
137     }
138 
139     /* CONSTRUCTORS WITH Collection<DoubleSparseValue> */
140 
141     /**
142      * Construct a PositionMatrix 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 PositionUnit; 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 PositionMatrix(final Collection<DoubleSparseValue<PositionUnit, Position>> data, final PositionUnit displayUnit,
151             final int rows, final int cols, final StorageType storageType)
152     {
153         this(DoubleMatrixData.instantiate(data, rows, cols, storageType), displayUnit);
154     }
155 
156     /**
157      * Construct a PositionMatrix 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 PositionUnit; 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 PositionMatrix(final Collection<DoubleSparseValue<PositionUnit, Position>> data, final PositionUnit displayUnit,
166             final int rows, final int cols)
167     {
168         this(data, displayUnit, rows, cols, StorageType.SPARSE);
169     }
170 
171     /**
172      * Construct a PositionMatrix 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 PositionMatrix(final Collection<DoubleSparseValue<PositionUnit, Position>> data, final int rows, final int cols,
181             final StorageType storageType)
182     {
183         this(data, PositionUnit.BASE.getStandardUnit(), rows, cols, storageType);
184     }
185 
186     /**
187      * Construct a PositionMatrix 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 PositionMatrix(final Collection<DoubleSparseValue<PositionUnit, Position>> data, final int rows, final int cols)
195     {
196         this(data, PositionUnit.BASE.getStandardUnit(), rows, cols, StorageType.SPARSE);
197     }
198 
199     @Override
200     public Class<Position> getScalarClass()
201     {
202         return Position.class;
203     }
204 
205     @Override
206     public Class<PositionVector> getVectorClass()
207     {
208         return PositionVector.class;
209     }
210 
211     @Override
212     public PositionMatrix instantiateMatrix(final DoubleMatrixData dmd, final PositionUnit displayUnit)
213     {
214         return new PositionMatrix(dmd, displayUnit);
215     }
216 
217     @Override
218     public PositionVector instantiateVector(final DoubleVectorData dvd, final PositionUnit displayUnit)
219     {
220         return new PositionVector(dvd, displayUnit);
221     }
222 
223     @Override
224     public Position instantiateScalarSI(final double valueSI, final PositionUnit displayUnit)
225     {
226         Position result = Position.instantiateSI(valueSI);
227         result.setDisplayUnit(displayUnit);
228         return result;
229     }
230 
231     @Override
232     public LengthMatrix instantiateMatrixRel(final DoubleMatrixData dmd, final LengthUnit displayUnit)
233     {
234         return new LengthMatrix(dmd, displayUnit);
235     }
236 
237     @Override
238     public LengthVector instantiateVectorRel(final DoubleVectorData dvd, final LengthUnit displayUnit)
239     {
240         return new LengthVector(dvd, displayUnit);
241     }
242 
243     @Override
244     public Length instantiateScalarRelSI(final double valueSI, final LengthUnit displayUnit)
245     {
246         Length result = Length.instantiateSI(valueSI);
247         result.setDisplayUnit(displayUnit);
248         return result;
249     }
250 
251 }