1 package org.djunits.value.vfloat.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.vfloat.matrix.base.FloatMatrixRelWithAbs; 9 import org.djunits.value.vfloat.matrix.base.FloatSparseValue; 10 import org.djunits.value.vfloat.matrix.data.FloatMatrixData; 11 import org.djunits.value.vfloat.scalar.FloatLength; 12 import org.djunits.value.vfloat.scalar.FloatPosition; 13 import org.djunits.value.vfloat.vector.FloatLengthVector; 14 import org.djunits.value.vfloat.vector.FloatPositionVector; 15 import org.djunits.value.vfloat.vector.data.FloatVectorData; 16 17 import jakarta.annotation.Generated; 18 19 /** 20 * Immutable FloatLength 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 FloatLengthMatrix extends FloatMatrixRelWithAbs<PositionUnit, FloatPosition, FloatPositionVector, 30 FloatPositionMatrix, LengthUnit, FloatLength, FloatLengthVector, FloatLengthMatrix> 31 { 32 /** */ 33 private static final long serialVersionUID = 20151006L; 34 35 /** 36 * Construct a FloatLengthMatrix from an internal data object. 37 * @param data FloatMatrixData; the internal data object for the matrix 38 * @param displayUnit LengthUnit; the display unit of the matrix data 39 */ 40 public FloatLengthMatrix(final FloatMatrixData data, final LengthUnit displayUnit) 41 { 42 super(data, displayUnit); 43 } 44 45 /* CONSTRUCTORS WITH float[][] */ 46 47 /** 48 * Construct a FloatLengthMatrix from a float[][] object. The float values are expressed in the displayUnit, and will be 49 * printed using the displayUnit. 50 * @param data float[][]; the data for the matrix, expressed in the displayUnit 51 * @param displayUnit LengthUnit; 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 FloatLengthMatrix(final float[][] data, final LengthUnit displayUnit, final StorageType storageType) 55 { 56 this(FloatMatrixData.instantiate(data, displayUnit.getScale(), storageType), displayUnit); 57 } 58 59 /** 60 * Construct a FloatLengthMatrix from a float[][] object. The float 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 float[][]; the data for the matrix 63 * @param displayUnit LengthUnit; the unit of the values in the data array, and display unit when printing 64 */ 65 public FloatLengthMatrix(final float[][] data, final LengthUnit displayUnit) 66 { 67 this(data, displayUnit, StorageType.DENSE); 68 } 69 70 /** 71 * Construct a FloatLengthMatrix from a float[][] object with SI-unit values. 72 * @param data float[][]; 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 FloatLengthMatrix(final float[][] data, final StorageType storageType) 76 { 77 this(data, LengthUnit.SI, storageType); 78 } 79 80 /** 81 * Construct a FloatLengthMatrix from a float[][] 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 float[][]; the data for the matrix, in SI units 84 */ 85 public FloatLengthMatrix(final float[][] data) 86 { 87 this(data, StorageType.DENSE); 88 } 89 90 /* CONSTRUCTORS WITH FloatLength[][] */ 91 92 /** 93 * Construct a FloatLengthMatrix from an array of an array of FloatLength objects. The FloatLength values are each expressed 94 * in their own unit, but will be internally stored as SI values, all expressed in the displayUnit when printing. 95 * @param data FloatLength[][]; the data for the matrix 96 * @param displayUnit LengthUnit; 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 FloatLengthMatrix(final FloatLength[][] data, final LengthUnit displayUnit, final StorageType storageType) 100 { 101 this(FloatMatrixData.instantiate(data, storageType), displayUnit); 102 } 103 104 /** 105 * Construct a FloatLengthMatrix from an array of an array of FloatLength objects. The FloatLength values are each expressed 106 * in their own unit, but will be internally stored as SI values, all expressed in the displayUnit when printing. Assume 107 * that the StorageType is DENSE since we offer the data as an array of an array. 108 * @param data FloatLength[][]; the data for the matrix 109 * @param displayUnit LengthUnit; the display unit of the values when printing 110 */ 111 public FloatLengthMatrix(final FloatLength[][] data, final LengthUnit displayUnit) 112 { 113 this(data, displayUnit, StorageType.DENSE); 114 } 115 116 /** 117 * Construct a FloatLengthMatrix from an array of an array of FloatLength objects. The FloatLength values are each expressed 118 * in their own unit, but will be internally stored as SI values, and expressed using SI units when printing. since we offer 119 * the data as an array of an array. 120 * @param data FloatLength[][]; the data for the matrix 121 * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix 122 */ 123 public FloatLengthMatrix(final FloatLength[][] data, final StorageType storageType) 124 { 125 this(data, LengthUnit.SI, storageType); 126 } 127 128 /** 129 * Construct a FloatLengthMatrix from an array of an array of FloatLength objects. The FloatLength values are each expressed 130 * in their own unit, but will be internally stored as SI values, and expressed using SI units when printing. Assume that 131 * the StorageType is DENSE since we offer the data as an array of an array. 132 * @param data FloatLength[][]; the data for the matrix 133 */ 134 public FloatLengthMatrix(final FloatLength[][] data) 135 { 136 this(data, StorageType.DENSE); 137 } 138 139 /* CONSTRUCTORS WITH Collection<FloatSparseValue> */ 140 141 /** 142 * Construct a FloatLengthMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates the unit 143 * in which the values in the collection are expressed, as well as the unit in which they will be printed. 144 * @param data Collection<FloatSparseValue>; the data for the matrix 145 * @param displayUnit LengthUnit; 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 FloatLengthMatrix(final Collection<FloatSparseValue<LengthUnit, FloatLength>> data, final LengthUnit displayUnit, 151 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 FloatLengthMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates the unit 158 * in which the values in the collection are expressed, as well as the unit in which they will be printed. Assume the 159 * storage type is SPARSE, since we offer the data as a collection. 160 * @param data Collection<FloatSparseValue>; the data for the matrix 161 * @param displayUnit LengthUnit; 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 FloatLengthMatrix(final Collection<FloatSparseValue<LengthUnit, FloatLength>> data, final LengthUnit displayUnit, 166 final int rows, final int cols) 167 { 168 this(data, displayUnit, rows, cols, StorageType.SPARSE); 169 } 170 171 /** 172 * Construct a FloatLengthMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates the unit 173 * in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the SI unit 174 * or base unit as the displayUnit. 175 * @param data Collection<FloatSparseValue>; 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 FloatLengthMatrix(final Collection<FloatSparseValue<LengthUnit, FloatLength>> data, final int rows, final int cols, 181 final StorageType storageType) 182 { 183 this(data, LengthUnit.SI, rows, cols, storageType); 184 } 185 186 /** 187 * Construct a FloatLengthMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates the unit 188 * in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the SI unit 189 * or base unit as the displayUnit. Assume the storage type is SPARSE, since we offer the data as a collection. 190 * @param data Collection<FloatSparseValue>; 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 FloatLengthMatrix(final Collection<FloatSparseValue<LengthUnit, FloatLength>> data, final int rows, final int cols) 195 { 196 this(data, LengthUnit.SI, rows, cols, StorageType.SPARSE); 197 } 198 199 @Override 200 public Class<FloatLength> getScalarClass() 201 { 202 return FloatLength.class; 203 } 204 205 @Override 206 public Class<FloatLengthVector> getVectorClass() 207 { 208 return FloatLengthVector.class; 209 } 210 211 @Override 212 public FloatLengthMatrix instantiateMatrix(final FloatMatrixData fmd, final LengthUnit displayUnit) 213 { 214 return new FloatLengthMatrix(fmd, displayUnit); 215 } 216 217 @Override 218 public FloatLengthVector instantiateVector(final FloatVectorData fvd, final LengthUnit displayUnit) 219 { 220 return new FloatLengthVector(fvd, displayUnit); 221 } 222 223 @Override 224 public FloatLength instantiateScalarSI(final float valueSI, final LengthUnit displayUnit) 225 { 226 FloatLength result = FloatLength.instantiateSI(valueSI); 227 result.setDisplayUnit(displayUnit); 228 return result; 229 } 230 231 @Override 232 public FloatPositionMatrix instantiateMatrixAbs(final FloatMatrixData fmd, final PositionUnit displayUnit) 233 { 234 return new FloatPositionMatrix(fmd, displayUnit); 235 } 236 237 @Override 238 public FloatPositionVector instantiateVectorAbs(final FloatVectorData fvd, final PositionUnit displayUnit) 239 { 240 return new FloatPositionVector(fvd, displayUnit); 241 } 242 243 @Override 244 public FloatPosition instantiateScalarAbsSI(final float valueSI, final PositionUnit displayUnit) 245 { 246 FloatPosition result = FloatPosition.instantiateSI(valueSI); 247 result.setDisplayUnit(displayUnit); 248 return result; 249 } 250 251 }