View Javadoc
1   package org.djunits.value.vfloat.scalar;
2   
3   import java.util.regex.Matcher;
4   
5   import javax.annotation.Generated;
6   
7   import org.djunits.Throw;
8   import org.djunits.unit.AbsorbedDoseUnit;
9   import org.djunits.unit.AccelerationUnit;
10  import org.djunits.unit.AmountOfSubstanceUnit;
11  import org.djunits.unit.AngleUnit;
12  import org.djunits.unit.AreaUnit;
13  import org.djunits.unit.CatalyticActivityUnit;
14  import org.djunits.unit.DensityUnit;
15  import org.djunits.unit.DimensionlessUnit;
16  import org.djunits.unit.DurationUnit;
17  import org.djunits.unit.ElectricalCapacitanceUnit;
18  import org.djunits.unit.ElectricalChargeUnit;
19  import org.djunits.unit.ElectricalConductanceUnit;
20  import org.djunits.unit.ElectricalCurrentUnit;
21  import org.djunits.unit.ElectricalInductanceUnit;
22  import org.djunits.unit.ElectricalPotentialUnit;
23  import org.djunits.unit.ElectricalResistanceUnit;
24  import org.djunits.unit.EnergyUnit;
25  import org.djunits.unit.EquivalentDoseUnit;
26  import org.djunits.unit.FlowMassUnit;
27  import org.djunits.unit.FlowVolumeUnit;
28  import org.djunits.unit.ForceUnit;
29  import org.djunits.unit.FrequencyUnit;
30  import org.djunits.unit.IlluminanceUnit;
31  import org.djunits.unit.LengthUnit;
32  import org.djunits.unit.LinearDensityUnit;
33  import org.djunits.unit.LuminousFluxUnit;
34  import org.djunits.unit.LuminousIntensityUnit;
35  import org.djunits.unit.MagneticFluxDensityUnit;
36  import org.djunits.unit.MagneticFluxUnit;
37  import org.djunits.unit.MassUnit;
38  import org.djunits.unit.PowerUnit;
39  import org.djunits.unit.PressureUnit;
40  import org.djunits.unit.RadioActivityUnit;
41  import org.djunits.unit.SolidAngleUnit;
42  import org.djunits.unit.SpeedUnit;
43  import org.djunits.unit.TemperatureUnit;
44  import org.djunits.unit.TorqueUnit;
45  import org.djunits.unit.VolumeUnit;
46  import org.djunits.value.function.DimensionlessFunctions;
47  import org.djunits.value.util.ValueUtil;
48  import org.djunits.value.vfloat.scalar.base.AbstractFloatScalarRel;
49  
50  /**
51   * Easy access methods for the FloatDimensionless FloatScalar, which is relative by definition.
52   * <p>
53   * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
54   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
55   * </p>
56   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
57   * @author <a href="https://www.tudelft.nl/staff/p.knoppers/">Peter Knoppers</a>
58   */
59  @Generated(value = "org.djunits.generator.GenerateDJUNIT", date = "2019-10-18T12:12:25.568Z")
60  public class FloatDimensionless extends AbstractFloatScalarRel<DimensionlessUnit, FloatDimensionless>
61          implements DimensionlessFunctions<DimensionlessUnit, FloatDimensionless>
62  {
63      /** */
64      private static final long serialVersionUID = 20150901L;
65  
66      /** Constant with value zero. */
67      public static final FloatDimensionlessatDimensionless.html#FloatDimensionless">FloatDimensionless ZERO = new FloatDimensionless(0.0f, DimensionlessUnit.SI);
68  
69      /** Constant with value one. */
70      public static final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless ONE = new FloatDimensionless(1.0f, DimensionlessUnit.SI);
71  
72      /** Constant with value NaN. */
73      @SuppressWarnings("checkstyle:constantname")
74      public static final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless NaN = new FloatDimensionless(Float.NaN, DimensionlessUnit.SI);
75  
76      /** Constant with value POSITIVE_INFINITY. */
77      public static final FloatDimensionless POSITIVE_INFINITY =
78              new FloatDimensionless(Float.POSITIVE_INFINITY, DimensionlessUnit.SI);
79  
80      /** Constant with value NEGATIVE_INFINITY. */
81      public static final FloatDimensionless NEGATIVE_INFINITY =
82              new FloatDimensionless(Float.NEGATIVE_INFINITY, DimensionlessUnit.SI);
83  
84      /** Constant with value MAX_VALUE. */
85      public static final FloatDimensionlessionless.html#FloatDimensionless">FloatDimensionless POS_MAXVALUE = new FloatDimensionless(Float.MAX_VALUE, DimensionlessUnit.SI);
86  
87      /** Constant with value -MAX_VALUE. */
88      public static final FloatDimensionlessionless.html#FloatDimensionless">FloatDimensionless NEG_MAXVALUE = new FloatDimensionless(-Float.MAX_VALUE, DimensionlessUnit.SI);
89  
90      /**
91       * Construct FloatDimensionless scalar.
92       * @param value float; the float value
93       * @param unit unit for the float value
94       */
95      public FloatDimensionless(final float value, final DimensionlessUnit unit)
96      {
97          super(value, unit);
98      }
99  
100     /**
101      * Construct FloatDimensionless scalar.
102      * @param value Scalar from which to construct this instance
103      */
104     public FloatDimensionlessr/FloatDimensionless.html#FloatDimensionless">FloatDimensionless(final FloatDimensionless value)
105     {
106         super(value);
107     }
108 
109     /**
110      * Construct FloatDimensionless scalar using a double value.
111      * @param value double; the double value
112      * @param unit unit for the resulting float value
113      */
114     public FloatDimensionless(final double value, final DimensionlessUnit unit)
115     {
116         super((float) value, unit);
117     }
118 
119     /** {@inheritDoc} */
120     @Override
121     public final FloatDimensionless instantiateRel(final float value, final DimensionlessUnit unit)
122     {
123         return new FloatDimensionless(value, unit);
124     }
125 
126     /**
127      * Construct FloatDimensionless scalar.
128      * @param value float; the float value in SI units
129      * @return the new scalar with the SI value
130      */
131     public static final FloatDimensionless instantiateSI(final float value)
132     {
133         return new FloatDimensionless(value, DimensionlessUnit.SI);
134     }
135 
136     /**
137      * Interpolate between two values.
138      * @param zero the low value
139      * @param one the high value
140      * @param ratio double; the ratio between 0 and 1, inclusive
141      * @return a Scalar at the ratio between
142      */
143     public static FloatDimensionlesstDimensionless.html#FloatDimensionless">FloatDimensionlesssionless.html#FloatDimensionless">FloatDimensionless interpolate(final FloatDimensionlesstDimensionless.html#FloatDimensionless">FloatDimensionless zero, final FloatDimensionless one, final float ratio)
144     {
145         return new FloatDimensionless(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getDisplayUnit()) * ratio,
146                 zero.getDisplayUnit());
147     }
148 
149     /**
150      * Return the maximum value of two relative scalars.
151      * @param r1 the first scalar
152      * @param r2 the second scalar
153      * @return the maximum value of two relative scalars
154      */
155     public static FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless max(final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless r1, final FloatDimensionless r2)
156     {
157         return (r1.gt(r2)) ? r1 : r2;
158     }
159 
160     /**
161      * Return the maximum value of more than two relative scalars.
162      * @param r1 the first scalar
163      * @param r2 the second scalar
164      * @param rn the other scalars
165      * @return the maximum value of more than two relative scalars
166      */
167     public static FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless max(final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless r1, final FloatDimensionless r2,
168             final FloatDimensionless... rn)
169     {
170         FloatDimensionless maxr = (r1.gt(r2)) ? r1 : r2;
171         for (FloatDimensionless r : rn)
172         {
173             if (r.gt(maxr))
174             {
175                 maxr = r;
176             }
177         }
178         return maxr;
179     }
180 
181     /**
182      * Return the minimum value of two relative scalars.
183      * @param r1 the first scalar
184      * @param r2 the second scalar
185      * @return the minimum value of two relative scalars
186      */
187     public static FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless min(final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless r1, final FloatDimensionless r2)
188     {
189         return (r1.lt(r2)) ? r1 : r2;
190     }
191 
192     /**
193      * Return the minimum value of more than two relative scalars.
194      * @param r1 the first scalar
195      * @param r2 the second scalar
196      * @param rn the other scalars
197      * @return the minimum value of more than two relative scalars
198      */
199     public static FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless min(final FloatDimensionlessoatDimensionless.html#FloatDimensionless">FloatDimensionless r1, final FloatDimensionless r2,
200             final FloatDimensionless... rn)
201     {
202         FloatDimensionless minr = (r1.lt(r2)) ? r1 : r2;
203         for (FloatDimensionless r : rn)
204         {
205             if (r.lt(minr))
206             {
207                 minr = r;
208             }
209         }
210         return minr;
211     }
212 
213     /**
214      * Returns a FloatDimensionless representation of a textual representation of a value with a unit. The String representation
215      * that can be parsed is the double value in the unit, followed by the official abbreviation of the unit. Spaces are
216      * allowed, but not required, between the value and the unit.
217      * @param text String; the textual representation to parse into a FloatDimensionless
218      * @return FloatDimensionless; the Scalar representation of the value in its unit
219      * @throws IllegalArgumentException when the text cannot be parsed
220      * @throws NullPointerException when the text argument is null
221      */
222     public static FloatDimensionless valueOf(final String text)
223     {
224         Throw.whenNull(text, "Error parsing FloatDimensionless: text to parse is null");
225         Throw.when(text.length() == 0, IllegalArgumentException.class, "Error parsing FloatDimensionless: empty text to parse");
226         Matcher matcher = ValueUtil.NUMBER_PATTERN.matcher(text);
227         if (matcher.find())
228         {
229             int index = matcher.end();
230             String unitString = text.substring(index).trim();
231             String valueString = text.substring(0, index).trim();
232             DimensionlessUnit unit = DimensionlessUnit.BASE.getUnitByAbbreviation(unitString);
233             if (unit != null)
234             {
235                 float f = Float.parseFloat(valueString);
236                 return new FloatDimensionless(f, unit);
237             }
238         }
239         throw new IllegalArgumentException("Error parsing FloatDimensionless from " + text);
240     }
241 
242     /**
243      * Returns a FloatDimensionless based on a value and the textual representation of the unit.
244      * @param value double; the value to use
245      * @param unitString String; the textual representation of the unit
246      * @return FloatDimensionless; the Scalar representation of the value in its unit
247      * @throws IllegalArgumentException when the unit cannot be parsed or is incorrect
248      * @throws NullPointerException when the unitString argument is null
249      */
250     public static FloatDimensionless of(final float value, final String unitString)
251     {
252         Throw.whenNull(unitString, "Error parsing FloatDimensionless: unitString is null");
253         Throw.when(unitString.length() == 0, IllegalArgumentException.class,
254                 "Error parsing FloatDimensionless: empty unitString");
255         DimensionlessUnit unit = DimensionlessUnit.BASE.getUnitByAbbreviation(unitString);
256         if (unit != null)
257         {
258             return new FloatDimensionless(value, unit);
259         }
260         throw new IllegalArgumentException("Error parsing FloatDimensionless with unit " + unitString);
261     }
262 
263     /** {@inheritDoc} */
264     @Override
265     public final FloatDimensionless acos()
266     {
267         return instantiateRel((float) Math.acos(getInUnit()), getDisplayUnit());
268     }
269 
270     /** {@inheritDoc} */
271     @Override
272     public final FloatDimensionless asin()
273     {
274         return instantiateRel((float) Math.asin(getInUnit()), getDisplayUnit());
275     }
276 
277     /** {@inheritDoc} */
278     @Override
279     public final FloatDimensionless atan()
280     {
281         return instantiateRel((float) Math.atan(getInUnit()), getDisplayUnit());
282     }
283 
284     /** {@inheritDoc} */
285     @Override
286     public final FloatDimensionless cbrt()
287     {
288         return instantiateRel((float) Math.cbrt(getInUnit()), getDisplayUnit());
289     }
290 
291     /** {@inheritDoc} */
292     @Override
293     public final FloatDimensionless cos()
294     {
295         return instantiateRel((float) Math.cos(getInUnit()), getDisplayUnit());
296     }
297 
298     /** {@inheritDoc} */
299     @Override
300     public final FloatDimensionless cosh()
301     {
302         return instantiateRel((float) Math.cosh(getInUnit()), getDisplayUnit());
303     }
304 
305     /** {@inheritDoc} */
306     @Override
307     public final FloatDimensionless exp()
308     {
309         return instantiateRel((float) Math.exp(getInUnit()), getDisplayUnit());
310     }
311 
312     /** {@inheritDoc} */
313     @Override
314     public final FloatDimensionless expm1()
315     {
316         return instantiateRel((float) Math.expm1(getInUnit()), getDisplayUnit());
317     }
318 
319     /** {@inheritDoc} */
320     @Override
321     public final FloatDimensionless log()
322     {
323         return instantiateRel((float) Math.log(getInUnit()), getDisplayUnit());
324     }
325 
326     /** {@inheritDoc} */
327     @Override
328     public final FloatDimensionless log10()
329     {
330         return instantiateRel((float) Math.log10(getInUnit()), getDisplayUnit());
331     }
332 
333     /** {@inheritDoc} */
334     @Override
335     public final FloatDimensionless log1p()
336     {
337         return instantiateRel((float) Math.log1p(getInUnit()), getDisplayUnit());
338     }
339 
340     /** {@inheritDoc} */
341     @Override
342     public final FloatDimensionless pow(final double x)
343     {
344         return instantiateRel((float) Math.pow(getInUnit(), x), getDisplayUnit());
345     }
346 
347     /** {@inheritDoc} */
348     @Override
349     public final FloatDimensionless signum()
350     {
351         return instantiateRel(Math.signum(getInUnit()), getDisplayUnit());
352     }
353 
354     /** {@inheritDoc} */
355     @Override
356     public final FloatDimensionless sin()
357     {
358         return instantiateRel((float) Math.sin(getInUnit()), getDisplayUnit());
359     }
360 
361     /** {@inheritDoc} */
362     @Override
363     public final FloatDimensionless sinh()
364     {
365         return instantiateRel((float) Math.sinh(getInUnit()), getDisplayUnit());
366     }
367 
368     /** {@inheritDoc} */
369     @Override
370     public final FloatDimensionless sqrt()
371     {
372         return instantiateRel((float) Math.sqrt(getInUnit()), getDisplayUnit());
373     }
374 
375     /** {@inheritDoc} */
376     @Override
377     public final FloatDimensionless tan()
378     {
379         return instantiateRel((float) Math.tan(getInUnit()), getDisplayUnit());
380     }
381 
382     /** {@inheritDoc} */
383     @Override
384     public final FloatDimensionless tanh()
385     {
386         return instantiateRel((float) Math.tanh(getInUnit()), getDisplayUnit());
387     }
388 
389     /** {@inheritDoc} */
390     @Override
391     public final FloatDimensionless inv()
392     {
393         return instantiateRel(1.0f / getInUnit(), getDisplayUnit());
394     }
395 
396     /**
397      * Calculate the division of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
398      * @param v FloatDimensionless scalar
399      * @return FloatDimensionless scalar as a division of FloatDimensionless and FloatDimensionless
400      */
401     public final FloatDimensionlessDimensionless.html#FloatDimensionless">FloatDimensionless divide(final FloatDimensionless v)
402     {
403         return new FloatDimensionless(this.si / v.si, DimensionlessUnit.SI);
404     }
405 
406     /**
407      * Calculate the multiplication of FloatDimensionless and FloatAbsorbedDose, which results in a FloatAbsorbedDose scalar.
408      * @param v FloatDimensionless scalar
409      * @return FloatAbsorbedDose scalar as a multiplication of FloatDimensionless and FloatAbsorbedDose
410      */
411     public final FloatAbsorbedDoseatAbsorbedDose.html#FloatAbsorbedDose">FloatAbsorbedDose times(final FloatAbsorbedDose v)
412     {
413         return new FloatAbsorbedDose(this.si * v.si, AbsorbedDoseUnit.SI);
414     }
415 
416     /**
417      * Calculate the multiplication of FloatDimensionless and FloatAcceleration, which results in a FloatAcceleration scalar.
418      * @param v FloatDimensionless scalar
419      * @return FloatAcceleration scalar as a multiplication of FloatDimensionless and FloatAcceleration
420      */
421     public final FloatAccelerationatAcceleration.html#FloatAcceleration">FloatAcceleration times(final FloatAcceleration v)
422     {
423         return new FloatAcceleration(this.si * v.si, AccelerationUnit.SI);
424     }
425 
426     /**
427      * Calculate the multiplication of FloatDimensionless and FloatAmountOfSubstance, which results in a FloatAmountOfSubstance
428      * scalar.
429      * @param v FloatDimensionless scalar
430      * @return FloatAmountOfSubstance scalar as a multiplication of FloatDimensionless and FloatAmountOfSubstance
431      */
432     public final FloatAmountOfSubstanceuntOfSubstance.html#FloatAmountOfSubstance">FloatAmountOfSubstance times(final FloatAmountOfSubstance v)
433     {
434         return new FloatAmountOfSubstance(this.si * v.si, AmountOfSubstanceUnit.SI);
435     }
436 
437     /**
438      * Calculate the multiplication of FloatDimensionless and FloatAngle, which results in a FloatAngle scalar.
439      * @param v FloatDimensionless scalar
440      * @return FloatAngle scalar as a multiplication of FloatDimensionless and FloatAngle
441      */
442     public final FloatAnglelar/FloatAngle.html#FloatAngle">FloatAngle times(final FloatAngle v)
443     {
444         return new FloatAngle(this.si * v.si, AngleUnit.SI);
445     }
446 
447     /**
448      * Calculate the multiplication of FloatDimensionless and FloatSolidAngle, which results in a FloatSolidAngle scalar.
449      * @param v FloatDimensionless scalar
450      * @return FloatSolidAngle scalar as a multiplication of FloatDimensionless and FloatSolidAngle
451      */
452     public final FloatSolidAngleloatSolidAngle.html#FloatSolidAngle">FloatSolidAngle times(final FloatSolidAngle v)
453     {
454         return new FloatSolidAngle(this.si * v.si, SolidAngleUnit.SI);
455     }
456 
457     /**
458      * Calculate the multiplication of FloatDimensionless and FloatArea, which results in a FloatArea scalar.
459      * @param v FloatDimensionless scalar
460      * @return FloatArea scalar as a multiplication of FloatDimensionless and FloatArea
461      */
462     public final FloatAreaalar/FloatArea.html#FloatArea">FloatArea times(final FloatArea v)
463     {
464         return new FloatArea(this.si * v.si, AreaUnit.SI);
465     }
466 
467     /**
468      * Calculate the multiplication of FloatDimensionless and FloatCatalyticActivity, which results in a FloatCatalyticActivity
469      * scalar.
470      * @param v FloatDimensionless scalar
471      * @return FloatCatalyticActivity scalar as a multiplication of FloatDimensionless and FloatCatalyticActivity
472      */
473     public final FloatCatalyticActivityalyticActivity.html#FloatCatalyticActivity">FloatCatalyticActivity times(final FloatCatalyticActivity v)
474     {
475         return new FloatCatalyticActivity(this.si * v.si, CatalyticActivityUnit.SI);
476     }
477 
478     /**
479      * Calculate the multiplication of FloatDimensionless and FloatDensity, which results in a FloatDensity scalar.
480      * @param v FloatDimensionless scalar
481      * @return FloatDensity scalar as a multiplication of FloatDimensionless and FloatDensity
482      */
483     public final FloatDensityr/FloatDensity.html#FloatDensity">FloatDensity times(final FloatDensity v)
484     {
485         return new FloatDensity(this.si * v.si, DensityUnit.SI);
486     }
487 
488     /**
489      * Calculate the multiplication of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
490      * @param v FloatDimensionless scalar
491      * @return FloatDimensionless scalar as a multiplication of FloatDimensionless and FloatDimensionless
492      */
493     public final FloatDimensionlesstDimensionless.html#FloatDimensionless">FloatDimensionless times(final FloatDimensionless v)
494     {
495         return new FloatDimensionless(this.si * v.si, DimensionlessUnit.SI);
496     }
497 
498     /**
499      * Calculate the multiplication of FloatDimensionless and FloatElectricalCapacitance, which results in a
500      * FloatElectricalCapacitance scalar.
501      * @param v FloatDimensionless scalar
502      * @return FloatElectricalCapacitance scalar as a multiplication of FloatDimensionless and FloatElectricalCapacitance
503      */
504     public final FloatElectricalCapacitancecalCapacitance.html#FloatElectricalCapacitance">FloatElectricalCapacitance times(final FloatElectricalCapacitance v)
505     {
506         return new FloatElectricalCapacitance(this.si * v.si, ElectricalCapacitanceUnit.SI);
507     }
508 
509     /**
510      * Calculate the multiplication of FloatDimensionless and FloatElectricalCharge, which results in a FloatElectricalCharge
511      * scalar.
512      * @param v FloatDimensionless scalar
513      * @return FloatElectricalCharge scalar as a multiplication of FloatDimensionless and FloatElectricalCharge
514      */
515     public final FloatElectricalChargeectricalCharge.html#FloatElectricalCharge">FloatElectricalCharge times(final FloatElectricalCharge v)
516     {
517         return new FloatElectricalCharge(this.si * v.si, ElectricalChargeUnit.SI);
518     }
519 
520     /**
521      * Calculate the multiplication of FloatDimensionless and FloatElectricalConductance, which results in a
522      * FloatElectricalConductance scalar.
523      * @param v FloatDimensionless scalar
524      * @return FloatElectricalConductance scalar as a multiplication of FloatDimensionless and FloatElectricalConductance
525      */
526     public final FloatElectricalConductancecalConductance.html#FloatElectricalConductance">FloatElectricalConductance times(final FloatElectricalConductance v)
527     {
528         return new FloatElectricalConductance(this.si * v.si, ElectricalConductanceUnit.SI);
529     }
530 
531     /**
532      * Calculate the multiplication of FloatDimensionless and FloatElectricalCurrent, which results in a FloatElectricalCurrent
533      * scalar.
534      * @param v FloatDimensionless scalar
535      * @return FloatElectricalCurrent scalar as a multiplication of FloatDimensionless and FloatElectricalCurrent
536      */
537     public final FloatElectricalCurrentctricalCurrent.html#FloatElectricalCurrent">FloatElectricalCurrent times(final FloatElectricalCurrent v)
538     {
539         return new FloatElectricalCurrent(this.si * v.si, ElectricalCurrentUnit.SI);
540     }
541 
542     /**
543      * Calculate the multiplication of FloatDimensionless and FloatElectricalInductance, which results in a
544      * FloatElectricalInductance scalar.
545      * @param v FloatDimensionless scalar
546      * @return FloatElectricalInductance scalar as a multiplication of FloatDimensionless and FloatElectricalInductance
547      */
548     public final FloatElectricalInductanceicalInductance.html#FloatElectricalInductance">FloatElectricalInductance times(final FloatElectricalInductance v)
549     {
550         return new FloatElectricalInductance(this.si * v.si, ElectricalInductanceUnit.SI);
551     }
552 
553     /**
554      * Calculate the multiplication of FloatDimensionless and FloatElectricalPotential, which results in a
555      * FloatElectricalPotential scalar.
556      * @param v FloatDimensionless scalar
557      * @return FloatElectricalPotential scalar as a multiplication of FloatDimensionless and FloatElectricalPotential
558      */
559     public final FloatElectricalPotentialricalPotential.html#FloatElectricalPotential">FloatElectricalPotential times(final FloatElectricalPotential v)
560     {
561         return new FloatElectricalPotential(this.si * v.si, ElectricalPotentialUnit.SI);
562     }
563 
564     /**
565      * Calculate the multiplication of FloatDimensionless and FloatElectricalResistance, which results in a
566      * FloatElectricalResistance scalar.
567      * @param v FloatDimensionless scalar
568      * @return FloatElectricalResistance scalar as a multiplication of FloatDimensionless and FloatElectricalResistance
569      */
570     public final FloatElectricalResistanceicalResistance.html#FloatElectricalResistance">FloatElectricalResistance times(final FloatElectricalResistance v)
571     {
572         return new FloatElectricalResistance(this.si * v.si, ElectricalResistanceUnit.SI);
573     }
574 
575     /**
576      * Calculate the multiplication of FloatDimensionless and FloatEnergy, which results in a FloatEnergy scalar.
577      * @param v FloatDimensionless scalar
578      * @return FloatEnergy scalar as a multiplication of FloatDimensionless and FloatEnergy
579      */
580     public final FloatEnergyar/FloatEnergy.html#FloatEnergy">FloatEnergy times(final FloatEnergy v)
581     {
582         return new FloatEnergy(this.si * v.si, EnergyUnit.SI);
583     }
584 
585     /**
586      * Calculate the multiplication of FloatDimensionless and FloatEquivalentDose, which results in a FloatEquivalentDose
587      * scalar.
588      * @param v FloatDimensionless scalar
589      * @return FloatEquivalentDose scalar as a multiplication of FloatDimensionless and FloatEquivalentDose
590      */
591     public final FloatEquivalentDoseEquivalentDose.html#FloatEquivalentDose">FloatEquivalentDose times(final FloatEquivalentDose v)
592     {
593         return new FloatEquivalentDose(this.si * v.si, EquivalentDoseUnit.SI);
594     }
595 
596     /**
597      * Calculate the multiplication of FloatDimensionless and FloatFlowMass, which results in a FloatFlowMass scalar.
598      * @param v FloatDimensionless scalar
599      * @return FloatFlowMass scalar as a multiplication of FloatDimensionless and FloatFlowMass
600      */
601     public final FloatFlowMass/FloatFlowMass.html#FloatFlowMass">FloatFlowMass times(final FloatFlowMass v)
602     {
603         return new FloatFlowMass(this.si * v.si, FlowMassUnit.SI);
604     }
605 
606     /**
607      * Calculate the multiplication of FloatDimensionless and FloatFlowVolume, which results in a FloatFlowVolume scalar.
608      * @param v FloatDimensionless scalar
609      * @return FloatFlowVolume scalar as a multiplication of FloatDimensionless and FloatFlowVolume
610      */
611     public final FloatFlowVolumeloatFlowVolume.html#FloatFlowVolume">FloatFlowVolume times(final FloatFlowVolume v)
612     {
613         return new FloatFlowVolume(this.si * v.si, FlowVolumeUnit.SI);
614     }
615 
616     /**
617      * Calculate the multiplication of FloatDimensionless and FloatForce, which results in a FloatForce scalar.
618      * @param v FloatDimensionless scalar
619      * @return FloatForce scalar as a multiplication of FloatDimensionless and FloatForce
620      */
621     public final FloatForcelar/FloatForce.html#FloatForce">FloatForce times(final FloatForce v)
622     {
623         return new FloatForce(this.si * v.si, ForceUnit.SI);
624     }
625 
626     /**
627      * Calculate the multiplication of FloatDimensionless and FloatFrequency, which results in a FloatFrequency scalar.
628      * @param v FloatDimensionless scalar
629      * @return FloatFrequency scalar as a multiplication of FloatDimensionless and FloatFrequency
630      */
631     public final FloatFrequencyFloatFrequency.html#FloatFrequency">FloatFrequency times(final FloatFrequency v)
632     {
633         return new FloatFrequency(this.si * v.si, FrequencyUnit.SI);
634     }
635 
636     /**
637      * Calculate the multiplication of FloatDimensionless and FloatIlluminance, which results in a FloatIlluminance scalar.
638      * @param v FloatDimensionless scalar
639      * @return FloatIlluminance scalar as a multiplication of FloatDimensionless and FloatIlluminance
640      */
641     public final FloatIlluminanceoatIlluminance.html#FloatIlluminance">FloatIlluminance times(final FloatIlluminance v)
642     {
643         return new FloatIlluminance(this.si * v.si, IlluminanceUnit.SI);
644     }
645 
646     /**
647      * Calculate the multiplication of FloatDimensionless and FloatLength, which results in a FloatLength scalar.
648      * @param v FloatDimensionless scalar
649      * @return FloatLength scalar as a multiplication of FloatDimensionless and FloatLength
650      */
651     public final FloatLengthar/FloatLength.html#FloatLength">FloatLength times(final FloatLength v)
652     {
653         return new FloatLength(this.si * v.si, LengthUnit.SI);
654     }
655 
656     /**
657      * Calculate the multiplication of FloatDimensionless and FloatLinearDensity, which results in a FloatLinearDensity scalar.
658      * @param v FloatDimensionless scalar
659      * @return FloatLinearDensity scalar as a multiplication of FloatDimensionless and FloatLinearDensity
660      */
661     public final FloatLinearDensitytLinearDensity.html#FloatLinearDensity">FloatLinearDensity times(final FloatLinearDensity v)
662     {
663         return new FloatLinearDensity(this.si * v.si, LinearDensityUnit.SI);
664     }
665 
666     /**
667      * Calculate the multiplication of FloatDimensionless and FloatLuminousFlux, which results in a FloatLuminousFlux scalar.
668      * @param v FloatDimensionless scalar
669      * @return FloatLuminousFlux scalar as a multiplication of FloatDimensionless and FloatLuminousFlux
670      */
671     public final FloatLuminousFluxatLuminousFlux.html#FloatLuminousFlux">FloatLuminousFlux times(final FloatLuminousFlux v)
672     {
673         return new FloatLuminousFlux(this.si * v.si, LuminousFluxUnit.SI);
674     }
675 
676     /**
677      * Calculate the multiplication of FloatDimensionless and FloatLuminousIntensity, which results in a FloatLuminousIntensity
678      * scalar.
679      * @param v FloatDimensionless scalar
680      * @return FloatLuminousIntensity scalar as a multiplication of FloatDimensionless and FloatLuminousIntensity
681      */
682     public final FloatLuminousIntensityinousIntensity.html#FloatLuminousIntensity">FloatLuminousIntensity times(final FloatLuminousIntensity v)
683     {
684         return new FloatLuminousIntensity(this.si * v.si, LuminousIntensityUnit.SI);
685     }
686 
687     /**
688      * Calculate the multiplication of FloatDimensionless and FloatMagneticFluxDensity, which results in a
689      * FloatMagneticFluxDensity scalar.
690      * @param v FloatDimensionless scalar
691      * @return FloatMagneticFluxDensity scalar as a multiplication of FloatDimensionless and FloatMagneticFluxDensity
692      */
693     public final FloatMagneticFluxDensityticFluxDensity.html#FloatMagneticFluxDensity">FloatMagneticFluxDensity times(final FloatMagneticFluxDensity v)
694     {
695         return new FloatMagneticFluxDensity(this.si * v.si, MagneticFluxDensityUnit.SI);
696     }
697 
698     /**
699      * Calculate the multiplication of FloatDimensionless and FloatMagneticFlux, which results in a FloatMagneticFlux scalar.
700      * @param v FloatDimensionless scalar
701      * @return FloatMagneticFlux scalar as a multiplication of FloatDimensionless and FloatMagneticFlux
702      */
703     public final FloatMagneticFluxatMagneticFlux.html#FloatMagneticFlux">FloatMagneticFlux times(final FloatMagneticFlux v)
704     {
705         return new FloatMagneticFlux(this.si * v.si, MagneticFluxUnit.SI);
706     }
707 
708     /**
709      * Calculate the multiplication of FloatDimensionless and FloatMass, which results in a FloatMass scalar.
710      * @param v FloatDimensionless scalar
711      * @return FloatMass scalar as a multiplication of FloatDimensionless and FloatMass
712      */
713     public final FloatMassalar/FloatMass.html#FloatMass">FloatMass times(final FloatMass v)
714     {
715         return new FloatMass(this.si * v.si, MassUnit.SI);
716     }
717 
718     /**
719      * Calculate the multiplication of FloatDimensionless and FloatPower, which results in a FloatPower scalar.
720      * @param v FloatDimensionless scalar
721      * @return FloatPower scalar as a multiplication of FloatDimensionless and FloatPower
722      */
723     public final FloatPowerlar/FloatPower.html#FloatPower">FloatPower times(final FloatPower v)
724     {
725         return new FloatPower(this.si * v.si, PowerUnit.SI);
726     }
727 
728     /**
729      * Calculate the multiplication of FloatDimensionless and FloatPressure, which results in a FloatPressure scalar.
730      * @param v FloatDimensionless scalar
731      * @return FloatPressure scalar as a multiplication of FloatDimensionless and FloatPressure
732      */
733     public final FloatPressure/FloatPressure.html#FloatPressure">FloatPressure times(final FloatPressure v)
734     {
735         return new FloatPressure(this.si * v.si, PressureUnit.SI);
736     }
737 
738     /**
739      * Calculate the multiplication of FloatDimensionless and FloatRadioActivity, which results in a FloatRadioActivity scalar.
740      * @param v FloatDimensionless scalar
741      * @return FloatRadioActivity scalar as a multiplication of FloatDimensionless and FloatRadioActivity
742      */
743     public final FloatRadioActivitytRadioActivity.html#FloatRadioActivity">FloatRadioActivity times(final FloatRadioActivity v)
744     {
745         return new FloatRadioActivity(this.si * v.si, RadioActivityUnit.SI);
746     }
747 
748     /**
749      * Calculate the multiplication of FloatDimensionless and FloatSpeed, which results in a FloatSpeed scalar.
750      * @param v FloatDimensionless scalar
751      * @return FloatSpeed scalar as a multiplication of FloatDimensionless and FloatSpeed
752      */
753     public final FloatSpeedlar/FloatSpeed.html#FloatSpeed">FloatSpeed times(final FloatSpeed v)
754     {
755         return new FloatSpeed(this.si * v.si, SpeedUnit.SI);
756     }
757 
758     /**
759      * Calculate the multiplication of FloatDimensionless and FloatTemperature, which results in a FloatTemperature scalar.
760      * @param v FloatDimensionless scalar
761      * @return FloatTemperature scalar as a multiplication of FloatDimensionless and FloatTemperature
762      */
763     public final FloatTemperatureoatTemperature.html#FloatTemperature">FloatTemperature times(final FloatTemperature v)
764     {
765         return new FloatTemperature(this.si * v.si, TemperatureUnit.SI);
766     }
767 
768     /**
769      * Calculate the multiplication of FloatDimensionless and FloatDuration, which results in a FloatDuration scalar.
770      * @param v FloatDimensionless scalar
771      * @return FloatDuration scalar as a multiplication of FloatDimensionless and FloatDuration
772      */
773     public final FloatDuration/FloatDuration.html#FloatDuration">FloatDuration times(final FloatDuration v)
774     {
775         return new FloatDuration(this.si * v.si, DurationUnit.SI);
776     }
777 
778     /**
779      * Calculate the multiplication of FloatDimensionless and FloatTorque, which results in a FloatTorque scalar.
780      * @param v FloatDimensionless scalar
781      * @return FloatTorque scalar as a multiplication of FloatDimensionless and FloatTorque
782      */
783     public final FloatTorquear/FloatTorque.html#FloatTorque">FloatTorque times(final FloatTorque v)
784     {
785         return new FloatTorque(this.si * v.si, TorqueUnit.SI);
786     }
787 
788     /**
789      * Calculate the multiplication of FloatDimensionless and FloatVolume, which results in a FloatVolume scalar.
790      * @param v FloatDimensionless scalar
791      * @return FloatVolume scalar as a multiplication of FloatDimensionless and FloatVolume
792      */
793     public final FloatVolumear/FloatVolume.html#FloatVolume">FloatVolume times(final FloatVolume v)
794     {
795         return new FloatVolume(this.si * v.si, VolumeUnit.SI);
796     }
797 
798     /**
799      * Calculate the division of FloatDimensionless and FloatLength, which results in a FloatLinearDensity scalar.
800      * @param v FloatDimensionless scalar
801      * @return FloatLinearDensity scalar as a division of FloatDimensionless and FloatLength
802      */
803     public final FloatLinearDensity divide(final FloatLength v)
804     {
805         return new FloatLinearDensity(this.si / v.si, LinearDensityUnit.SI);
806     }
807 
808     /**
809      * Calculate the division of FloatDimensionless and FloatLinearDensity, which results in a FloatLength scalar.
810      * @param v FloatDimensionless scalar
811      * @return FloatLength scalar as a division of FloatDimensionless and FloatLinearDensity
812      */
813     public final FloatLength divide(final FloatLinearDensity v)
814     {
815         return new FloatLength(this.si / v.si, LengthUnit.SI);
816     }
817 
818     /**
819      * Calculate the division of FloatDimensionless and FloatDuration, which results in a FloatFrequency scalar.
820      * @param v FloatDimensionless scalar
821      * @return FloatFrequency scalar as a division of FloatDimensionless and FloatDuration
822      */
823     public final FloatFrequency divide(final FloatDuration v)
824     {
825         return new FloatFrequency(this.si / v.si, FrequencyUnit.SI);
826     }
827 
828     /**
829      * Calculate the division of FloatDimensionless and FloatFrequency, which results in a FloatDuration scalar.
830      * @param v FloatDimensionless scalar
831      * @return FloatDuration scalar as a division of FloatDimensionless and FloatFrequency
832      */
833     public final FloatDuration divide(final FloatFrequency v)
834     {
835         return new FloatDuration(this.si / v.si, DurationUnit.SI);
836     }
837 
838 }