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