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-2022 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 = "2022-03-14T11:14:15.180987200Z")
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 String toStringSIPrefixed(final int smallestPower, final int biggestPower)
266     {
267         return toString();
268     }
269 
270     /** {@inheritDoc} */
271     @Override
272     public final FloatDimensionless acos()
273     {
274         return instantiateRel((float) Math.acos(getInUnit()), getDisplayUnit());
275     }
276 
277     /** {@inheritDoc} */
278     @Override
279     public final FloatDimensionless asin()
280     {
281         return instantiateRel((float) Math.asin(getInUnit()), getDisplayUnit());
282     }
283 
284     /** {@inheritDoc} */
285     @Override
286     public final FloatDimensionless atan()
287     {
288         return instantiateRel((float) Math.atan(getInUnit()), getDisplayUnit());
289     }
290 
291     /** {@inheritDoc} */
292     @Override
293     public final FloatDimensionless cbrt()
294     {
295         return instantiateRel((float) Math.cbrt(getInUnit()), getDisplayUnit());
296     }
297 
298     /** {@inheritDoc} */
299     @Override
300     public final FloatDimensionless cos()
301     {
302         return instantiateRel((float) Math.cos(getInUnit()), getDisplayUnit());
303     }
304 
305     /** {@inheritDoc} */
306     @Override
307     public final FloatDimensionless cosh()
308     {
309         return instantiateRel((float) Math.cosh(getInUnit()), getDisplayUnit());
310     }
311 
312     /** {@inheritDoc} */
313     @Override
314     public final FloatDimensionless exp()
315     {
316         return instantiateRel((float) Math.exp(getInUnit()), getDisplayUnit());
317     }
318 
319     /** {@inheritDoc} */
320     @Override
321     public final FloatDimensionless expm1()
322     {
323         return instantiateRel((float) Math.expm1(getInUnit()), getDisplayUnit());
324     }
325 
326     /** {@inheritDoc} */
327     @Override
328     public final FloatDimensionless log()
329     {
330         return instantiateRel((float) Math.log(getInUnit()), getDisplayUnit());
331     }
332 
333     /** {@inheritDoc} */
334     @Override
335     public final FloatDimensionless log10()
336     {
337         return instantiateRel((float) Math.log10(getInUnit()), getDisplayUnit());
338     }
339 
340     /** {@inheritDoc} */
341     @Override
342     public final FloatDimensionless log1p()
343     {
344         return instantiateRel((float) Math.log1p(getInUnit()), getDisplayUnit());
345     }
346 
347     /** {@inheritDoc} */
348     @Override
349     public final FloatDimensionless pow(final double x)
350     {
351         return instantiateRel((float) Math.pow(getInUnit(), x), getDisplayUnit());
352     }
353 
354     /** {@inheritDoc} */
355     @Override
356     public final FloatDimensionless signum()
357     {
358         return instantiateRel(Math.signum(getInUnit()), getDisplayUnit());
359     }
360 
361     /** {@inheritDoc} */
362     @Override
363     public final FloatDimensionless sin()
364     {
365         return instantiateRel((float) Math.sin(getInUnit()), getDisplayUnit());
366     }
367 
368     /** {@inheritDoc} */
369     @Override
370     public final FloatDimensionless sinh()
371     {
372         return instantiateRel((float) Math.sinh(getInUnit()), getDisplayUnit());
373     }
374 
375     /** {@inheritDoc} */
376     @Override
377     public final FloatDimensionless sqrt()
378     {
379         return instantiateRel((float) Math.sqrt(getInUnit()), getDisplayUnit());
380     }
381 
382     /** {@inheritDoc} */
383     @Override
384     public final FloatDimensionless tan()
385     {
386         return instantiateRel((float) Math.tan(getInUnit()), getDisplayUnit());
387     }
388 
389     /** {@inheritDoc} */
390     @Override
391     public final FloatDimensionless tanh()
392     {
393         return instantiateRel((float) Math.tanh(getInUnit()), getDisplayUnit());
394     }
395 
396     /** {@inheritDoc} */
397     @Override
398     public final FloatDimensionless inv()
399     {
400         return instantiateRel(1.0f / getInUnit(), getDisplayUnit());
401     }
402 
403     /**
404      * Calculate the division of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
405      * @param v FloatDimensionless; scalar
406      * @return FloatDimensionless; scalar as a division of FloatDimensionless and FloatDimensionless
407      */
408     public final FloatDimensionlessDimensionless.html#FloatDimensionless">FloatDimensionless divide(final FloatDimensionless v)
409     {
410         return new FloatDimensionless(this.si / v.si, DimensionlessUnit.SI);
411     }
412 
413     /**
414      * Calculate the multiplication of FloatDimensionless and FloatAbsorbedDose, which results in a FloatAbsorbedDose scalar.
415      * @param v FloatDimensionless; scalar
416      * @return FloatAbsorbedDose; scalar as a multiplication of FloatDimensionless and FloatAbsorbedDose
417      */
418     public final FloatAbsorbedDoseatAbsorbedDose.html#FloatAbsorbedDose">FloatAbsorbedDose times(final FloatAbsorbedDose v)
419     {
420         return new FloatAbsorbedDose(this.si * v.si, AbsorbedDoseUnit.SI);
421     }
422 
423     /**
424      * Calculate the multiplication of FloatDimensionless and FloatAcceleration, which results in a FloatAcceleration scalar.
425      * @param v FloatDimensionless; scalar
426      * @return FloatAcceleration; scalar as a multiplication of FloatDimensionless and FloatAcceleration
427      */
428     public final FloatAccelerationatAcceleration.html#FloatAcceleration">FloatAcceleration times(final FloatAcceleration v)
429     {
430         return new FloatAcceleration(this.si * v.si, AccelerationUnit.SI);
431     }
432 
433     /**
434      * Calculate the multiplication of FloatDimensionless and FloatAmountOfSubstance, which results in a FloatAmountOfSubstance
435      * scalar.
436      * @param v FloatDimensionless; scalar
437      * @return FloatAmountOfSubstance; scalar as a multiplication of FloatDimensionless and FloatAmountOfSubstance
438      */
439     public final FloatAmountOfSubstanceuntOfSubstance.html#FloatAmountOfSubstance">FloatAmountOfSubstance times(final FloatAmountOfSubstance v)
440     {
441         return new FloatAmountOfSubstance(this.si * v.si, AmountOfSubstanceUnit.SI);
442     }
443 
444     /**
445      * Calculate the multiplication of FloatDimensionless and FloatAngle, which results in a FloatAngle scalar.
446      * @param v FloatDimensionless; scalar
447      * @return FloatAngle; scalar as a multiplication of FloatDimensionless and FloatAngle
448      */
449     public final FloatAnglelar/FloatAngle.html#FloatAngle">FloatAngle times(final FloatAngle v)
450     {
451         return new FloatAngle(this.si * v.si, AngleUnit.SI);
452     }
453 
454     /**
455      * Calculate the multiplication of FloatDimensionless and FloatSolidAngle, which results in a FloatSolidAngle scalar.
456      * @param v FloatDimensionless; scalar
457      * @return FloatSolidAngle; scalar as a multiplication of FloatDimensionless and FloatSolidAngle
458      */
459     public final FloatSolidAngleloatSolidAngle.html#FloatSolidAngle">FloatSolidAngle times(final FloatSolidAngle v)
460     {
461         return new FloatSolidAngle(this.si * v.si, SolidAngleUnit.SI);
462     }
463 
464     /**
465      * Calculate the multiplication of FloatDimensionless and FloatArea, which results in a FloatArea scalar.
466      * @param v FloatDimensionless; scalar
467      * @return FloatArea; scalar as a multiplication of FloatDimensionless and FloatArea
468      */
469     public final FloatAreaalar/FloatArea.html#FloatArea">FloatArea times(final FloatArea v)
470     {
471         return new FloatArea(this.si * v.si, AreaUnit.SI);
472     }
473 
474     /**
475      * Calculate the multiplication of FloatDimensionless and FloatCatalyticActivity, which results in a FloatCatalyticActivity
476      * scalar.
477      * @param v FloatDimensionless; scalar
478      * @return FloatCatalyticActivity; scalar as a multiplication of FloatDimensionless and FloatCatalyticActivity
479      */
480     public final FloatCatalyticActivityalyticActivity.html#FloatCatalyticActivity">FloatCatalyticActivity times(final FloatCatalyticActivity v)
481     {
482         return new FloatCatalyticActivity(this.si * v.si, CatalyticActivityUnit.SI);
483     }
484 
485     /**
486      * Calculate the multiplication of FloatDimensionless and FloatDensity, which results in a FloatDensity scalar.
487      * @param v FloatDimensionless; scalar
488      * @return FloatDensity; scalar as a multiplication of FloatDimensionless and FloatDensity
489      */
490     public final FloatDensityr/FloatDensity.html#FloatDensity">FloatDensity times(final FloatDensity v)
491     {
492         return new FloatDensity(this.si * v.si, DensityUnit.SI);
493     }
494 
495     /**
496      * Calculate the multiplication of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
497      * @param v FloatDimensionless; scalar
498      * @return FloatDimensionless; scalar as a multiplication of FloatDimensionless and FloatDimensionless
499      */
500     public final FloatDimensionlesstDimensionless.html#FloatDimensionless">FloatDimensionless times(final FloatDimensionless v)
501     {
502         return new FloatDimensionless(this.si * v.si, DimensionlessUnit.SI);
503     }
504 
505     /**
506      * Calculate the multiplication of FloatDimensionless and FloatElectricalCapacitance, which results in a
507      * FloatElectricalCapacitance scalar.
508      * @param v FloatDimensionless; scalar
509      * @return FloatElectricalCapacitance; scalar as a multiplication of FloatDimensionless and FloatElectricalCapacitance
510      */
511     public final FloatElectricalCapacitancecalCapacitance.html#FloatElectricalCapacitance">FloatElectricalCapacitance times(final FloatElectricalCapacitance v)
512     {
513         return new FloatElectricalCapacitance(this.si * v.si, ElectricalCapacitanceUnit.SI);
514     }
515 
516     /**
517      * Calculate the multiplication of FloatDimensionless and FloatElectricalCharge, which results in a FloatElectricalCharge
518      * scalar.
519      * @param v FloatDimensionless; scalar
520      * @return FloatElectricalCharge; scalar as a multiplication of FloatDimensionless and FloatElectricalCharge
521      */
522     public final FloatElectricalChargeectricalCharge.html#FloatElectricalCharge">FloatElectricalCharge times(final FloatElectricalCharge v)
523     {
524         return new FloatElectricalCharge(this.si * v.si, ElectricalChargeUnit.SI);
525     }
526 
527     /**
528      * Calculate the multiplication of FloatDimensionless and FloatElectricalConductance, which results in a
529      * FloatElectricalConductance scalar.
530      * @param v FloatDimensionless; scalar
531      * @return FloatElectricalConductance; scalar as a multiplication of FloatDimensionless and FloatElectricalConductance
532      */
533     public final FloatElectricalConductancecalConductance.html#FloatElectricalConductance">FloatElectricalConductance times(final FloatElectricalConductance v)
534     {
535         return new FloatElectricalConductance(this.si * v.si, ElectricalConductanceUnit.SI);
536     }
537 
538     /**
539      * Calculate the multiplication of FloatDimensionless and FloatElectricalCurrent, which results in a FloatElectricalCurrent
540      * scalar.
541      * @param v FloatDimensionless; scalar
542      * @return FloatElectricalCurrent; scalar as a multiplication of FloatDimensionless and FloatElectricalCurrent
543      */
544     public final FloatElectricalCurrentctricalCurrent.html#FloatElectricalCurrent">FloatElectricalCurrent times(final FloatElectricalCurrent v)
545     {
546         return new FloatElectricalCurrent(this.si * v.si, ElectricalCurrentUnit.SI);
547     }
548 
549     /**
550      * Calculate the multiplication of FloatDimensionless and FloatElectricalInductance, which results in a
551      * FloatElectricalInductance scalar.
552      * @param v FloatDimensionless; scalar
553      * @return FloatElectricalInductance; scalar as a multiplication of FloatDimensionless and FloatElectricalInductance
554      */
555     public final FloatElectricalInductanceicalInductance.html#FloatElectricalInductance">FloatElectricalInductance times(final FloatElectricalInductance v)
556     {
557         return new FloatElectricalInductance(this.si * v.si, ElectricalInductanceUnit.SI);
558     }
559 
560     /**
561      * Calculate the multiplication of FloatDimensionless and FloatElectricalPotential, which results in a
562      * FloatElectricalPotential scalar.
563      * @param v FloatDimensionless; scalar
564      * @return FloatElectricalPotential; scalar as a multiplication of FloatDimensionless and FloatElectricalPotential
565      */
566     public final FloatElectricalPotentialricalPotential.html#FloatElectricalPotential">FloatElectricalPotential times(final FloatElectricalPotential v)
567     {
568         return new FloatElectricalPotential(this.si * v.si, ElectricalPotentialUnit.SI);
569     }
570 
571     /**
572      * Calculate the multiplication of FloatDimensionless and FloatElectricalResistance, which results in a
573      * FloatElectricalResistance scalar.
574      * @param v FloatDimensionless; scalar
575      * @return FloatElectricalResistance; scalar as a multiplication of FloatDimensionless and FloatElectricalResistance
576      */
577     public final FloatElectricalResistanceicalResistance.html#FloatElectricalResistance">FloatElectricalResistance times(final FloatElectricalResistance v)
578     {
579         return new FloatElectricalResistance(this.si * v.si, ElectricalResistanceUnit.SI);
580     }
581 
582     /**
583      * Calculate the multiplication of FloatDimensionless and FloatEnergy, which results in a FloatEnergy scalar.
584      * @param v FloatDimensionless; scalar
585      * @return FloatEnergy; scalar as a multiplication of FloatDimensionless and FloatEnergy
586      */
587     public final FloatEnergyar/FloatEnergy.html#FloatEnergy">FloatEnergy times(final FloatEnergy v)
588     {
589         return new FloatEnergy(this.si * v.si, EnergyUnit.SI);
590     }
591 
592     /**
593      * Calculate the multiplication of FloatDimensionless and FloatEquivalentDose, which results in a FloatEquivalentDose
594      * scalar.
595      * @param v FloatDimensionless; scalar
596      * @return FloatEquivalentDose; scalar as a multiplication of FloatDimensionless and FloatEquivalentDose
597      */
598     public final FloatEquivalentDoseEquivalentDose.html#FloatEquivalentDose">FloatEquivalentDose times(final FloatEquivalentDose v)
599     {
600         return new FloatEquivalentDose(this.si * v.si, EquivalentDoseUnit.SI);
601     }
602 
603     /**
604      * Calculate the multiplication of FloatDimensionless and FloatFlowMass, which results in a FloatFlowMass scalar.
605      * @param v FloatDimensionless; scalar
606      * @return FloatFlowMass; scalar as a multiplication of FloatDimensionless and FloatFlowMass
607      */
608     public final FloatFlowMass/FloatFlowMass.html#FloatFlowMass">FloatFlowMass times(final FloatFlowMass v)
609     {
610         return new FloatFlowMass(this.si * v.si, FlowMassUnit.SI);
611     }
612 
613     /**
614      * Calculate the multiplication of FloatDimensionless and FloatFlowVolume, which results in a FloatFlowVolume scalar.
615      * @param v FloatDimensionless; scalar
616      * @return FloatFlowVolume; scalar as a multiplication of FloatDimensionless and FloatFlowVolume
617      */
618     public final FloatFlowVolumeloatFlowVolume.html#FloatFlowVolume">FloatFlowVolume times(final FloatFlowVolume v)
619     {
620         return new FloatFlowVolume(this.si * v.si, FlowVolumeUnit.SI);
621     }
622 
623     /**
624      * Calculate the multiplication of FloatDimensionless and FloatForce, which results in a FloatForce scalar.
625      * @param v FloatDimensionless; scalar
626      * @return FloatForce; scalar as a multiplication of FloatDimensionless and FloatForce
627      */
628     public final FloatForcelar/FloatForce.html#FloatForce">FloatForce times(final FloatForce v)
629     {
630         return new FloatForce(this.si * v.si, ForceUnit.SI);
631     }
632 
633     /**
634      * Calculate the multiplication of FloatDimensionless and FloatFrequency, which results in a FloatFrequency scalar.
635      * @param v FloatDimensionless; scalar
636      * @return FloatFrequency; scalar as a multiplication of FloatDimensionless and FloatFrequency
637      */
638     public final FloatFrequencyFloatFrequency.html#FloatFrequency">FloatFrequency times(final FloatFrequency v)
639     {
640         return new FloatFrequency(this.si * v.si, FrequencyUnit.SI);
641     }
642 
643     /**
644      * Calculate the multiplication of FloatDimensionless and FloatIlluminance, which results in a FloatIlluminance scalar.
645      * @param v FloatDimensionless; scalar
646      * @return FloatIlluminance; scalar as a multiplication of FloatDimensionless and FloatIlluminance
647      */
648     public final FloatIlluminanceoatIlluminance.html#FloatIlluminance">FloatIlluminance times(final FloatIlluminance v)
649     {
650         return new FloatIlluminance(this.si * v.si, IlluminanceUnit.SI);
651     }
652 
653     /**
654      * Calculate the multiplication of FloatDimensionless and FloatLength, which results in a FloatLength scalar.
655      * @param v FloatDimensionless; scalar
656      * @return FloatLength; scalar as a multiplication of FloatDimensionless and FloatLength
657      */
658     public final FloatLengthar/FloatLength.html#FloatLength">FloatLength times(final FloatLength v)
659     {
660         return new FloatLength(this.si * v.si, LengthUnit.SI);
661     }
662 
663     /**
664      * Calculate the multiplication of FloatDimensionless and FloatLinearDensity, which results in a FloatLinearDensity scalar.
665      * @param v FloatDimensionless; scalar
666      * @return FloatLinearDensity; scalar as a multiplication of FloatDimensionless and FloatLinearDensity
667      */
668     public final FloatLinearDensitytLinearDensity.html#FloatLinearDensity">FloatLinearDensity times(final FloatLinearDensity v)
669     {
670         return new FloatLinearDensity(this.si * v.si, LinearDensityUnit.SI);
671     }
672 
673     /**
674      * Calculate the multiplication of FloatDimensionless and FloatLuminousFlux, which results in a FloatLuminousFlux scalar.
675      * @param v FloatDimensionless; scalar
676      * @return FloatLuminousFlux; scalar as a multiplication of FloatDimensionless and FloatLuminousFlux
677      */
678     public final FloatLuminousFluxatLuminousFlux.html#FloatLuminousFlux">FloatLuminousFlux times(final FloatLuminousFlux v)
679     {
680         return new FloatLuminousFlux(this.si * v.si, LuminousFluxUnit.SI);
681     }
682 
683     /**
684      * Calculate the multiplication of FloatDimensionless and FloatLuminousIntensity, which results in a FloatLuminousIntensity
685      * scalar.
686      * @param v FloatDimensionless; scalar
687      * @return FloatLuminousIntensity; scalar as a multiplication of FloatDimensionless and FloatLuminousIntensity
688      */
689     public final FloatLuminousIntensityinousIntensity.html#FloatLuminousIntensity">FloatLuminousIntensity times(final FloatLuminousIntensity v)
690     {
691         return new FloatLuminousIntensity(this.si * v.si, LuminousIntensityUnit.SI);
692     }
693 
694     /**
695      * Calculate the multiplication of FloatDimensionless and FloatMagneticFluxDensity, which results in a
696      * FloatMagneticFluxDensity scalar.
697      * @param v FloatDimensionless; scalar
698      * @return FloatMagneticFluxDensity; scalar as a multiplication of FloatDimensionless and FloatMagneticFluxDensity
699      */
700     public final FloatMagneticFluxDensityticFluxDensity.html#FloatMagneticFluxDensity">FloatMagneticFluxDensity times(final FloatMagneticFluxDensity v)
701     {
702         return new FloatMagneticFluxDensity(this.si * v.si, MagneticFluxDensityUnit.SI);
703     }
704 
705     /**
706      * Calculate the multiplication of FloatDimensionless and FloatMagneticFlux, which results in a FloatMagneticFlux scalar.
707      * @param v FloatDimensionless; scalar
708      * @return FloatMagneticFlux; scalar as a multiplication of FloatDimensionless and FloatMagneticFlux
709      */
710     public final FloatMagneticFluxatMagneticFlux.html#FloatMagneticFlux">FloatMagneticFlux times(final FloatMagneticFlux v)
711     {
712         return new FloatMagneticFlux(this.si * v.si, MagneticFluxUnit.SI);
713     }
714 
715     /**
716      * Calculate the multiplication of FloatDimensionless and FloatMass, which results in a FloatMass scalar.
717      * @param v FloatDimensionless; scalar
718      * @return FloatMass; scalar as a multiplication of FloatDimensionless and FloatMass
719      */
720     public final FloatMassalar/FloatMass.html#FloatMass">FloatMass times(final FloatMass v)
721     {
722         return new FloatMass(this.si * v.si, MassUnit.SI);
723     }
724 
725     /**
726      * Calculate the multiplication of FloatDimensionless and FloatPower, which results in a FloatPower scalar.
727      * @param v FloatDimensionless; scalar
728      * @return FloatPower; scalar as a multiplication of FloatDimensionless and FloatPower
729      */
730     public final FloatPowerlar/FloatPower.html#FloatPower">FloatPower times(final FloatPower v)
731     {
732         return new FloatPower(this.si * v.si, PowerUnit.SI);
733     }
734 
735     /**
736      * Calculate the multiplication of FloatDimensionless and FloatPressure, which results in a FloatPressure scalar.
737      * @param v FloatDimensionless; scalar
738      * @return FloatPressure; scalar as a multiplication of FloatDimensionless and FloatPressure
739      */
740     public final FloatPressure/FloatPressure.html#FloatPressure">FloatPressure times(final FloatPressure v)
741     {
742         return new FloatPressure(this.si * v.si, PressureUnit.SI);
743     }
744 
745     /**
746      * Calculate the multiplication of FloatDimensionless and FloatRadioActivity, which results in a FloatRadioActivity scalar.
747      * @param v FloatDimensionless; scalar
748      * @return FloatRadioActivity; scalar as a multiplication of FloatDimensionless and FloatRadioActivity
749      */
750     public final FloatRadioActivitytRadioActivity.html#FloatRadioActivity">FloatRadioActivity times(final FloatRadioActivity v)
751     {
752         return new FloatRadioActivity(this.si * v.si, RadioActivityUnit.SI);
753     }
754 
755     /**
756      * Calculate the multiplication of FloatDimensionless and FloatSpeed, which results in a FloatSpeed scalar.
757      * @param v FloatDimensionless; scalar
758      * @return FloatSpeed; scalar as a multiplication of FloatDimensionless and FloatSpeed
759      */
760     public final FloatSpeedlar/FloatSpeed.html#FloatSpeed">FloatSpeed times(final FloatSpeed v)
761     {
762         return new FloatSpeed(this.si * v.si, SpeedUnit.SI);
763     }
764 
765     /**
766      * Calculate the multiplication of FloatDimensionless and FloatTemperature, which results in a FloatTemperature scalar.
767      * @param v FloatDimensionless; scalar
768      * @return FloatTemperature; scalar as a multiplication of FloatDimensionless and FloatTemperature
769      */
770     public final FloatTemperatureoatTemperature.html#FloatTemperature">FloatTemperature times(final FloatTemperature v)
771     {
772         return new FloatTemperature(this.si * v.si, TemperatureUnit.SI);
773     }
774 
775     /**
776      * Calculate the multiplication of FloatDimensionless and FloatDuration, which results in a FloatDuration scalar.
777      * @param v FloatDimensionless; scalar
778      * @return FloatDuration; scalar as a multiplication of FloatDimensionless and FloatDuration
779      */
780     public final FloatDuration/FloatDuration.html#FloatDuration">FloatDuration times(final FloatDuration v)
781     {
782         return new FloatDuration(this.si * v.si, DurationUnit.SI);
783     }
784 
785     /**
786      * Calculate the multiplication of FloatDimensionless and FloatTorque, which results in a FloatTorque scalar.
787      * @param v FloatDimensionless; scalar
788      * @return FloatTorque; scalar as a multiplication of FloatDimensionless and FloatTorque
789      */
790     public final FloatTorquear/FloatTorque.html#FloatTorque">FloatTorque times(final FloatTorque v)
791     {
792         return new FloatTorque(this.si * v.si, TorqueUnit.SI);
793     }
794 
795     /**
796      * Calculate the multiplication of FloatDimensionless and FloatVolume, which results in a FloatVolume scalar.
797      * @param v FloatDimensionless; scalar
798      * @return FloatVolume; scalar as a multiplication of FloatDimensionless and FloatVolume
799      */
800     public final FloatVolumear/FloatVolume.html#FloatVolume">FloatVolume times(final FloatVolume v)
801     {
802         return new FloatVolume(this.si * v.si, VolumeUnit.SI);
803     }
804 
805     /**
806      * Calculate the division of FloatDimensionless and FloatLength, which results in a FloatLinearDensity scalar.
807      * @param v FloatDimensionless; scalar
808      * @return FloatLinearDensity; scalar as a division of FloatDimensionless and FloatLength
809      */
810     public final FloatLinearDensity divide(final FloatLength v)
811     {
812         return new FloatLinearDensity(this.si / v.si, LinearDensityUnit.SI);
813     }
814 
815     /**
816      * Calculate the division of FloatDimensionless and FloatLinearDensity, which results in a FloatLength scalar.
817      * @param v FloatDimensionless; scalar
818      * @return FloatLength; scalar as a division of FloatDimensionless and FloatLinearDensity
819      */
820     public final FloatLength divide(final FloatLinearDensity v)
821     {
822         return new FloatLength(this.si / v.si, LengthUnit.SI);
823     }
824 
825     /**
826      * Calculate the division of FloatDimensionless and FloatDuration, which results in a FloatFrequency scalar.
827      * @param v FloatDimensionless; scalar
828      * @return FloatFrequency; scalar as a division of FloatDimensionless and FloatDuration
829      */
830     public final FloatFrequency divide(final FloatDuration v)
831     {
832         return new FloatFrequency(this.si / v.si, FrequencyUnit.SI);
833     }
834 
835     /**
836      * Calculate the division of FloatDimensionless and FloatFrequency, which results in a FloatDuration scalar.
837      * @param v FloatDimensionless; scalar
838      * @return FloatDuration; scalar as a division of FloatDimensionless and FloatFrequency
839      */
840     public final FloatDuration divide(final FloatFrequency v)
841     {
842         return new FloatDuration(this.si / v.si, DurationUnit.SI);
843     }
844 
845     /**
846      * Calculate the division of FloatDimensionless and FloatElectricalConductance, which results in a FloatElectricalResistance
847      * scalar.
848      * @param v FloatDimensionless; scalar
849      * @return FloatElectricalResistance; scalar as a division of FloatDimensionless and FloatElectricalConductance
850      */
851     public final FloatElectricalResistance divide(final FloatElectricalConductance v)
852     {
853         return new FloatElectricalResistance(this.si / v.si, ElectricalResistanceUnit.SI);
854     }
855 
856     /**
857      * Calculate the division of FloatDimensionless and FloatElectricalResistance, which results in a FloatElectricalConductance
858      * scalar.
859      * @param v FloatDimensionless; scalar
860      * @return FloatElectricalConductance; scalar as a division of FloatDimensionless and FloatElectricalResistance
861      */
862     public final FloatElectricalConductance divide(final FloatElectricalResistance v)
863     {
864         return new FloatElectricalConductance(this.si / v.si, ElectricalConductanceUnit.SI);
865     }
866 
867     /** {@inheritDoc} */
868     @Override
869     public FloatDimensionless reciprocal()
870     {
871         return FloatDimensionless.instantiateSI(1.0f / this.si);
872     }
873 
874 }