View Javadoc
1   package org.djunits.value.vdouble.vector;
2   
3   import java.util.List;
4   import java.util.SortedMap;
5   
6   import javax.annotation.Generated;
7   
8   import org.djunits.Throw;
9   import org.djunits.unit.AbsorbedDoseUnit;
10  import org.djunits.unit.AccelerationUnit;
11  import org.djunits.unit.AmountOfSubstanceUnit;
12  import org.djunits.unit.AngleUnit;
13  import org.djunits.unit.AngularAccelerationUnit;
14  import org.djunits.unit.AngularVelocityUnit;
15  import org.djunits.unit.AreaUnit;
16  import org.djunits.unit.CatalyticActivityUnit;
17  import org.djunits.unit.DensityUnit;
18  import org.djunits.unit.DimensionlessUnit;
19  import org.djunits.unit.DurationUnit;
20  import org.djunits.unit.ElectricalCapacitanceUnit;
21  import org.djunits.unit.ElectricalChargeUnit;
22  import org.djunits.unit.ElectricalConductanceUnit;
23  import org.djunits.unit.ElectricalCurrentUnit;
24  import org.djunits.unit.ElectricalInductanceUnit;
25  import org.djunits.unit.ElectricalPotentialUnit;
26  import org.djunits.unit.ElectricalResistanceUnit;
27  import org.djunits.unit.EnergyUnit;
28  import org.djunits.unit.EquivalentDoseUnit;
29  import org.djunits.unit.FlowMassUnit;
30  import org.djunits.unit.FlowVolumeUnit;
31  import org.djunits.unit.ForceUnit;
32  import org.djunits.unit.FrequencyUnit;
33  import org.djunits.unit.IlluminanceUnit;
34  import org.djunits.unit.LengthUnit;
35  import org.djunits.unit.LinearDensityUnit;
36  import org.djunits.unit.LuminousFluxUnit;
37  import org.djunits.unit.LuminousIntensityUnit;
38  import org.djunits.unit.MagneticFluxDensityUnit;
39  import org.djunits.unit.MagneticFluxUnit;
40  import org.djunits.unit.MassUnit;
41  import org.djunits.unit.MomentumUnit;
42  import org.djunits.unit.PowerUnit;
43  import org.djunits.unit.PressureUnit;
44  import org.djunits.unit.RadioActivityUnit;
45  import org.djunits.unit.SIUnit;
46  import org.djunits.unit.SolidAngleUnit;
47  import org.djunits.unit.SpeedUnit;
48  import org.djunits.unit.TemperatureUnit;
49  import org.djunits.unit.TorqueUnit;
50  import org.djunits.unit.Unit;
51  import org.djunits.unit.VolumeUnit;
52  import org.djunits.unit.si.SIDimensions;
53  import org.djunits.unit.util.UnitRuntimeException;
54  import org.djunits.value.ValueRuntimeException;
55  import org.djunits.value.storage.StorageType;
56  import org.djunits.value.vdouble.scalar.SIScalar;
57  import org.djunits.value.vdouble.scalar.base.AbstractDoubleScalarRel;
58  import org.djunits.value.vdouble.vector.base.AbstractDoubleVectorRel;
59  import org.djunits.value.vdouble.vector.base.DoubleVector;
60  import org.djunits.value.vdouble.vector.data.DoubleVectorData;
61  
62  /**
63   * Easy access methods for the generic Relative SI DoubleVector.
64   * <p>
65   * Copyright (c) 2013-2020 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. <br>
66   * All rights reserved. <br>
67   * BSD-style license. See <a href="https://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
68   * </p>
69   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
70   * @author <a href="https://www.tudelft.nl/staff/p.knoppers/">Peter Knoppers</a>
71   */
72  @Generated(value = "org.djunits.generator.GenerateDJUNIT", date = "2020-01-19T15:21:24.964166400Z")
73  public class SIVector extends AbstractDoubleVectorRel<SIUnit, SIScalar, SIVector>
74  {
75      /** */
76      private static final long serialVersionUID = 20150901L;
77  
78      /**
79       * Construct a new Relative Double SIVector.
80       * @param values double[]; the values of the entries in the new Relative Double SIVector
81       * @param unit SIUnit; the unit of the new Relative Double SIVector
82       * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
83       * @return SIVector; the SIVector of the given unit
84       * @throws ValueRuntimeException when values is null
85       */
86      public static SIVector instantiate(final double[] values, final SIUnit unit, final StorageType storageType)
87              throws ValueRuntimeException
88      {
89          return new SIVector(DoubleVectorData.instantiate(values, unit.getScale(), storageType), unit);
90      }
91  
92      /**
93       * Construct a new Relative Double SIVector.
94       * @param values List&lt;Double&gt;; the values of the entries in the new Relative Double SIVector
95       * @param unit SIUnit; the unit of the new Relative Double SIVector
96       * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
97       * @return SIVector; the SIVector of the given unit
98       * @throws ValueRuntimeException when values is null
99       */
100     public static SIVector instantiate(final List<Double> values, final SIUnit unit, final StorageType storageType)
101             throws ValueRuntimeException
102     {
103         return new SIVector(DoubleVectorData.instantiate(values, unit.getScale(), storageType), unit);
104     }
105 
106     /**
107      * Construct a new Relative Double SIVector.
108      * @param values SortedMap&lt;Integer, Double&gt;; the map of indexes to values of the Relative Sparse Double SIVector
109      * @param length int; the size of the vector
110      * @param unit SIUnit; the unit of the new Relative Sparse Double SIVector
111      * @param storageType StorageType; the data type to use (e.g., DENSE or SPARSE)
112      * @return SIVector; the SIVector of the given unit
113      * @throws ValueRuntimeException when values is null
114      */
115     public static SIVector instantiate(final SortedMap<Integer, Double> values, final int length, final SIUnit unit,
116             final StorageType storageType) throws ValueRuntimeException
117     {
118         return new SIVector(DoubleVectorData.instantiate(values, length, unit.getScale(), storageType), unit);
119     }
120 
121     /**
122      * @param data DoubleVectorData; an internal data object
123      * @param unit SIUnit; the unit
124      */
125     public SIVector(final DoubleVectorData data, final SIUnit unit)
126     {
127         super(data, unit);
128     }
129 
130     /** {@inheritDoc} */
131     @Override
132     public Class<SIScalar> getScalarClass()
133     {
134         return SIScalar.class;
135     }
136 
137     /**
138      * Returns an SIVector based on an array of values and the textual representation of the unit.
139      * @param value double[]; the values to use
140      * @param unitString String; the textual representation of the unit
141      * @param storageType StorageType; the storage type to use
142      * @return SIVector; the vector representation of the values in their unit
143      * @throws IllegalArgumentException when the unit cannot be parsed or is incorrect
144      * @throws NullPointerException when the unitString argument is null
145      */
146     public static SIVector of(final double[] value, final String unitString, final StorageType storageType)
147     {
148         Throw.whenNull(value, "Error parsing SIVector: value is null");
149         Throw.whenNull(unitString, "Error parsing SIVector: unitString is null");
150         Throw.when(unitString.length() == 0, IllegalArgumentException.class, "Error parsing SIVector: empty unitString");
151         Throw.whenNull(storageType, "Error parsing SIVector: storageType is null");
152         try
153         {
154             SIUnit unit = Unit.lookupOrCreateUnitWithSIDimensions(SIDimensions.of(unitString));
155             if (unit != null)
156             {
157                 return SIVector.instantiate(value, unit, storageType);
158             }
159         }
160         catch (Exception exception)
161         {
162             throw new IllegalArgumentException("Error parsing SIUnit from " + unitString, exception);
163         }
164         throw new IllegalArgumentException("Error parsing SIVector with unit " + unitString);
165     }
166 
167     /**
168      * Returns an SIVector based on an array of values and the textual representation of the unit.
169      * @param valueList List&lt;Double&gt;; the values to use
170      * @param unitString String; the textual representation of the unit
171      * @param storageType StorageType; the storage type to use
172      * @return SIVector; the vector representation of the values in their unit
173      * @throws IllegalArgumentException when the unit cannot be parsed or is incorrect
174      * @throws NullPointerException when the unitString argument is null
175      */
176     public static SIVector of(final List<Double> valueList, final String unitString, final StorageType storageType)
177     {
178         Throw.whenNull(valueList, "Error parsing SIVector: valueList is null");
179         Throw.whenNull(unitString, "Error parsing SIVector: unitString is null");
180         Throw.when(unitString.length() == 0, IllegalArgumentException.class, "Error parsing SIVector: empty unitString");
181         Throw.whenNull(storageType, "Error parsing SIVector: storageType is null");
182         try
183         {
184             SIUnit unit = Unit.lookupOrCreateUnitWithSIDimensions(SIDimensions.of(unitString));
185             if (unit != null)
186             {
187                 return SIVector.instantiate(valueList, unit, storageType);
188             }
189         }
190         catch (Exception exception)
191         {
192             throw new IllegalArgumentException("Error parsing SIUnit from " + unitString, exception);
193         }
194         throw new IllegalArgumentException("Error parsing SIVector with unit " + unitString);
195     }
196 
197     /**
198      * Returns an SIVector based on a (sparse) map of values and the textual representation of the unit.
199      * @param valueMap SortedMap&lt;Integer, Double&gt;; the values to use
200      * @param unitString String; the textual representation of the unit
201      * @param length int; the size of the vector
202      * @param storageType StorageType; the storage type to use
203      * @return SIVector; the vector representation of the values in their unit
204      * @throws IllegalArgumentException when the unit cannot be parsed or is incorrect
205      * @throws NullPointerException when the unitString argument is null
206      */
207     public static SIVector of(final SortedMap<Integer, Double> valueMap, final String unitString, final int length,
208             final StorageType storageType)
209     {
210         Throw.whenNull(valueMap, "Error parsing SIVector: valueMap is null");
211         Throw.whenNull(unitString, "Error parsing SIVector: unitString is null");
212         Throw.when(unitString.length() == 0, IllegalArgumentException.class, "Error parsing SIVector: empty unitString");
213         Throw.whenNull(storageType, "Error parsing SIVector: storageType is null");
214         try
215         {
216             SIUnit unit = Unit.lookupOrCreateUnitWithSIDimensions(SIDimensions.of(unitString));
217             if (unit != null)
218             {
219                 return SIVector.instantiate(valueMap, length, unit, storageType);
220             }
221         }
222         catch (Exception exception)
223         {
224             throw new IllegalArgumentException("Error parsing SIUnit from " + unitString, exception);
225         }
226         throw new IllegalArgumentException("Error parsing SIVector with unit " + unitString);
227     }
228 
229     /** {@inheritDoc} */
230     @Override
231     public SIVector instantiateVector(final DoubleVectorData dvd, final SIUnit unit)
232     {
233         return new SIVector(dvd, unit);
234     }
235 
236     /** {@inheritDoc} */
237     @Override
238     public SIScalar instantiateScalarSI(final double valueSI, final SIUnit unit)
239     {
240         return new SIScalar(valueSI, unit);
241     }
242 
243     /**********************************************************************************/
244     /******************************** 'CAST AS' METHODS *******************************/
245     /**********************************************************************************/
246 
247     /**
248      * Return the current vector transformed to a vector in the given unit. Of course the SI dimensionality has to match,
249      * otherwise the vector cannot be transformed. The compiler will check the alignment between the return value and the unit.
250      * @param displayUnit KU; the unit in which the vector needs to be expressed
251      * @return V; the vector that has been transformed into the right vector type and unit
252      * @param <U> the unit type
253      * @param <S> the scalar type
254      * @param <V> the vector type
255      */
256     public final <U extends Unit<U>, S extends AbstractDoubleScalarRel<U, S>,
257             V extends AbstractDoubleVectorRel<U, S, V>> V as(final U displayUnit)
258     {
259         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(displayUnit.getQuantity().getSiDimensions())),
260                 UnitRuntimeException.class, "SIVector with unit %s cannot be converted to a vector with unit %s",
261                 getDisplayUnit(), displayUnit);
262         V result = DoubleVector.instantiate(this.data, displayUnit.getStandardUnit());
263         result.setDisplayUnit(displayUnit);
264         return result;
265     }
266 
267     /**
268      * Return the current vector as a absorbeddose vector.
269      * @return AbsorbedDoseVector; the current vector as a absorbeddose vector
270      */
271     public final AbsorbedDoseVector asAbsorbedDose()
272     {
273         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AbsorbedDoseUnit.BASE.getSiDimensions())),
274                 UnitRuntimeException.class, "cannot cast %s to AbsorbedDoseVector", this.toString());
275         return new AbsorbedDoseVector(this.data, AbsorbedDoseUnit.SI);
276     }
277 
278     /**
279      * Return the current vector as a absorbeddose vector, and provide a display unit.
280      * @param displayUnit the unit in which the value will be displayed
281      * @return AbsorbedDoseVector; the current vector as a absorbeddose vector
282      */
283     public final AbsorbedDoseVector asAbsorbedDose(final AbsorbedDoseUnit displayUnit)
284     {
285         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AbsorbedDoseUnit.BASE.getSiDimensions())),
286                 UnitRuntimeException.class, "cannot cast %s to AbsorbedDoseVector", this.toString());
287         AbsorbedDoseVectorrbedDoseVector.html#AbsorbedDoseVector">AbsorbedDoseVector result = new AbsorbedDoseVector(this.data, displayUnit.getStandardUnit());
288         result.setDisplayUnit(displayUnit);
289         return result;
290     }
291 
292     /**
293      * Return the current vector as a acceleration vector.
294      * @return AccelerationVector; the current vector as a acceleration vector
295      */
296     public final AccelerationVector asAcceleration()
297     {
298         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AccelerationUnit.BASE.getSiDimensions())),
299                 UnitRuntimeException.class, "cannot cast %s to AccelerationVector", this.toString());
300         return new AccelerationVector(this.data, AccelerationUnit.SI);
301     }
302 
303     /**
304      * Return the current vector as a acceleration vector, and provide a display unit.
305      * @param displayUnit the unit in which the value will be displayed
306      * @return AccelerationVector; the current vector as a acceleration vector
307      */
308     public final AccelerationVector asAcceleration(final AccelerationUnit displayUnit)
309     {
310         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AccelerationUnit.BASE.getSiDimensions())),
311                 UnitRuntimeException.class, "cannot cast %s to AccelerationVector", this.toString());
312         AccelerationVectorlerationVector.html#AccelerationVector">AccelerationVector result = new AccelerationVector(this.data, displayUnit.getStandardUnit());
313         result.setDisplayUnit(displayUnit);
314         return result;
315     }
316 
317     /**
318      * Return the current vector as a amountofsubstance vector.
319      * @return AmountOfSubstanceVector; the current vector as a amountofsubstance vector
320      */
321     public final AmountOfSubstanceVector asAmountOfSubstance()
322     {
323         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AmountOfSubstanceUnit.BASE.getSiDimensions())),
324                 UnitRuntimeException.class, "cannot cast %s to AmountOfSubstanceVector", this.toString());
325         return new AmountOfSubstanceVector(this.data, AmountOfSubstanceUnit.SI);
326     }
327 
328     /**
329      * Return the current vector as a amountofsubstance vector, and provide a display unit.
330      * @param displayUnit the unit in which the value will be displayed
331      * @return AmountOfSubstanceVector; the current vector as a amountofsubstance vector
332      */
333     public final AmountOfSubstanceVector asAmountOfSubstance(final AmountOfSubstanceUnit displayUnit)
334     {
335         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AmountOfSubstanceUnit.BASE.getSiDimensions())),
336                 UnitRuntimeException.class, "cannot cast %s to AmountOfSubstanceVector", this.toString());
337         AmountOfSubstanceVectorubstanceVector.html#AmountOfSubstanceVector">AmountOfSubstanceVector result = new AmountOfSubstanceVector(this.data, displayUnit.getStandardUnit());
338         result.setDisplayUnit(displayUnit);
339         return result;
340     }
341 
342     /**
343      * Return the current vector as a angularacceleration vector.
344      * @return AngularAccelerationVector; the current vector as a angularacceleration vector
345      */
346     public final AngularAccelerationVector asAngularAcceleration()
347     {
348         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngularAccelerationUnit.BASE.getSiDimensions())),
349                 UnitRuntimeException.class, "cannot cast %s to AngularAccelerationVector", this.toString());
350         return new AngularAccelerationVector(this.data, AngularAccelerationUnit.SI);
351     }
352 
353     /**
354      * Return the current vector as a angularacceleration vector, and provide a display unit.
355      * @param displayUnit the unit in which the value will be displayed
356      * @return AngularAccelerationVector; the current vector as a angularacceleration vector
357      */
358     public final AngularAccelerationVector asAngularAcceleration(final AngularAccelerationUnit displayUnit)
359     {
360         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngularAccelerationUnit.BASE.getSiDimensions())),
361                 UnitRuntimeException.class, "cannot cast %s to AngularAccelerationVector", this.toString());
362         AngularAccelerationVectorlerationVector.html#AngularAccelerationVector">AngularAccelerationVector result = new AngularAccelerationVector(this.data, displayUnit.getStandardUnit());
363         result.setDisplayUnit(displayUnit);
364         return result;
365     }
366 
367     /**
368      * Return the current vector as a angularvelocity vector.
369      * @return AngularVelocityVector; the current vector as a angularvelocity vector
370      */
371     public final AngularVelocityVector asAngularVelocity()
372     {
373         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngularVelocityUnit.BASE.getSiDimensions())),
374                 UnitRuntimeException.class, "cannot cast %s to AngularVelocityVector", this.toString());
375         return new AngularVelocityVector(this.data, AngularVelocityUnit.SI);
376     }
377 
378     /**
379      * Return the current vector as a angularvelocity vector, and provide a display unit.
380      * @param displayUnit the unit in which the value will be displayed
381      * @return AngularVelocityVector; the current vector as a angularvelocity vector
382      */
383     public final AngularVelocityVector asAngularVelocity(final AngularVelocityUnit displayUnit)
384     {
385         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngularVelocityUnit.BASE.getSiDimensions())),
386                 UnitRuntimeException.class, "cannot cast %s to AngularVelocityVector", this.toString());
387         AngularVelocityVectorVelocityVector.html#AngularVelocityVector">AngularVelocityVector result = new AngularVelocityVector(this.data, displayUnit.getStandardUnit());
388         result.setDisplayUnit(displayUnit);
389         return result;
390     }
391 
392     /**
393      * Return the current vector as a area vector.
394      * @return AreaVector; the current vector as a area vector
395      */
396     public final AreaVector asArea()
397     {
398         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AreaUnit.BASE.getSiDimensions())),
399                 UnitRuntimeException.class, "cannot cast %s to AreaVector", this.toString());
400         return new AreaVector(this.data, AreaUnit.SI);
401     }
402 
403     /**
404      * Return the current vector as a area vector, and provide a display unit.
405      * @param displayUnit the unit in which the value will be displayed
406      * @return AreaVector; the current vector as a area vector
407      */
408     public final AreaVector asArea(final AreaUnit displayUnit)
409     {
410         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AreaUnit.BASE.getSiDimensions())),
411                 UnitRuntimeException.class, "cannot cast %s to AreaVector", this.toString());
412         AreaVectortor/AreaVector.html#AreaVector">AreaVector result = new AreaVector(this.data, displayUnit.getStandardUnit());
413         result.setDisplayUnit(displayUnit);
414         return result;
415     }
416 
417     /**
418      * Return the current vector as a catalyticactivity vector.
419      * @return CatalyticActivityVector; the current vector as a catalyticactivity vector
420      */
421     public final CatalyticActivityVector asCatalyticActivity()
422     {
423         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(CatalyticActivityUnit.BASE.getSiDimensions())),
424                 UnitRuntimeException.class, "cannot cast %s to CatalyticActivityVector", this.toString());
425         return new CatalyticActivityVector(this.data, CatalyticActivityUnit.SI);
426     }
427 
428     /**
429      * Return the current vector as a catalyticactivity vector, and provide a display unit.
430      * @param displayUnit the unit in which the value will be displayed
431      * @return CatalyticActivityVector; the current vector as a catalyticactivity vector
432      */
433     public final CatalyticActivityVector asCatalyticActivity(final CatalyticActivityUnit displayUnit)
434     {
435         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(CatalyticActivityUnit.BASE.getSiDimensions())),
436                 UnitRuntimeException.class, "cannot cast %s to CatalyticActivityVector", this.toString());
437         CatalyticActivityVectorActivityVector.html#CatalyticActivityVector">CatalyticActivityVector result = new CatalyticActivityVector(this.data, displayUnit.getStandardUnit());
438         result.setDisplayUnit(displayUnit);
439         return result;
440     }
441 
442     /**
443      * Return the current vector as a density vector.
444      * @return DensityVector; the current vector as a density vector
445      */
446     public final DensityVector asDensity()
447     {
448         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DensityUnit.BASE.getSiDimensions())),
449                 UnitRuntimeException.class, "cannot cast %s to DensityVector", this.toString());
450         return new DensityVector(this.data, DensityUnit.SI);
451     }
452 
453     /**
454      * Return the current vector as a density vector, and provide a display unit.
455      * @param displayUnit the unit in which the value will be displayed
456      * @return DensityVector; the current vector as a density vector
457      */
458     public final DensityVector asDensity(final DensityUnit displayUnit)
459     {
460         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DensityUnit.BASE.getSiDimensions())),
461                 UnitRuntimeException.class, "cannot cast %s to DensityVector", this.toString());
462         DensityVector/DensityVector.html#DensityVector">DensityVector result = new DensityVector(this.data, displayUnit.getStandardUnit());
463         result.setDisplayUnit(displayUnit);
464         return result;
465     }
466 
467     /**
468      * Return the current vector as a dimensionless vector.
469      * @return DimensionlessVector; the current vector as a dimensionless vector
470      */
471     public final DimensionlessVector asDimensionless()
472     {
473         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DimensionlessUnit.BASE.getSiDimensions())),
474                 UnitRuntimeException.class, "cannot cast %s to DimensionlessVector", this.toString());
475         return new DimensionlessVector(this.data, DimensionlessUnit.SI);
476     }
477 
478     /**
479      * Return the current vector as a dimensionless vector, and provide a display unit.
480      * @param displayUnit the unit in which the value will be displayed
481      * @return DimensionlessVector; the current vector as a dimensionless vector
482      */
483     public final DimensionlessVector asDimensionless(final DimensionlessUnit displayUnit)
484     {
485         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DimensionlessUnit.BASE.getSiDimensions())),
486                 UnitRuntimeException.class, "cannot cast %s to DimensionlessVector", this.toString());
487         DimensionlessVectorsionlessVector.html#DimensionlessVector">DimensionlessVector result = new DimensionlessVector(this.data, displayUnit.getStandardUnit());
488         result.setDisplayUnit(displayUnit);
489         return result;
490     }
491 
492     /**
493      * Return the current vector as a electricalcapacitance vector.
494      * @return ElectricalCapacitanceVector; the current vector as a electricalcapacitance vector
495      */
496     public final ElectricalCapacitanceVector asElectricalCapacitance()
497     {
498         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalCapacitanceUnit.BASE.getSiDimensions())),
499                 UnitRuntimeException.class, "cannot cast %s to ElectricalCapacitanceVector", this.toString());
500         return new ElectricalCapacitanceVector(this.data, ElectricalCapacitanceUnit.SI);
501     }
502 
503     /**
504      * Return the current vector as a electricalcapacitance vector, and provide a display unit.
505      * @param displayUnit the unit in which the value will be displayed
506      * @return ElectricalCapacitanceVector; the current vector as a electricalcapacitance vector
507      */
508     public final ElectricalCapacitanceVector asElectricalCapacitance(final ElectricalCapacitanceUnit displayUnit)
509     {
510         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalCapacitanceUnit.BASE.getSiDimensions())),
511                 UnitRuntimeException.class, "cannot cast %s to ElectricalCapacitanceVector", this.toString());
512         ElectricalCapacitanceVectoracitanceVector.html#ElectricalCapacitanceVector">ElectricalCapacitanceVector result = new ElectricalCapacitanceVector(this.data, displayUnit.getStandardUnit());
513         result.setDisplayUnit(displayUnit);
514         return result;
515     }
516 
517     /**
518      * Return the current vector as a electricalcharge vector.
519      * @return ElectricalChargeVector; the current vector as a electricalcharge vector
520      */
521     public final ElectricalChargeVector asElectricalCharge()
522     {
523         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalChargeUnit.BASE.getSiDimensions())),
524                 UnitRuntimeException.class, "cannot cast %s to ElectricalChargeVector", this.toString());
525         return new ElectricalChargeVector(this.data, ElectricalChargeUnit.SI);
526     }
527 
528     /**
529      * Return the current vector as a electricalcharge vector, and provide a display unit.
530      * @param displayUnit the unit in which the value will be displayed
531      * @return ElectricalChargeVector; the current vector as a electricalcharge vector
532      */
533     public final ElectricalChargeVector asElectricalCharge(final ElectricalChargeUnit displayUnit)
534     {
535         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalChargeUnit.BASE.getSiDimensions())),
536                 UnitRuntimeException.class, "cannot cast %s to ElectricalChargeVector", this.toString());
537         ElectricalChargeVectoralChargeVector.html#ElectricalChargeVector">ElectricalChargeVector result = new ElectricalChargeVector(this.data, displayUnit.getStandardUnit());
538         result.setDisplayUnit(displayUnit);
539         return result;
540     }
541 
542     /**
543      * Return the current vector as a electricalconductance vector.
544      * @return ElectricalConductanceVector; the current vector as a electricalconductance vector
545      */
546     public final ElectricalConductanceVector asElectricalConductance()
547     {
548         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalConductanceUnit.BASE.getSiDimensions())),
549                 UnitRuntimeException.class, "cannot cast %s to ElectricalConductanceVector", this.toString());
550         return new ElectricalConductanceVector(this.data, ElectricalConductanceUnit.SI);
551     }
552 
553     /**
554      * Return the current vector as a electricalconductance vector, and provide a display unit.
555      * @param displayUnit the unit in which the value will be displayed
556      * @return ElectricalConductanceVector; the current vector as a electricalconductance vector
557      */
558     public final ElectricalConductanceVector asElectricalConductance(final ElectricalConductanceUnit displayUnit)
559     {
560         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalConductanceUnit.BASE.getSiDimensions())),
561                 UnitRuntimeException.class, "cannot cast %s to ElectricalConductanceVector", this.toString());
562         ElectricalConductanceVectorductanceVector.html#ElectricalConductanceVector">ElectricalConductanceVector result = new ElectricalConductanceVector(this.data, displayUnit.getStandardUnit());
563         result.setDisplayUnit(displayUnit);
564         return result;
565     }
566 
567     /**
568      * Return the current vector as a electricalcurrent vector.
569      * @return ElectricalCurrentVector; the current vector as a electricalcurrent vector
570      */
571     public final ElectricalCurrentVector asElectricalCurrent()
572     {
573         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalCurrentUnit.BASE.getSiDimensions())),
574                 UnitRuntimeException.class, "cannot cast %s to ElectricalCurrentVector", this.toString());
575         return new ElectricalCurrentVector(this.data, ElectricalCurrentUnit.SI);
576     }
577 
578     /**
579      * Return the current vector as a electricalcurrent vector, and provide a display unit.
580      * @param displayUnit the unit in which the value will be displayed
581      * @return ElectricalCurrentVector; the current vector as a electricalcurrent vector
582      */
583     public final ElectricalCurrentVector asElectricalCurrent(final ElectricalCurrentUnit displayUnit)
584     {
585         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalCurrentUnit.BASE.getSiDimensions())),
586                 UnitRuntimeException.class, "cannot cast %s to ElectricalCurrentVector", this.toString());
587         ElectricalCurrentVectorlCurrentVector.html#ElectricalCurrentVector">ElectricalCurrentVector result = new ElectricalCurrentVector(this.data, displayUnit.getStandardUnit());
588         result.setDisplayUnit(displayUnit);
589         return result;
590     }
591 
592     /**
593      * Return the current vector as a electricalinductance vector.
594      * @return ElectricalInductanceVector; the current vector as a electricalinductance vector
595      */
596     public final ElectricalInductanceVector asElectricalInductance()
597     {
598         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalInductanceUnit.BASE.getSiDimensions())),
599                 UnitRuntimeException.class, "cannot cast %s to ElectricalInductanceVector", this.toString());
600         return new ElectricalInductanceVector(this.data, ElectricalInductanceUnit.SI);
601     }
602 
603     /**
604      * Return the current vector as a electricalinductance vector, and provide a display unit.
605      * @param displayUnit the unit in which the value will be displayed
606      * @return ElectricalInductanceVector; the current vector as a electricalinductance vector
607      */
608     public final ElectricalInductanceVector asElectricalInductance(final ElectricalInductanceUnit displayUnit)
609     {
610         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalInductanceUnit.BASE.getSiDimensions())),
611                 UnitRuntimeException.class, "cannot cast %s to ElectricalInductanceVector", this.toString());
612         ElectricalInductanceVectorductanceVector.html#ElectricalInductanceVector">ElectricalInductanceVector result = new ElectricalInductanceVector(this.data, displayUnit.getStandardUnit());
613         result.setDisplayUnit(displayUnit);
614         return result;
615     }
616 
617     /**
618      * Return the current vector as a electricalpotential vector.
619      * @return ElectricalPotentialVector; the current vector as a electricalpotential vector
620      */
621     public final ElectricalPotentialVector asElectricalPotential()
622     {
623         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalPotentialUnit.BASE.getSiDimensions())),
624                 UnitRuntimeException.class, "cannot cast %s to ElectricalPotentialVector", this.toString());
625         return new ElectricalPotentialVector(this.data, ElectricalPotentialUnit.SI);
626     }
627 
628     /**
629      * Return the current vector as a electricalpotential vector, and provide a display unit.
630      * @param displayUnit the unit in which the value will be displayed
631      * @return ElectricalPotentialVector; the current vector as a electricalpotential vector
632      */
633     public final ElectricalPotentialVector asElectricalPotential(final ElectricalPotentialUnit displayUnit)
634     {
635         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalPotentialUnit.BASE.getSiDimensions())),
636                 UnitRuntimeException.class, "cannot cast %s to ElectricalPotentialVector", this.toString());
637         ElectricalPotentialVectorotentialVector.html#ElectricalPotentialVector">ElectricalPotentialVector result = new ElectricalPotentialVector(this.data, displayUnit.getStandardUnit());
638         result.setDisplayUnit(displayUnit);
639         return result;
640     }
641 
642     /**
643      * Return the current vector as a electricalresistance vector.
644      * @return ElectricalResistanceVector; the current vector as a electricalresistance vector
645      */
646     public final ElectricalResistanceVector asElectricalResistance()
647     {
648         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalResistanceUnit.BASE.getSiDimensions())),
649                 UnitRuntimeException.class, "cannot cast %s to ElectricalResistanceVector", this.toString());
650         return new ElectricalResistanceVector(this.data, ElectricalResistanceUnit.SI);
651     }
652 
653     /**
654      * Return the current vector as a electricalresistance vector, and provide a display unit.
655      * @param displayUnit the unit in which the value will be displayed
656      * @return ElectricalResistanceVector; the current vector as a electricalresistance vector
657      */
658     public final ElectricalResistanceVector asElectricalResistance(final ElectricalResistanceUnit displayUnit)
659     {
660         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ElectricalResistanceUnit.BASE.getSiDimensions())),
661                 UnitRuntimeException.class, "cannot cast %s to ElectricalResistanceVector", this.toString());
662         ElectricalResistanceVectorsistanceVector.html#ElectricalResistanceVector">ElectricalResistanceVector result = new ElectricalResistanceVector(this.data, displayUnit.getStandardUnit());
663         result.setDisplayUnit(displayUnit);
664         return result;
665     }
666 
667     /**
668      * Return the current vector as a energy vector.
669      * @return EnergyVector; the current vector as a energy vector
670      */
671     public final EnergyVector asEnergy()
672     {
673         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(EnergyUnit.BASE.getSiDimensions())),
674                 UnitRuntimeException.class, "cannot cast %s to EnergyVector", this.toString());
675         return new EnergyVector(this.data, EnergyUnit.SI);
676     }
677 
678     /**
679      * Return the current vector as a energy vector, and provide a display unit.
680      * @param displayUnit the unit in which the value will be displayed
681      * @return EnergyVector; the current vector as a energy vector
682      */
683     public final EnergyVector asEnergy(final EnergyUnit displayUnit)
684     {
685         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(EnergyUnit.BASE.getSiDimensions())),
686                 UnitRuntimeException.class, "cannot cast %s to EnergyVector", this.toString());
687         EnergyVectorr/EnergyVector.html#EnergyVector">EnergyVector result = new EnergyVector(this.data, displayUnit.getStandardUnit());
688         result.setDisplayUnit(displayUnit);
689         return result;
690     }
691 
692     /**
693      * Return the current vector as a equivalentdose vector.
694      * @return EquivalentDoseVector; the current vector as a equivalentdose vector
695      */
696     public final EquivalentDoseVector asEquivalentDose()
697     {
698         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(EquivalentDoseUnit.BASE.getSiDimensions())),
699                 UnitRuntimeException.class, "cannot cast %s to EquivalentDoseVector", this.toString());
700         return new EquivalentDoseVector(this.data, EquivalentDoseUnit.SI);
701     }
702 
703     /**
704      * Return the current vector as a equivalentdose vector, and provide a display unit.
705      * @param displayUnit the unit in which the value will be displayed
706      * @return EquivalentDoseVector; the current vector as a equivalentdose vector
707      */
708     public final EquivalentDoseVector asEquivalentDose(final EquivalentDoseUnit displayUnit)
709     {
710         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(EquivalentDoseUnit.BASE.getSiDimensions())),
711                 UnitRuntimeException.class, "cannot cast %s to EquivalentDoseVector", this.toString());
712         EquivalentDoseVectorlentDoseVector.html#EquivalentDoseVector">EquivalentDoseVector result = new EquivalentDoseVector(this.data, displayUnit.getStandardUnit());
713         result.setDisplayUnit(displayUnit);
714         return result;
715     }
716 
717     /**
718      * Return the current vector as a flowmass vector.
719      * @return FlowMassVector; the current vector as a flowmass vector
720      */
721     public final FlowMassVector asFlowMass()
722     {
723         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FlowMassUnit.BASE.getSiDimensions())),
724                 UnitRuntimeException.class, "cannot cast %s to FlowMassVector", this.toString());
725         return new FlowMassVector(this.data, FlowMassUnit.SI);
726     }
727 
728     /**
729      * Return the current vector as a flowmass vector, and provide a display unit.
730      * @param displayUnit the unit in which the value will be displayed
731      * @return FlowMassVector; the current vector as a flowmass vector
732      */
733     public final FlowMassVector asFlowMass(final FlowMassUnit displayUnit)
734     {
735         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FlowMassUnit.BASE.getSiDimensions())),
736                 UnitRuntimeException.class, "cannot cast %s to FlowMassVector", this.toString());
737         FlowMassVectorFlowMassVector.html#FlowMassVector">FlowMassVector result = new FlowMassVector(this.data, displayUnit.getStandardUnit());
738         result.setDisplayUnit(displayUnit);
739         return result;
740     }
741 
742     /**
743      * Return the current vector as a flowvolume vector.
744      * @return FlowVolumeVector; the current vector as a flowvolume vector
745      */
746     public final FlowVolumeVector asFlowVolume()
747     {
748         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FlowVolumeUnit.BASE.getSiDimensions())),
749                 UnitRuntimeException.class, "cannot cast %s to FlowVolumeVector", this.toString());
750         return new FlowVolumeVector(this.data, FlowVolumeUnit.SI);
751     }
752 
753     /**
754      * Return the current vector as a flowvolume vector, and provide a display unit.
755      * @param displayUnit the unit in which the value will be displayed
756      * @return FlowVolumeVector; the current vector as a flowvolume vector
757      */
758     public final FlowVolumeVector asFlowVolume(final FlowVolumeUnit displayUnit)
759     {
760         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FlowVolumeUnit.BASE.getSiDimensions())),
761                 UnitRuntimeException.class, "cannot cast %s to FlowVolumeVector", this.toString());
762         FlowVolumeVectorowVolumeVector.html#FlowVolumeVector">FlowVolumeVector result = new FlowVolumeVector(this.data, displayUnit.getStandardUnit());
763         result.setDisplayUnit(displayUnit);
764         return result;
765     }
766 
767     /**
768      * Return the current vector as a force vector.
769      * @return ForceVector; the current vector as a force vector
770      */
771     public final ForceVector asForce()
772     {
773         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ForceUnit.BASE.getSiDimensions())),
774                 UnitRuntimeException.class, "cannot cast %s to ForceVector", this.toString());
775         return new ForceVector(this.data, ForceUnit.SI);
776     }
777 
778     /**
779      * Return the current vector as a force vector, and provide a display unit.
780      * @param displayUnit the unit in which the value will be displayed
781      * @return ForceVector; the current vector as a force vector
782      */
783     public final ForceVector asForce(final ForceUnit displayUnit)
784     {
785         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(ForceUnit.BASE.getSiDimensions())),
786                 UnitRuntimeException.class, "cannot cast %s to ForceVector", this.toString());
787         ForceVectoror/ForceVector.html#ForceVector">ForceVector result = new ForceVector(this.data, displayUnit.getStandardUnit());
788         result.setDisplayUnit(displayUnit);
789         return result;
790     }
791 
792     /**
793      * Return the current vector as a frequency vector.
794      * @return FrequencyVector; the current vector as a frequency vector
795      */
796     public final FrequencyVector asFrequency()
797     {
798         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FrequencyUnit.BASE.getSiDimensions())),
799                 UnitRuntimeException.class, "cannot cast %s to FrequencyVector", this.toString());
800         return new FrequencyVector(this.data, FrequencyUnit.SI);
801     }
802 
803     /**
804      * Return the current vector as a frequency vector, and provide a display unit.
805      * @param displayUnit the unit in which the value will be displayed
806      * @return FrequencyVector; the current vector as a frequency vector
807      */
808     public final FrequencyVector asFrequency(final FrequencyUnit displayUnit)
809     {
810         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(FrequencyUnit.BASE.getSiDimensions())),
811                 UnitRuntimeException.class, "cannot cast %s to FrequencyVector", this.toString());
812         FrequencyVectorrequencyVector.html#FrequencyVector">FrequencyVector result = new FrequencyVector(this.data, displayUnit.getStandardUnit());
813         result.setDisplayUnit(displayUnit);
814         return result;
815     }
816 
817     /**
818      * Return the current vector as a illuminance vector.
819      * @return IlluminanceVector; the current vector as a illuminance vector
820      */
821     public final IlluminanceVector asIlluminance()
822     {
823         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(IlluminanceUnit.BASE.getSiDimensions())),
824                 UnitRuntimeException.class, "cannot cast %s to IlluminanceVector", this.toString());
825         return new IlluminanceVector(this.data, IlluminanceUnit.SI);
826     }
827 
828     /**
829      * Return the current vector as a illuminance vector, and provide a display unit.
830      * @param displayUnit the unit in which the value will be displayed
831      * @return IlluminanceVector; the current vector as a illuminance vector
832      */
833     public final IlluminanceVector asIlluminance(final IlluminanceUnit displayUnit)
834     {
835         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(IlluminanceUnit.BASE.getSiDimensions())),
836                 UnitRuntimeException.class, "cannot cast %s to IlluminanceVector", this.toString());
837         IlluminanceVectoruminanceVector.html#IlluminanceVector">IlluminanceVector result = new IlluminanceVector(this.data, displayUnit.getStandardUnit());
838         result.setDisplayUnit(displayUnit);
839         return result;
840     }
841 
842     /**
843      * Return the current vector as a lineardensity vector.
844      * @return LinearDensityVector; the current vector as a lineardensity vector
845      */
846     public final LinearDensityVector asLinearDensity()
847     {
848         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LinearDensityUnit.BASE.getSiDimensions())),
849                 UnitRuntimeException.class, "cannot cast %s to LinearDensityVector", this.toString());
850         return new LinearDensityVector(this.data, LinearDensityUnit.SI);
851     }
852 
853     /**
854      * Return the current vector as a lineardensity vector, and provide a display unit.
855      * @param displayUnit the unit in which the value will be displayed
856      * @return LinearDensityVector; the current vector as a lineardensity vector
857      */
858     public final LinearDensityVector asLinearDensity(final LinearDensityUnit displayUnit)
859     {
860         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LinearDensityUnit.BASE.getSiDimensions())),
861                 UnitRuntimeException.class, "cannot cast %s to LinearDensityVector", this.toString());
862         LinearDensityVectorrDensityVector.html#LinearDensityVector">LinearDensityVector result = new LinearDensityVector(this.data, displayUnit.getStandardUnit());
863         result.setDisplayUnit(displayUnit);
864         return result;
865     }
866 
867     /**
868      * Return the current vector as a luminousflux vector.
869      * @return LuminousFluxVector; the current vector as a luminousflux vector
870      */
871     public final LuminousFluxVector asLuminousFlux()
872     {
873         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LuminousFluxUnit.BASE.getSiDimensions())),
874                 UnitRuntimeException.class, "cannot cast %s to LuminousFluxVector", this.toString());
875         return new LuminousFluxVector(this.data, LuminousFluxUnit.SI);
876     }
877 
878     /**
879      * Return the current vector as a luminousflux vector, and provide a display unit.
880      * @param displayUnit the unit in which the value will be displayed
881      * @return LuminousFluxVector; the current vector as a luminousflux vector
882      */
883     public final LuminousFluxVector asLuminousFlux(final LuminousFluxUnit displayUnit)
884     {
885         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LuminousFluxUnit.BASE.getSiDimensions())),
886                 UnitRuntimeException.class, "cannot cast %s to LuminousFluxVector", this.toString());
887         LuminousFluxVectornousFluxVector.html#LuminousFluxVector">LuminousFluxVector result = new LuminousFluxVector(this.data, displayUnit.getStandardUnit());
888         result.setDisplayUnit(displayUnit);
889         return result;
890     }
891 
892     /**
893      * Return the current vector as a luminousintensity vector.
894      * @return LuminousIntensityVector; the current vector as a luminousintensity vector
895      */
896     public final LuminousIntensityVector asLuminousIntensity()
897     {
898         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LuminousIntensityUnit.BASE.getSiDimensions())),
899                 UnitRuntimeException.class, "cannot cast %s to LuminousIntensityVector", this.toString());
900         return new LuminousIntensityVector(this.data, LuminousIntensityUnit.SI);
901     }
902 
903     /**
904      * Return the current vector as a luminousintensity vector, and provide a display unit.
905      * @param displayUnit the unit in which the value will be displayed
906      * @return LuminousIntensityVector; the current vector as a luminousintensity vector
907      */
908     public final LuminousIntensityVector asLuminousIntensity(final LuminousIntensityUnit displayUnit)
909     {
910         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LuminousIntensityUnit.BASE.getSiDimensions())),
911                 UnitRuntimeException.class, "cannot cast %s to LuminousIntensityVector", this.toString());
912         LuminousIntensityVectorntensityVector.html#LuminousIntensityVector">LuminousIntensityVector result = new LuminousIntensityVector(this.data, displayUnit.getStandardUnit());
913         result.setDisplayUnit(displayUnit);
914         return result;
915     }
916 
917     /**
918      * Return the current vector as a magneticfluxdensity vector.
919      * @return MagneticFluxDensityVector; the current vector as a magneticfluxdensity vector
920      */
921     public final MagneticFluxDensityVector asMagneticFluxDensity()
922     {
923         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MagneticFluxDensityUnit.BASE.getSiDimensions())),
924                 UnitRuntimeException.class, "cannot cast %s to MagneticFluxDensityVector", this.toString());
925         return new MagneticFluxDensityVector(this.data, MagneticFluxDensityUnit.SI);
926     }
927 
928     /**
929      * Return the current vector as a magneticfluxdensity vector, and provide a display unit.
930      * @param displayUnit the unit in which the value will be displayed
931      * @return MagneticFluxDensityVector; the current vector as a magneticfluxdensity vector
932      */
933     public final MagneticFluxDensityVector asMagneticFluxDensity(final MagneticFluxDensityUnit displayUnit)
934     {
935         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MagneticFluxDensityUnit.BASE.getSiDimensions())),
936                 UnitRuntimeException.class, "cannot cast %s to MagneticFluxDensityVector", this.toString());
937         MagneticFluxDensityVectorxDensityVector.html#MagneticFluxDensityVector">MagneticFluxDensityVector result = new MagneticFluxDensityVector(this.data, displayUnit.getStandardUnit());
938         result.setDisplayUnit(displayUnit);
939         return result;
940     }
941 
942     /**
943      * Return the current vector as a magneticflux vector.
944      * @return MagneticFluxVector; the current vector as a magneticflux vector
945      */
946     public final MagneticFluxVector asMagneticFlux()
947     {
948         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MagneticFluxUnit.BASE.getSiDimensions())),
949                 UnitRuntimeException.class, "cannot cast %s to MagneticFluxVector", this.toString());
950         return new MagneticFluxVector(this.data, MagneticFluxUnit.SI);
951     }
952 
953     /**
954      * Return the current vector as a magneticflux vector, and provide a display unit.
955      * @param displayUnit the unit in which the value will be displayed
956      * @return MagneticFluxVector; the current vector as a magneticflux vector
957      */
958     public final MagneticFluxVector asMagneticFlux(final MagneticFluxUnit displayUnit)
959     {
960         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MagneticFluxUnit.BASE.getSiDimensions())),
961                 UnitRuntimeException.class, "cannot cast %s to MagneticFluxVector", this.toString());
962         MagneticFluxVectoreticFluxVector.html#MagneticFluxVector">MagneticFluxVector result = new MagneticFluxVector(this.data, displayUnit.getStandardUnit());
963         result.setDisplayUnit(displayUnit);
964         return result;
965     }
966 
967     /**
968      * Return the current vector as a mass vector.
969      * @return MassVector; the current vector as a mass vector
970      */
971     public final MassVector asMass()
972     {
973         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MassUnit.BASE.getSiDimensions())),
974                 UnitRuntimeException.class, "cannot cast %s to MassVector", this.toString());
975         return new MassVector(this.data, MassUnit.SI);
976     }
977 
978     /**
979      * Return the current vector as a mass vector, and provide a display unit.
980      * @param displayUnit the unit in which the value will be displayed
981      * @return MassVector; the current vector as a mass vector
982      */
983     public final MassVector asMass(final MassUnit displayUnit)
984     {
985         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MassUnit.BASE.getSiDimensions())),
986                 UnitRuntimeException.class, "cannot cast %s to MassVector", this.toString());
987         MassVectortor/MassVector.html#MassVector">MassVector result = new MassVector(this.data, displayUnit.getStandardUnit());
988         result.setDisplayUnit(displayUnit);
989         return result;
990     }
991 
992     /**
993      * Return the current vector as a momentum vector.
994      * @return MomentumVector; the current vector as a momentum vector
995      */
996     public final MomentumVector asMomentum()
997     {
998         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MomentumUnit.BASE.getSiDimensions())),
999                 UnitRuntimeException.class, "cannot cast %s to MomentumVector", this.toString());
1000         return new MomentumVector(this.data, MomentumUnit.SI);
1001     }
1002 
1003     /**
1004      * Return the current vector as a momentum vector, and provide a display unit.
1005      * @param displayUnit the unit in which the value will be displayed
1006      * @return MomentumVector; the current vector as a momentum vector
1007      */
1008     public final MomentumVector asMomentum(final MomentumUnit displayUnit)
1009     {
1010         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(MomentumUnit.BASE.getSiDimensions())),
1011                 UnitRuntimeException.class, "cannot cast %s to MomentumVector", this.toString());
1012         MomentumVectorMomentumVector.html#MomentumVector">MomentumVector result = new MomentumVector(this.data, displayUnit.getStandardUnit());
1013         result.setDisplayUnit(displayUnit);
1014         return result;
1015     }
1016 
1017     /**
1018      * Return the current vector as a power vector.
1019      * @return PowerVector; the current vector as a power vector
1020      */
1021     public final PowerVector asPower()
1022     {
1023         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(PowerUnit.BASE.getSiDimensions())),
1024                 UnitRuntimeException.class, "cannot cast %s to PowerVector", this.toString());
1025         return new PowerVector(this.data, PowerUnit.SI);
1026     }
1027 
1028     /**
1029      * Return the current vector as a power vector, and provide a display unit.
1030      * @param displayUnit the unit in which the value will be displayed
1031      * @return PowerVector; the current vector as a power vector
1032      */
1033     public final PowerVector asPower(final PowerUnit displayUnit)
1034     {
1035         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(PowerUnit.BASE.getSiDimensions())),
1036                 UnitRuntimeException.class, "cannot cast %s to PowerVector", this.toString());
1037         PowerVectoror/PowerVector.html#PowerVector">PowerVector result = new PowerVector(this.data, displayUnit.getStandardUnit());
1038         result.setDisplayUnit(displayUnit);
1039         return result;
1040     }
1041 
1042     /**
1043      * Return the current vector as a pressure vector.
1044      * @return PressureVector; the current vector as a pressure vector
1045      */
1046     public final PressureVector asPressure()
1047     {
1048         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(PressureUnit.BASE.getSiDimensions())),
1049                 UnitRuntimeException.class, "cannot cast %s to PressureVector", this.toString());
1050         return new PressureVector(this.data, PressureUnit.SI);
1051     }
1052 
1053     /**
1054      * Return the current vector as a pressure vector, and provide a display unit.
1055      * @param displayUnit the unit in which the value will be displayed
1056      * @return PressureVector; the current vector as a pressure vector
1057      */
1058     public final PressureVector asPressure(final PressureUnit displayUnit)
1059     {
1060         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(PressureUnit.BASE.getSiDimensions())),
1061                 UnitRuntimeException.class, "cannot cast %s to PressureVector", this.toString());
1062         PressureVectorPressureVector.html#PressureVector">PressureVector result = new PressureVector(this.data, displayUnit.getStandardUnit());
1063         result.setDisplayUnit(displayUnit);
1064         return result;
1065     }
1066 
1067     /**
1068      * Return the current vector as a radioactivity vector.
1069      * @return RadioActivityVector; the current vector as a radioactivity vector
1070      */
1071     public final RadioActivityVector asRadioActivity()
1072     {
1073         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(RadioActivityUnit.BASE.getSiDimensions())),
1074                 UnitRuntimeException.class, "cannot cast %s to RadioActivityVector", this.toString());
1075         return new RadioActivityVector(this.data, RadioActivityUnit.SI);
1076     }
1077 
1078     /**
1079      * Return the current vector as a radioactivity vector, and provide a display unit.
1080      * @param displayUnit the unit in which the value will be displayed
1081      * @return RadioActivityVector; the current vector as a radioactivity vector
1082      */
1083     public final RadioActivityVector asRadioActivity(final RadioActivityUnit displayUnit)
1084     {
1085         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(RadioActivityUnit.BASE.getSiDimensions())),
1086                 UnitRuntimeException.class, "cannot cast %s to RadioActivityVector", this.toString());
1087         RadioActivityVectorActivityVector.html#RadioActivityVector">RadioActivityVector result = new RadioActivityVector(this.data, displayUnit.getStandardUnit());
1088         result.setDisplayUnit(displayUnit);
1089         return result;
1090     }
1091 
1092     /**
1093      * Return the current vector as a solidangle vector.
1094      * @return SolidAngleVector; the current vector as a solidangle vector
1095      */
1096     public final SolidAngleVector asSolidAngle()
1097     {
1098         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(SolidAngleUnit.BASE.getSiDimensions())),
1099                 UnitRuntimeException.class, "cannot cast %s to SolidAngleVector", this.toString());
1100         return new SolidAngleVector(this.data, SolidAngleUnit.SI);
1101     }
1102 
1103     /**
1104      * Return the current vector as a solidangle vector, and provide a display unit.
1105      * @param displayUnit the unit in which the value will be displayed
1106      * @return SolidAngleVector; the current vector as a solidangle vector
1107      */
1108     public final SolidAngleVector asSolidAngle(final SolidAngleUnit displayUnit)
1109     {
1110         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(SolidAngleUnit.BASE.getSiDimensions())),
1111                 UnitRuntimeException.class, "cannot cast %s to SolidAngleVector", this.toString());
1112         SolidAngleVectorlidAngleVector.html#SolidAngleVector">SolidAngleVector result = new SolidAngleVector(this.data, displayUnit.getStandardUnit());
1113         result.setDisplayUnit(displayUnit);
1114         return result;
1115     }
1116 
1117     /**
1118      * Return the current vector as a speed vector.
1119      * @return SpeedVector; the current vector as a speed vector
1120      */
1121     public final SpeedVector asSpeed()
1122     {
1123         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(SpeedUnit.BASE.getSiDimensions())),
1124                 UnitRuntimeException.class, "cannot cast %s to SpeedVector", this.toString());
1125         return new SpeedVector(this.data, SpeedUnit.SI);
1126     }
1127 
1128     /**
1129      * Return the current vector as a speed vector, and provide a display unit.
1130      * @param displayUnit the unit in which the value will be displayed
1131      * @return SpeedVector; the current vector as a speed vector
1132      */
1133     public final SpeedVector asSpeed(final SpeedUnit displayUnit)
1134     {
1135         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(SpeedUnit.BASE.getSiDimensions())),
1136                 UnitRuntimeException.class, "cannot cast %s to SpeedVector", this.toString());
1137         SpeedVectoror/SpeedVector.html#SpeedVector">SpeedVector result = new SpeedVector(this.data, displayUnit.getStandardUnit());
1138         result.setDisplayUnit(displayUnit);
1139         return result;
1140     }
1141 
1142     /**
1143      * Return the current vector as a torque vector.
1144      * @return TorqueVector; the current vector as a torque vector
1145      */
1146     public final TorqueVector asTorque()
1147     {
1148         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(TorqueUnit.BASE.getSiDimensions())),
1149                 UnitRuntimeException.class, "cannot cast %s to TorqueVector", this.toString());
1150         return new TorqueVector(this.data, TorqueUnit.SI);
1151     }
1152 
1153     /**
1154      * Return the current vector as a torque vector, and provide a display unit.
1155      * @param displayUnit the unit in which the value will be displayed
1156      * @return TorqueVector; the current vector as a torque vector
1157      */
1158     public final TorqueVector asTorque(final TorqueUnit displayUnit)
1159     {
1160         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(TorqueUnit.BASE.getSiDimensions())),
1161                 UnitRuntimeException.class, "cannot cast %s to TorqueVector", this.toString());
1162         TorqueVectorr/TorqueVector.html#TorqueVector">TorqueVector result = new TorqueVector(this.data, displayUnit.getStandardUnit());
1163         result.setDisplayUnit(displayUnit);
1164         return result;
1165     }
1166 
1167     /**
1168      * Return the current vector as a volume vector.
1169      * @return VolumeVector; the current vector as a volume vector
1170      */
1171     public final VolumeVector asVolume()
1172     {
1173         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(VolumeUnit.BASE.getSiDimensions())),
1174                 UnitRuntimeException.class, "cannot cast %s to VolumeVector", this.toString());
1175         return new VolumeVector(this.data, VolumeUnit.SI);
1176     }
1177 
1178     /**
1179      * Return the current vector as a volume vector, and provide a display unit.
1180      * @param displayUnit the unit in which the value will be displayed
1181      * @return VolumeVector; the current vector as a volume vector
1182      */
1183     public final VolumeVector asVolume(final VolumeUnit displayUnit)
1184     {
1185         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(VolumeUnit.BASE.getSiDimensions())),
1186                 UnitRuntimeException.class, "cannot cast %s to VolumeVector", this.toString());
1187         VolumeVectorr/VolumeVector.html#VolumeVector">VolumeVector result = new VolumeVector(this.data, displayUnit.getStandardUnit());
1188         result.setDisplayUnit(displayUnit);
1189         return result;
1190     }
1191 
1192     /**
1193      * Return the current vector as a angle vector.
1194      * @return AngleVector; the current vector as a angle vector
1195      */
1196     public final AngleVector asAngle()
1197     {
1198         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngleUnit.BASE.getSiDimensions())),
1199                 UnitRuntimeException.class, "cannot cast %s to AngleVector", this.toString());
1200         return new AngleVector(this.data, AngleUnit.SI);
1201     }
1202 
1203     /**
1204      * Return the current vector as a angle vector, and provide a display unit.
1205      * @param displayUnit the unit in which the value will be displayed
1206      * @return AngleVector; the current vector as a angle vector
1207      */
1208     public final AngleVector asAngle(final AngleUnit displayUnit)
1209     {
1210         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(AngleUnit.BASE.getSiDimensions())),
1211                 UnitRuntimeException.class, "cannot cast %s to AngleVector", this.toString());
1212         AngleVectoror/AngleVector.html#AngleVector">AngleVector result = new AngleVector(this.data, displayUnit.getStandardUnit());
1213         result.setDisplayUnit(displayUnit);
1214         return result;
1215     }
1216 
1217     /**
1218      * Return the current vector as a length vector.
1219      * @return LengthVector; the current vector as a length vector
1220      */
1221     public final LengthVector asLength()
1222     {
1223         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LengthUnit.BASE.getSiDimensions())),
1224                 UnitRuntimeException.class, "cannot cast %s to LengthVector", this.toString());
1225         return new LengthVector(this.data, LengthUnit.SI);
1226     }
1227 
1228     /**
1229      * Return the current vector as a length vector, and provide a display unit.
1230      * @param displayUnit the unit in which the value will be displayed
1231      * @return LengthVector; the current vector as a length vector
1232      */
1233     public final LengthVector asLength(final LengthUnit displayUnit)
1234     {
1235         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(LengthUnit.BASE.getSiDimensions())),
1236                 UnitRuntimeException.class, "cannot cast %s to LengthVector", this.toString());
1237         LengthVectorr/LengthVector.html#LengthVector">LengthVector result = new LengthVector(this.data, displayUnit.getStandardUnit());
1238         result.setDisplayUnit(displayUnit);
1239         return result;
1240     }
1241 
1242     /**
1243      * Return the current vector as a temperature vector.
1244      * @return TemperatureVector; the current vector as a temperature vector
1245      */
1246     public final TemperatureVector asTemperature()
1247     {
1248         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(TemperatureUnit.BASE.getSiDimensions())),
1249                 UnitRuntimeException.class, "cannot cast %s to TemperatureVector", this.toString());
1250         return new TemperatureVector(this.data, TemperatureUnit.SI);
1251     }
1252 
1253     /**
1254      * Return the current vector as a temperature vector, and provide a display unit.
1255      * @param displayUnit the unit in which the value will be displayed
1256      * @return TemperatureVector; the current vector as a temperature vector
1257      */
1258     public final TemperatureVector asTemperature(final TemperatureUnit displayUnit)
1259     {
1260         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(TemperatureUnit.BASE.getSiDimensions())),
1261                 UnitRuntimeException.class, "cannot cast %s to TemperatureVector", this.toString());
1262         TemperatureVectorperatureVector.html#TemperatureVector">TemperatureVector result = new TemperatureVector(this.data, displayUnit.getStandardUnit());
1263         result.setDisplayUnit(displayUnit);
1264         return result;
1265     }
1266 
1267     /**
1268      * Return the current vector as a duration vector.
1269      * @return DurationVector; the current vector as a duration vector
1270      */
1271     public final DurationVector asDuration()
1272     {
1273         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DurationUnit.BASE.getSiDimensions())),
1274                 UnitRuntimeException.class, "cannot cast %s to DurationVector", this.toString());
1275         return new DurationVector(this.data, DurationUnit.SI);
1276     }
1277 
1278     /**
1279      * Return the current vector as a duration vector, and provide a display unit.
1280      * @param displayUnit the unit in which the value will be displayed
1281      * @return DurationVector; the current vector as a duration vector
1282      */
1283     public final DurationVector asDuration(final DurationUnit displayUnit)
1284     {
1285         Throw.when(!(getDisplayUnit().getQuantity().getSiDimensions().equals(DurationUnit.BASE.getSiDimensions())),
1286                 UnitRuntimeException.class, "cannot cast %s to DurationVector", this.toString());
1287         DurationVectorDurationVector.html#DurationVector">DurationVector result = new DurationVector(this.data, displayUnit.getStandardUnit());
1288         result.setDisplayUnit(displayUnit);
1289         return result;
1290     }
1291 
1292 }