1 package org.djunits.value.vfloat.matrix; 2 3 import java.util.Collection; 4 5 import org.djunits.unit.EquivalentDoseUnit; 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.FloatEquivalentDose; 11 import org.djunits.value.vfloat.vector.FloatEquivalentDoseVector; 12 import org.djunits.value.vfloat.vector.data.FloatVectorData; 13 14 import jakarta.annotation.Generated; 15 16 /** 17 * Immutable FloatFloatEquivalentDoseMatrix, a matrix of values with a EquivalentDoseUnit. 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 FloatEquivalentDoseMatrix 27 extends FloatMatrixRel<EquivalentDoseUnit, FloatEquivalentDose, FloatEquivalentDoseVector, FloatEquivalentDoseMatrix> 28 29 { 30 /** */ 31 private static final long serialVersionUID = 20151109L; 32 33 /** 34 * Construct a FloatEquivalentDoseMatrix from an internal data object. 35 * @param data FloatMatrixData; the internal data object for the matrix 36 * @param displayUnit EquivalentDoseUnit; the display unit of the matrix data 37 */ 38 public FloatEquivalentDoseMatrix(final FloatMatrixData data, final EquivalentDoseUnit displayUnit) 39 { 40 super(data, displayUnit); 41 } 42 43 /* CONSTRUCTORS WITH float[][] */ 44 45 /** 46 * Construct a FloatEquivalentDoseMatrix 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 EquivalentDoseUnit; 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 FloatEquivalentDoseMatrix(final float[][] data, final EquivalentDoseUnit displayUnit, final StorageType storageType) 53 { 54 this(FloatMatrixData.instantiate(data, displayUnit.getScale(), storageType), displayUnit); 55 } 56 57 /** 58 * Construct a FloatEquivalentDoseMatrix from a float[][] object. The float values are expressed in the displayUnit. Assume 59 * that the StorageType is DENSE since we offer the data as an array of an array. 60 * @param data float[][]; the data for the matrix 61 * @param displayUnit EquivalentDoseUnit; the unit of the values in the data array, and display unit when printing 62 */ 63 public FloatEquivalentDoseMatrix(final float[][] data, final EquivalentDoseUnit displayUnit) 64 { 65 this(data, displayUnit, StorageType.DENSE); 66 } 67 68 /** 69 * Construct a FloatEquivalentDoseMatrix from a float[][] object with SI-unit values. 70 * @param data float[][]; the data for the matrix, in SI units 71 * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix 72 */ 73 public FloatEquivalentDoseMatrix(final float[][] data, final StorageType storageType) 74 { 75 this(data, EquivalentDoseUnit.SI, storageType); 76 } 77 78 /** 79 * Construct a FloatEquivalentDoseMatrix from a float[][] object with SI-unit values. Assume that the StorageType is DENSE 80 * since we offer the data as an array of an array. 81 * @param data float[][]; the data for the matrix, in SI units 82 */ 83 public FloatEquivalentDoseMatrix(final float[][] data) 84 { 85 this(data, StorageType.DENSE); 86 } 87 88 /* CONSTRUCTORS WITH EquivalentDose[][] */ 89 90 /** 91 * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose 92 * values are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit 93 * when printing. 94 * @param data FloatEquivalentDose[][]; the data for the matrix 95 * @param displayUnit EquivalentDoseUnit; the display unit of the values when printing 96 * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix 97 */ 98 public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final EquivalentDoseUnit displayUnit, 99 final StorageType storageType) 100 { 101 this(FloatMatrixData.instantiate(data, storageType), displayUnit); 102 } 103 104 /** 105 * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose 106 * values are each expressed in their own unit, but will be internally stored as SI values, all expressed in the displayUnit 107 * when printing. Assume that the StorageType is DENSE since we offer the data as an array of an array. 108 * @param data FloatEquivalentDose[][]; the data for the matrix 109 * @param displayUnit EquivalentDoseUnit; the display unit of the values when printing 110 */ 111 public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final EquivalentDoseUnit displayUnit) 112 { 113 this(data, displayUnit, StorageType.DENSE); 114 } 115 116 /** 117 * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose 118 * values are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units 119 * when printing. since we offer the data as an array of an array. 120 * @param data FloatEquivalentDose[][]; the data for the matrix 121 * @param storageType StorageType; the StorageType (SPARSE or DENSE) to use for constructing the Matrix 122 */ 123 public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data, final StorageType storageType) 124 { 125 this(data, EquivalentDoseUnit.SI, storageType); 126 } 127 128 /** 129 * Construct a FloatEquivalentDoseMatrix from an array of an array of FloatEquivalentDose objects. The FloatEquivalentDose 130 * values are each expressed in their own unit, but will be internally stored as SI values, and expressed using SI units 131 * when printing. Assume that the StorageType is DENSE since we offer the data as an array of an array. 132 * @param data FloatEquivalentDose[][]; the data for the matrix 133 */ 134 public FloatEquivalentDoseMatrix(final FloatEquivalentDose[][] data) 135 { 136 this(data, StorageType.DENSE); 137 } 138 139 /* CONSTRUCTORS WITH Collection<FloatSparseValue> */ 140 141 /** 142 * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates 143 * the unit 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 EquivalentDoseUnit; 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 FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data, 151 final EquivalentDoseUnit displayUnit, 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 FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates 158 * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Assume 159 * the 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 EquivalentDoseUnit; 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 FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data, 166 final EquivalentDoseUnit displayUnit, final int rows, final int cols) 167 { 168 this(data, displayUnit, rows, cols, StorageType.SPARSE); 169 } 170 171 /** 172 * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates 173 * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the 174 * SI unit 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 FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data, 181 final int rows, final int cols, final StorageType storageType) 182 { 183 this(data, EquivalentDoseUnit.SI, rows, cols, storageType); 184 } 185 186 /** 187 * Construct a FloatEquivalentDoseMatrix from a (sparse) collection of FloatSparseValue objects. The displayUnit indicates 188 * the unit in which the values in the collection are expressed, as well as the unit in which they will be printed. Use the 189 * SI unit 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 FloatEquivalentDoseMatrix(final Collection<FloatSparseValue<EquivalentDoseUnit, FloatEquivalentDose>> data, 195 final int rows, final int cols) 196 { 197 this(data, EquivalentDoseUnit.SI, rows, cols, StorageType.SPARSE); 198 } 199 200 @Override 201 public Class<FloatEquivalentDose> getScalarClass() 202 { 203 return FloatEquivalentDose.class; 204 } 205 206 @Override 207 public Class<FloatEquivalentDoseVector> getVectorClass() 208 { 209 return FloatEquivalentDoseVector.class; 210 } 211 212 @Override 213 public FloatEquivalentDoseMatrix instantiateMatrix(final FloatMatrixData fmd, final EquivalentDoseUnit displayUnit) 214 { 215 return new FloatEquivalentDoseMatrix(fmd, displayUnit); 216 } 217 218 @Override 219 public FloatEquivalentDoseVector instantiateVector(final FloatVectorData fvd, final EquivalentDoseUnit displayUnit) 220 { 221 return new FloatEquivalentDoseVector(fvd, displayUnit); 222 } 223 224 @Override 225 public FloatEquivalentDose instantiateScalarSI(final float valueSI, final EquivalentDoseUnit displayUnit) 226 { 227 FloatEquivalentDose result = FloatEquivalentDose.instantiateSI(valueSI); 228 result.setDisplayUnit(displayUnit); 229 return result; 230 } 231 232 }