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
14
15
16
17
18
19
20
21
22
23 public abstract class FloatVector
24 {
25
26
27
28
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
38
39
40
41
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
50
51
52
53
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
62
63
64
65
66 public Abs(final FloatScalar.Abs<AU, RU>[] values, final StorageType storageType) throws ValueException
67 {
68 super(values, storageType);
69 }
70
71
72
73
74
75
76
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
85
86
87
88
89
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
99
100
101
102
103
104
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
114
115
116
117 public Abs(final FloatVectorData data, final AU unit)
118 {
119 super(data, unit);
120 }
121
122
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
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
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
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
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
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
168
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
178
179
180
181
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
190
191
192
193
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
202
203
204
205
206 public Rel(final FloatScalar.Rel<U>[] values, final StorageType storageType) throws ValueException
207 {
208 super(values, storageType);
209 }
210
211
212
213
214
215
216
217 public Rel(final List<FloatScalar.Rel<U>> values, final StorageType storageType) throws ValueException
218 {
219 super(values, storageType);
220 }
221
222
223
224
225
226
227
228
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
238
239
240
241
242
243
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
253
254
255
256 public Rel(final FloatVectorData data, final U unit)
257 {
258 super(data, unit);
259 }
260
261
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
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
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
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
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 }