1 package org.djunits.value.vfloat.vector;
2
3 import java.util.List;
4 import java.util.SortedMap;
5
6 import org.djunits.unit.AbsoluteLinearUnit;
7 import org.djunits.unit.Unit;
8 import org.djunits.value.StorageType;
9 import org.djunits.value.ValueException;
10 import org.djunits.value.vfloat.scalar.FloatScalar;
11
12 /**
13 * Immutable FloatVector.
14 * <p>
15 * Copyright (c) 2015-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
16 * BSD-style license. See <a href="http://djunits.org/docs/license.html">DJUNITS License</a>.
17 * <p>
18 * $LastChangedDate: 2019-01-18 00:35:01 +0100 (Fri, 18 Jan 2019) $, @version $Revision: 324 $, by $Author: averbraeck $,
19 * initial version 30 Oct, 2015 <br>
20 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
21 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
22 */
23 public abstract class FloatVector
24 {
25 /**
26 * Absolute Immutable FloatVector.
27 * @param <AU> Absolute unit
28 * @param <RU> Relative unit
29 */
30 public static class Abs<AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>> extends AbstractFloatVectorAbs<AU, RU,
31 FloatVector.Abs<AU, RU>, FloatVector.Rel<RU>, MutableFloatVector.Abs<AU, RU>, FloatScalar.Abs<AU, RU>>
32 {
33 /** */
34 private static final long serialVersionUID = 20150626L;
35
36 /**
37 * Construct a new Absolute Mutable FloatVector.
38 * @param values float[]; the values of the entries in the new Absolute Mutable FloatVector
39 * @param unit AU; the unit of the new Absolute Mutable FloatVector
40 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
41 * @throws ValueException when values is null
42 */
43 public Abs(final float[] values, final AU unit, final StorageType storageType) throws ValueException
44 {
45 super(values, unit, storageType);
46 }
47
48 /**
49 * Construct a new Absolute Mutable FloatVector.
50 * @param values List<Float>; the values of the entries in the new Absolute Mutable FloatVector
51 * @param unit AU; the unit of the new Absolute Mutable FloatVector
52 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
53 * @throws ValueException when values is null
54 */
55 public Abs(final List<Float> values, final AU unit, final StorageType storageType) throws ValueException
56 {
57 super(values, unit, storageType);
58 }
59
60 /**
61 * Construct a new Absolute Mutable FloatVector.
62 * @param values FloatScalar.Abs<AU, RU>[]; the values of the entries in the new Absolute Mutable FloatVector
63 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
64 * @throws ValueException when values has zero entries
65 */
66 public Abs(final FloatScalar.Abs<AU, RU>[] values, final StorageType storageType) throws ValueException
67 {
68 super(values, storageType);
69 }
70
71 /**
72 * Construct a new Absolute Mutable FloatVector.
73 * @param values List<FloatScalar.Abs<AU, RU>>; the values of the entries in the new Absolute Mutable
74 * FloatVector
75 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
76 * @throws ValueException when values has zero entries
77 */
78 public Abs(final List<FloatScalar.Abs<AU, RU>> values, final StorageType storageType) throws ValueException
79 {
80 super(values, storageType);
81 }
82
83 /**
84 * Construct a new Absolute Mutable FloatVector.
85 * @param values SortedMap<Integer, FloatScalar.Abs<AU, RU>>; the values of the entries in the new Absolute
86 * Sparse Mutable FloatVector
87 * @param length int; the size of the vector
88 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
89 * @throws ValueException when values has zero entries
90 */
91 public Abs(final SortedMap<Integer, FloatScalar.Abs<AU, RU>> values, final int length, final StorageType storageType)
92 throws ValueException
93 {
94 super(values, length, storageType);
95 }
96
97 /**
98 * Construct a new Absolute Mutable FloatVector.
99 * @param values SortedMap<Integer, Float>; the map of indexes to values of the Absolute Sparse Mutable
100 * FloatVector
101 * @param unit AU; the unit of the new Absolute Sparse Mutable FloatVector
102 * @param length int; the size of the vector
103 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
104 * @throws ValueException when values is null
105 */
106 public Abs(final SortedMap<Integer, Float> values, final AU unit, final int length, final StorageType storageType)
107 throws ValueException
108 {
109 super(values, unit, length, storageType);
110 }
111
112 /**
113 * Construct a new Absolute Mutable FloatVector.
114 * @param data FloatVectorData; an internal data object
115 * @param unit AU; the unit
116 */
117 public Abs(final FloatVectorData data, final AU unit)
118 {
119 super(data, unit);
120 }
121
122 /** {@inheritDoc} */
123 @Override
124 protected final FloatVector.Abs<AU, RU> instantiateTypeAbs(final FloatVectorData dvd, final AU unit)
125 {
126 return new FloatVector.Abs<AU, RU>(dvd, unit);
127 }
128
129 /** {@inheritDoc} */
130 @Override
131 protected final FloatVector.Rel<RU> instantiateTypeRel(final FloatVectorData dvd, final RU unit)
132 {
133 return new FloatVector.Rel<RU>(dvd, unit);
134 }
135
136 /** {@inheritDoc} */
137 @Override
138 protected final MutableFloatVector.Abs<AU, RU> instantiateMutableType(final FloatVectorData dvd, final AU unit)
139 {
140 return new MutableFloatVector.Abs<AU, RU>(dvd, unit);
141 }
142
143 /** {@inheritDoc} */
144 @Override
145 protected final FloatScalar.Abs<AU, RU> instantiateScalar(final float value, final AU unit)
146 {
147 return new FloatScalar.Abs<AU, RU>(value, unit);
148 }
149
150 /** {@inheritDoc} */
151 @Override
152 public final FloatVector.Abs<AU, RU> toDense()
153 {
154 return this.data.isDense() ? (FloatVector.Abs<AU, RU>) this : instantiateTypeAbs(this.data.toDense(), getUnit());
155 }
156
157 /** {@inheritDoc} */
158 @Override
159 public final FloatVector.Abs<AU, RU> toSparse()
160 {
161 return this.data.isSparse() ? (FloatVector.Abs<AU, RU>) this : instantiateTypeAbs(this.data.toSparse(), getUnit());
162 }
163
164 }
165
166 /**
167 * Relative Immutable FloatVector.
168 * @param <U> Unit
169 */
170 public static class Rel<U extends Unit<U>>
171 extends AbstractFloatVectorRel<U, FloatVector.Rel<U>, MutableFloatVector.Rel<U>, FloatScalar.Rel<U>>
172 {
173 /** */
174 private static final long serialVersionUID = 20150626L;
175
176 /**
177 * Construct a new Relative Mutable FloatVector.
178 * @param values float[]; the values of the entries in the new Relative Mutable FloatVector
179 * @param unit U; the unit of the new Relative Mutable FloatVector
180 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
181 * @throws ValueException when values is null
182 */
183 public Rel(final float[] values, final U unit, final StorageType storageType) throws ValueException
184 {
185 super(values, unit, storageType);
186 }
187
188 /**
189 * Construct a new Relative Mutable FloatVector.
190 * @param values List<Float>; the values of the entries in the new Relative Mutable FloatVector
191 * @param unit U; the unit of the new Relative Mutable FloatVector
192 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
193 * @throws ValueException when values is null
194 */
195 public Rel(final List<Float> values, final U unit, final StorageType storageType) throws ValueException
196 {
197 super(values, unit, storageType);
198 }
199
200 /**
201 * Construct a new Relative Mutable FloatVector.
202 * @param values FloatScalar.Rel<U>[]; the values of the entries in the new Relative Mutable FloatVector
203 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
204 * @throws ValueException when values has zero entries
205 */
206 public Rel(final FloatScalar.Rel<U>[] values, final StorageType storageType) throws ValueException
207 {
208 super(values, storageType);
209 }
210
211 /**
212 * Construct a new Relative Mutable FloatVector.
213 * @param values List<FloatScalar.Rel<U>>; the values of the entries in the new Relative Mutable FloatVector
214 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
215 * @throws ValueException when values has zero entries
216 */
217 public Rel(final List<FloatScalar.Rel<U>> values, final StorageType storageType) throws ValueException
218 {
219 super(values, storageType);
220 }
221
222 /**
223 * Construct a new Relative Mutable FloatVector.
224 * @param values SortedMap<Integer, FloatScalar.Rel<U>>; the values of the entries in the new Relative
225 * Sparse Mutable FloatVector
226 * @param length int; the size of the vector
227 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
228 * @throws ValueException when values has zero entries
229 */
230 public Rel(final SortedMap<Integer, FloatScalar.Rel<U>> values, final int length, final StorageType storageType)
231 throws ValueException
232 {
233 super(values, length, storageType);
234 }
235
236 /**
237 * Construct a new Relative Mutable FloatVector.
238 * @param values SortedMap<Integer, Float>; the map of indexes to values of the Relative Sparse Mutable
239 * FloatVector
240 * @param unit U; the unit of the new Relative Sparse Mutable FloatVector
241 * @param length int; the size of the vector
242 * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
243 * @throws ValueException when values is null
244 */
245 public Rel(final SortedMap<Integer, Float> values, final U unit, final int length, final StorageType storageType)
246 throws ValueException
247 {
248 super(values, unit, length, storageType);
249 }
250
251 /**
252 * Construct a new Relative Mutable FloatVector.
253 * @param data FloatVectorData; an internal data object
254 * @param unit U; the unit
255 */
256 public Rel(final FloatVectorData data, final U unit)
257 {
258 super(data, unit);
259 }
260
261 /** {@inheritDoc} */
262 @Override
263 protected final FloatVector.Rel<U> instantiateType(final FloatVectorData dvd, final U unit)
264 {
265 return new FloatVector.Rel<U>(dvd, unit);
266 }
267
268 /** {@inheritDoc} */
269 @Override
270 protected final MutableFloatVector.Rel<U> instantiateMutableType(final FloatVectorData dvd, final U unit)
271 {
272 return new MutableFloatVector.Rel<U>(dvd, unit);
273 }
274
275 /** {@inheritDoc} */
276 @Override
277 protected final FloatScalar.Rel<U> instantiateScalar(final float value, final U unit)
278 {
279 return new FloatScalar.Rel<U>(value, unit);
280 }
281
282 /** {@inheritDoc} */
283 @Override
284 public final FloatVector.Rel<U> toDense()
285 {
286 return this.data.isDense() ? (FloatVector.Rel<U>) this : instantiateType(this.data.toDense(), getUnit());
287 }
288
289 /** {@inheritDoc} */
290 @Override
291 public final FloatVector.Rel<U> toSparse()
292 {
293 return this.data.isSparse() ? (FloatVector.Rel<U>) this : instantiateType(this.data.toSparse(), getUnit());
294 }
295
296 }
297 }