View Javadoc
1   package org.djunits.value.vdouble.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.vdouble.scalar.base.AbstractDoubleScalarRel;
49  
50  /**
51   * Easy access methods for the Dimensionless DoubleScalar, 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 Dimensionless extends AbstractDoubleScalarRel<DimensionlessUnit, Dimensionless>
61          implements DimensionlessFunctions<DimensionlessUnit, Dimensionless>
62  {
63      /** */
64      private static final long serialVersionUID = 20150905L;
65  
66      /** Constant with value zero. */
67      public static final Dimensionlessar/Dimensionless.html#Dimensionless">Dimensionless ZERO = new Dimensionless(0.0, DimensionlessUnit.SI);
68  
69      /** Constant with value one. */
70      public static final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless ONE = new Dimensionless(1.0, DimensionlessUnit.SI);
71  
72      /** Constant with value NaN. */
73      @SuppressWarnings("checkstyle:constantname")
74      public static final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless NaN = new Dimensionless(Double.NaN, DimensionlessUnit.SI);
75  
76      /** Constant with value POSITIVE_INFINITY. */
77      public static final Dimensionlessess.html#Dimensionless">Dimensionless POSITIVE_INFINITY = new Dimensionless(Double.POSITIVE_INFINITY, DimensionlessUnit.SI);
78  
79      /** Constant with value NEGATIVE_INFINITY. */
80      public static final Dimensionlessess.html#Dimensionless">Dimensionless NEGATIVE_INFINITY = new Dimensionless(Double.NEGATIVE_INFINITY, DimensionlessUnit.SI);
81  
82      /** Constant with value MAX_VALUE. */
83      public static final Dimensionlesssionless.html#Dimensionless">Dimensionless POS_MAXVALUE = new Dimensionless(Double.MAX_VALUE, DimensionlessUnit.SI);
84  
85      /** Constant with value -MAX_VALUE. */
86      public static final Dimensionlesssionless.html#Dimensionless">Dimensionless NEG_MAXVALUE = new Dimensionless(-Double.MAX_VALUE, DimensionlessUnit.SI);
87  
88      /**
89       * Construct Dimensionless scalar.
90       * @param value double; the double value
91       * @param unit DimensionlessUnit; unit for the double value
92       */
93      public Dimensionless(final double value, final DimensionlessUnit unit)
94      {
95          super(value, unit);
96      }
97  
98      /**
99       * Construct Dimensionless scalar.
100      * @param value Dimensionless; Scalar from which to construct this instance
101      */
102     public Dimensionless/scalar/Dimensionless.html#Dimensionless">Dimensionless(final Dimensionless value)
103     {
104         super(value);
105     }
106 
107     /** {@inheritDoc} */
108     @Override
109     public final Dimensionless instantiateRel(final double value, final DimensionlessUnit unit)
110     {
111         return new Dimensionless(value, unit);
112     }
113 
114     /**
115      * Construct Dimensionless scalar.
116      * @param value double; the double value in SI units
117      * @return Dimensionless; the new scalar with the SI value
118      */
119     public static final Dimensionless instantiateSI(final double value)
120     {
121         return new Dimensionless(value, DimensionlessUnit.SI);
122     }
123 
124     /**
125      * Interpolate between two values.
126      * @param zero Dimensionless; the low value
127      * @param one Dimensionless; the high value
128      * @param ratio double; the ratio between 0 and 1, inclusive
129      * @return Dimensionless; a Scalar at the ratio between
130      */
131     public static Dimensionlessr/Dimensionless.html#Dimensionless">Dimensionlessnsionless.html#Dimensionless">Dimensionless interpolate(final Dimensionlessr/Dimensionless.html#Dimensionless">Dimensionless zero, final Dimensionless one, final double ratio)
132     {
133         return new Dimensionless(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getDisplayUnit()) * ratio,
134                 zero.getDisplayUnit());
135     }
136 
137     /**
138      * Return the maximum value of two relative scalars.
139      * @param r1 Dimensionless; the first scalar
140      * @param r2 Dimensionless; the second scalar
141      * @return Dimensionless; the maximum value of two relative scalars
142      */
143     public static Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless max(final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless r1, final Dimensionless r2)
144     {
145         return r1.gt(r2) ? r1 : r2;
146     }
147 
148     /**
149      * Return the maximum value of more than two relative scalars.
150      * @param r1 Dimensionless; the first scalar
151      * @param r2 Dimensionless; the second scalar
152      * @param rn Dimensionless...; the other scalars
153      * @return Dimensionless; the maximum value of more than two relative scalars
154      */
155     public static Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless max(final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless r1, final Dimensionless r2, final Dimensionless... rn)
156     {
157         Dimensionless maxr = r1.gt(r2) ? r1 : r2;
158         for (Dimensionless r : rn)
159         {
160             if (r.gt(maxr))
161             {
162                 maxr = r;
163             }
164         }
165         return maxr;
166     }
167 
168     /**
169      * Return the minimum value of two relative scalars.
170      * @param r1 Dimensionless; the first scalar
171      * @param r2 Dimensionless; the second scalar
172      * @return Dimensionless; the minimum value of two relative scalars
173      */
174     public static Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless min(final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless r1, final Dimensionless r2)
175     {
176         return r1.lt(r2) ? r1 : r2;
177     }
178 
179     /**
180      * Return the minimum value of more than two relative scalars.
181      * @param r1 Dimensionless; the first scalar
182      * @param r2 Dimensionless; the second scalar
183      * @param rn Dimensionless...; the other scalars
184      * @return Dimensionless; the minimum value of more than two relative scalars
185      */
186     public static Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless min(final Dimensionlesslar/Dimensionless.html#Dimensionless">Dimensionless r1, final Dimensionless r2, final Dimensionless... rn)
187     {
188         Dimensionless minr = r1.lt(r2) ? r1 : r2;
189         for (Dimensionless r : rn)
190         {
191             if (r.lt(minr))
192             {
193                 minr = r;
194             }
195         }
196         return minr;
197     }
198 
199     /**
200      * Returns a Dimensionless representation of a textual representation of a value with a unit. The String representation that
201      * can be parsed is the double value in the unit, followed by the official abbreviation of the unit. Spaces are allowed, but
202      * not required, between the value and the unit.
203      * @param text String; the textual representation to parse into a Dimensionless
204      * @return Dimensionless; the Scalar representation of the value in its unit
205      * @throws IllegalArgumentException when the text cannot be parsed
206      * @throws NullPointerException when the text argument is null
207      */
208     public static Dimensionless valueOf(final String text)
209     {
210         Throw.whenNull(text, "Error parsing Dimensionless: text to parse is null");
211         Throw.when(text.length() == 0, IllegalArgumentException.class, "Error parsing Dimensionless: empty text to parse");
212         Matcher matcher = ValueUtil.NUMBER_PATTERN.matcher(text);
213         if (matcher.find())
214         {
215             int index = matcher.end();
216             String unitString = text.substring(index).trim();
217             String valueString = text.substring(0, index).trim();
218             DimensionlessUnit unit = DimensionlessUnit.BASE.getUnitByAbbreviation(unitString);
219             if (unit != null)
220             {
221                 double d = Double.parseDouble(valueString);
222                 return new Dimensionless(d, unit);
223             }
224         }
225         throw new IllegalArgumentException("Error parsing Dimensionless from " + text);
226     }
227 
228     /**
229      * Returns a Dimensionless based on a value and the textual representation of the unit.
230      * @param value double; the value to use
231      * @param unitString String; the textual representation of the unit
232      * @return Dimensionless; the Scalar representation of the value in its unit
233      * @throws IllegalArgumentException when the unit cannot be parsed or is incorrect
234      * @throws NullPointerException when the unitString argument is null
235      */
236     public static Dimensionless of(final double value, final String unitString)
237     {
238         Throw.whenNull(unitString, "Error parsing Dimensionless: unitString is null");
239         Throw.when(unitString.length() == 0, IllegalArgumentException.class, "Error parsing Dimensionless: empty unitString");
240         DimensionlessUnit unit = DimensionlessUnit.BASE.getUnitByAbbreviation(unitString);
241         if (unit != null)
242         {
243             return new Dimensionless(value, unit);
244         }
245         throw new IllegalArgumentException("Error parsing Dimensionless with unit " + unitString);
246     }
247 
248     /** {@inheritDoc} */
249     @Override
250     public String toStringSIPrefixed(final int smallestPower, final int biggestPower)
251     {
252         return toString();
253     }
254 
255     /** {@inheritDoc} */
256     @Override
257     public final Dimensionless acos()
258     {
259         return instantiateRel(Math.acos(getInUnit()), getDisplayUnit());
260     }
261 
262     /** {@inheritDoc} */
263     @Override
264     public final Dimensionless asin()
265     {
266         return instantiateRel(Math.asin(getInUnit()), getDisplayUnit());
267     }
268 
269     /** {@inheritDoc} */
270     @Override
271     public final Dimensionless atan()
272     {
273         return instantiateRel(Math.atan(getInUnit()), getDisplayUnit());
274     }
275 
276     /** {@inheritDoc} */
277     @Override
278     public final Dimensionless cbrt()
279     {
280         return instantiateRel(Math.cbrt(getInUnit()), getDisplayUnit());
281     }
282 
283     /** {@inheritDoc} */
284     @Override
285     public final Dimensionless cos()
286     {
287         return instantiateRel(Math.cos(getInUnit()), getDisplayUnit());
288     }
289 
290     /** {@inheritDoc} */
291     @Override
292     public final Dimensionless cosh()
293     {
294         return instantiateRel(Math.cosh(getInUnit()), getDisplayUnit());
295     }
296 
297     /** {@inheritDoc} */
298     @Override
299     public final Dimensionless exp()
300     {
301         return instantiateRel(Math.exp(getInUnit()), getDisplayUnit());
302     }
303 
304     /** {@inheritDoc} */
305     @Override
306     public final Dimensionless expm1()
307     {
308         return instantiateRel(Math.expm1(getInUnit()), getDisplayUnit());
309     }
310 
311     /** {@inheritDoc} */
312     @Override
313     public final Dimensionless log()
314     {
315         return instantiateRel(Math.log(getInUnit()), getDisplayUnit());
316     }
317 
318     /** {@inheritDoc} */
319     @Override
320     public final Dimensionless log10()
321     {
322         return instantiateRel(Math.log10(getInUnit()), getDisplayUnit());
323     }
324 
325     /** {@inheritDoc} */
326     @Override
327     public final Dimensionless log1p()
328     {
329         return instantiateRel(Math.log1p(getInUnit()), getDisplayUnit());
330     }
331 
332     /** {@inheritDoc} */
333     @Override
334     public final Dimensionless pow(final double x)
335     {
336         return instantiateRel(Math.pow(getInUnit(), x), getDisplayUnit());
337     }
338 
339     /** {@inheritDoc} */
340     @Override
341     public final Dimensionless signum()
342     {
343         return instantiateRel(Math.signum(getInUnit()), getDisplayUnit());
344     }
345 
346     /** {@inheritDoc} */
347     @Override
348     public final Dimensionless sin()
349     {
350         return instantiateRel(Math.sin(getInUnit()), getDisplayUnit());
351     }
352 
353     /** {@inheritDoc} */
354     @Override
355     public final Dimensionless sinh()
356     {
357         return instantiateRel(Math.sinh(getInUnit()), getDisplayUnit());
358     }
359 
360     /** {@inheritDoc} */
361     @Override
362     public final Dimensionless sqrt()
363     {
364         return instantiateRel(Math.sqrt(getInUnit()), getDisplayUnit());
365     }
366 
367     /** {@inheritDoc} */
368     @Override
369     public final Dimensionless tan()
370     {
371         return instantiateRel(Math.tan(getInUnit()), getDisplayUnit());
372     }
373 
374     /** {@inheritDoc} */
375     @Override
376     public final Dimensionless tanh()
377     {
378         return instantiateRel(Math.tanh(getInUnit()), getDisplayUnit());
379     }
380 
381     /** {@inheritDoc} */
382     @Override
383     public final Dimensionless inv()
384     {
385         return instantiateRel(1.0 / getInUnit(), getDisplayUnit());
386     }
387 
388     /**
389      * Calculate the division of Dimensionless and Dimensionless, which results in a Dimensionless scalar.
390      * @param v Dimensionless; scalar
391      * @return Dimensionless; scalar as a division of Dimensionless and Dimensionless
392      */
393     public final Dimensionless/Dimensionless.html#Dimensionless">Dimensionless divide(final Dimensionless v)
394     {
395         return new Dimensionless(this.si / v.si, DimensionlessUnit.SI);
396     }
397 
398     /**
399      * Calculate the multiplication of Dimensionless and AbsorbedDose, which results in a AbsorbedDose scalar.
400      * @param v Dimensionless; scalar
401      * @return AbsorbedDose; scalar as a multiplication of Dimensionless and AbsorbedDose
402      */
403     public final AbsorbedDosear/AbsorbedDose.html#AbsorbedDose">AbsorbedDose times(final AbsorbedDose v)
404     {
405         return new AbsorbedDose(this.si * v.si, AbsorbedDoseUnit.SI);
406     }
407 
408     /**
409      * Calculate the multiplication of Dimensionless and Acceleration, which results in a Acceleration scalar.
410      * @param v Dimensionless; scalar
411      * @return Acceleration; scalar as a multiplication of Dimensionless and Acceleration
412      */
413     public final Accelerationar/Acceleration.html#Acceleration">Acceleration times(final Acceleration v)
414     {
415         return new Acceleration(this.si * v.si, AccelerationUnit.SI);
416     }
417 
418     /**
419      * Calculate the multiplication of Dimensionless and AmountOfSubstance, which results in a AmountOfSubstance scalar.
420      * @param v Dimensionless; scalar
421      * @return AmountOfSubstance; scalar as a multiplication of Dimensionless and AmountOfSubstance
422      */
423     public final AmountOfSubstanceountOfSubstance.html#AmountOfSubstance">AmountOfSubstance times(final AmountOfSubstance v)
424     {
425         return new AmountOfSubstance(this.si * v.si, AmountOfSubstanceUnit.SI);
426     }
427 
428     /**
429      * Calculate the multiplication of Dimensionless and Angle, which results in a Angle scalar.
430      * @param v Dimensionless; scalar
431      * @return Angle; scalar as a multiplication of Dimensionless and Angle
432      */
433     public final Anglele/scalar/Angle.html#Angle">Angle times(final Angle v)
434     {
435         return new Angle(this.si * v.si, AngleUnit.SI);
436     }
437 
438     /**
439      * Calculate the multiplication of Dimensionless and SolidAngle, which results in a SolidAngle scalar.
440      * @param v Dimensionless; scalar
441      * @return SolidAngle; scalar as a multiplication of Dimensionless and SolidAngle
442      */
443     public final SolidAnglealar/SolidAngle.html#SolidAngle">SolidAngle times(final SolidAngle v)
444     {
445         return new SolidAngle(this.si * v.si, SolidAngleUnit.SI);
446     }
447 
448     /**
449      * Calculate the multiplication of Dimensionless and Area, which results in a Area scalar.
450      * @param v Dimensionless; scalar
451      * @return Area; scalar as a multiplication of Dimensionless and Area
452      */
453     public final Areable/scalar/Area.html#Area">Area times(final Area v)
454     {
455         return new Area(this.si * v.si, AreaUnit.SI);
456     }
457 
458     /**
459      * Calculate the multiplication of Dimensionless and CatalyticActivity, which results in a CatalyticActivity scalar.
460      * @param v Dimensionless; scalar
461      * @return CatalyticActivity; scalar as a multiplication of Dimensionless and CatalyticActivity
462      */
463     public final CatalyticActivitytalyticActivity.html#CatalyticActivity">CatalyticActivity times(final CatalyticActivity v)
464     {
465         return new CatalyticActivity(this.si * v.si, CatalyticActivityUnit.SI);
466     }
467 
468     /**
469      * Calculate the multiplication of Dimensionless and Density, which results in a Density scalar.
470      * @param v Dimensionless; scalar
471      * @return Density; scalar as a multiplication of Dimensionless and Density
472      */
473     public final Density/scalar/Density.html#Density">Density times(final Density v)
474     {
475         return new Density(this.si * v.si, DensityUnit.SI);
476     }
477 
478     /**
479      * Calculate the multiplication of Dimensionless and Dimensionless, which results in a Dimensionless scalar.
480      * @param v Dimensionless; scalar
481      * @return Dimensionless; scalar as a multiplication of Dimensionless and Dimensionless
482      */
483     public final Dimensionlessr/Dimensionless.html#Dimensionless">Dimensionless times(final Dimensionless v)
484     {
485         return new Dimensionless(this.si * v.si, DimensionlessUnit.SI);
486     }
487 
488     /**
489      * Calculate the multiplication of Dimensionless and ElectricalCapacitance, which results in a ElectricalCapacitance scalar.
490      * @param v Dimensionless; scalar
491      * @return ElectricalCapacitance; scalar as a multiplication of Dimensionless and ElectricalCapacitance
492      */
493     public final ElectricalCapacitanceicalCapacitance.html#ElectricalCapacitance">ElectricalCapacitance times(final ElectricalCapacitance v)
494     {
495         return new ElectricalCapacitance(this.si * v.si, ElectricalCapacitanceUnit.SI);
496     }
497 
498     /**
499      * Calculate the multiplication of Dimensionless and ElectricalCharge, which results in a ElectricalCharge scalar.
500      * @param v Dimensionless; scalar
501      * @return ElectricalCharge; scalar as a multiplication of Dimensionless and ElectricalCharge
502      */
503     public final ElectricalChargelectricalCharge.html#ElectricalCharge">ElectricalCharge times(final ElectricalCharge v)
504     {
505         return new ElectricalCharge(this.si * v.si, ElectricalChargeUnit.SI);
506     }
507 
508     /**
509      * Calculate the multiplication of Dimensionless and ElectricalConductance, which results in a ElectricalConductance scalar.
510      * @param v Dimensionless; scalar
511      * @return ElectricalConductance; scalar as a multiplication of Dimensionless and ElectricalConductance
512      */
513     public final ElectricalConductanceicalConductance.html#ElectricalConductance">ElectricalConductance times(final ElectricalConductance v)
514     {
515         return new ElectricalConductance(this.si * v.si, ElectricalConductanceUnit.SI);
516     }
517 
518     /**
519      * Calculate the multiplication of Dimensionless and ElectricalCurrent, which results in a ElectricalCurrent scalar.
520      * @param v Dimensionless; scalar
521      * @return ElectricalCurrent; scalar as a multiplication of Dimensionless and ElectricalCurrent
522      */
523     public final ElectricalCurrentectricalCurrent.html#ElectricalCurrent">ElectricalCurrent times(final ElectricalCurrent v)
524     {
525         return new ElectricalCurrent(this.si * v.si, ElectricalCurrentUnit.SI);
526     }
527 
528     /**
529      * Calculate the multiplication of Dimensionless and ElectricalInductance, which results in a ElectricalInductance scalar.
530      * @param v Dimensionless; scalar
531      * @return ElectricalInductance; scalar as a multiplication of Dimensionless and ElectricalInductance
532      */
533     public final ElectricalInductancericalInductance.html#ElectricalInductance">ElectricalInductance times(final ElectricalInductance v)
534     {
535         return new ElectricalInductance(this.si * v.si, ElectricalInductanceUnit.SI);
536     }
537 
538     /**
539      * Calculate the multiplication of Dimensionless and ElectricalPotential, which results in a ElectricalPotential scalar.
540      * @param v Dimensionless; scalar
541      * @return ElectricalPotential; scalar as a multiplication of Dimensionless and ElectricalPotential
542      */
543     public final ElectricalPotentialtricalPotential.html#ElectricalPotential">ElectricalPotential times(final ElectricalPotential v)
544     {
545         return new ElectricalPotential(this.si * v.si, ElectricalPotentialUnit.SI);
546     }
547 
548     /**
549      * Calculate the multiplication of Dimensionless and ElectricalResistance, which results in a ElectricalResistance scalar.
550      * @param v Dimensionless; scalar
551      * @return ElectricalResistance; scalar as a multiplication of Dimensionless and ElectricalResistance
552      */
553     public final ElectricalResistancericalResistance.html#ElectricalResistance">ElectricalResistance times(final ElectricalResistance v)
554     {
555         return new ElectricalResistance(this.si * v.si, ElectricalResistanceUnit.SI);
556     }
557 
558     /**
559      * Calculate the multiplication of Dimensionless and Energy, which results in a Energy scalar.
560      * @param v Dimensionless; scalar
561      * @return Energy; scalar as a multiplication of Dimensionless and Energy
562      */
563     public final Energye/scalar/Energy.html#Energy">Energy times(final Energy v)
564     {
565         return new Energy(this.si * v.si, EnergyUnit.SI);
566     }
567 
568     /**
569      * Calculate the multiplication of Dimensionless and EquivalentDose, which results in a EquivalentDose scalar.
570      * @param v Dimensionless; scalar
571      * @return EquivalentDose; scalar as a multiplication of Dimensionless and EquivalentDose
572      */
573     public final EquivalentDose/EquivalentDose.html#EquivalentDose">EquivalentDose times(final EquivalentDose v)
574     {
575         return new EquivalentDose(this.si * v.si, EquivalentDoseUnit.SI);
576     }
577 
578     /**
579      * Calculate the multiplication of Dimensionless and FlowMass, which results in a FlowMass scalar.
580      * @param v Dimensionless; scalar
581      * @return FlowMass; scalar as a multiplication of Dimensionless and FlowMass
582      */
583     public final FlowMassscalar/FlowMass.html#FlowMass">FlowMass times(final FlowMass v)
584     {
585         return new FlowMass(this.si * v.si, FlowMassUnit.SI);
586     }
587 
588     /**
589      * Calculate the multiplication of Dimensionless and FlowVolume, which results in a FlowVolume scalar.
590      * @param v Dimensionless; scalar
591      * @return FlowVolume; scalar as a multiplication of Dimensionless and FlowVolume
592      */
593     public final FlowVolumealar/FlowVolume.html#FlowVolume">FlowVolume times(final FlowVolume v)
594     {
595         return new FlowVolume(this.si * v.si, FlowVolumeUnit.SI);
596     }
597 
598     /**
599      * Calculate the multiplication of Dimensionless and Force, which results in a Force scalar.
600      * @param v Dimensionless; scalar
601      * @return Force; scalar as a multiplication of Dimensionless and Force
602      */
603     public final Forcele/scalar/Force.html#Force">Force times(final Force v)
604     {
605         return new Force(this.si * v.si, ForceUnit.SI);
606     }
607 
608     /**
609      * Calculate the multiplication of Dimensionless and Frequency, which results in a Frequency scalar.
610      * @param v Dimensionless; scalar
611      * @return Frequency; scalar as a multiplication of Dimensionless and Frequency
612      */
613     public final Frequencycalar/Frequency.html#Frequency">Frequency times(final Frequency v)
614     {
615         return new Frequency(this.si * v.si, FrequencyUnit.SI);
616     }
617 
618     /**
619      * Calculate the multiplication of Dimensionless and Illuminance, which results in a Illuminance scalar.
620      * @param v Dimensionless; scalar
621      * @return Illuminance; scalar as a multiplication of Dimensionless and Illuminance
622      */
623     public final Illuminancelar/Illuminance.html#Illuminance">Illuminance times(final Illuminance v)
624     {
625         return new Illuminance(this.si * v.si, IlluminanceUnit.SI);
626     }
627 
628     /**
629      * Calculate the multiplication of Dimensionless and Length, which results in a Length scalar.
630      * @param v Dimensionless; scalar
631      * @return Length; scalar as a multiplication of Dimensionless and Length
632      */
633     public final Lengthe/scalar/Length.html#Length">Length times(final Length v)
634     {
635         return new Length(this.si * v.si, LengthUnit.SI);
636     }
637 
638     /**
639      * Calculate the multiplication of Dimensionless and LinearDensity, which results in a LinearDensity scalar.
640      * @param v Dimensionless; scalar
641      * @return LinearDensity; scalar as a multiplication of Dimensionless and LinearDensity
642      */
643     public final LinearDensityr/LinearDensity.html#LinearDensity">LinearDensity times(final LinearDensity v)
644     {
645         return new LinearDensity(this.si * v.si, LinearDensityUnit.SI);
646     }
647 
648     /**
649      * Calculate the multiplication of Dimensionless and LuminousFlux, which results in a LuminousFlux scalar.
650      * @param v Dimensionless; scalar
651      * @return LuminousFlux; scalar as a multiplication of Dimensionless and LuminousFlux
652      */
653     public final LuminousFluxar/LuminousFlux.html#LuminousFlux">LuminousFlux times(final LuminousFlux v)
654     {
655         return new LuminousFlux(this.si * v.si, LuminousFluxUnit.SI);
656     }
657 
658     /**
659      * Calculate the multiplication of Dimensionless and LuminousIntensity, which results in a LuminousIntensity scalar.
660      * @param v Dimensionless; scalar
661      * @return LuminousIntensity; scalar as a multiplication of Dimensionless and LuminousIntensity
662      */
663     public final LuminousIntensityminousIntensity.html#LuminousIntensity">LuminousIntensity times(final LuminousIntensity v)
664     {
665         return new LuminousIntensity(this.si * v.si, LuminousIntensityUnit.SI);
666     }
667 
668     /**
669      * Calculate the multiplication of Dimensionless and MagneticFluxDensity, which results in a MagneticFluxDensity scalar.
670      * @param v Dimensionless; scalar
671      * @return MagneticFluxDensity; scalar as a multiplication of Dimensionless and MagneticFluxDensity
672      */
673     public final MagneticFluxDensityeticFluxDensity.html#MagneticFluxDensity">MagneticFluxDensity times(final MagneticFluxDensity v)
674     {
675         return new MagneticFluxDensity(this.si * v.si, MagneticFluxDensityUnit.SI);
676     }
677 
678     /**
679      * Calculate the multiplication of Dimensionless and MagneticFlux, which results in a MagneticFlux scalar.
680      * @param v Dimensionless; scalar
681      * @return MagneticFlux; scalar as a multiplication of Dimensionless and MagneticFlux
682      */
683     public final MagneticFluxar/MagneticFlux.html#MagneticFlux">MagneticFlux times(final MagneticFlux v)
684     {
685         return new MagneticFlux(this.si * v.si, MagneticFluxUnit.SI);
686     }
687 
688     /**
689      * Calculate the multiplication of Dimensionless and Mass, which results in a Mass scalar.
690      * @param v Dimensionless; scalar
691      * @return Mass; scalar as a multiplication of Dimensionless and Mass
692      */
693     public final Massble/scalar/Mass.html#Mass">Mass times(final Mass v)
694     {
695         return new Mass(this.si * v.si, MassUnit.SI);
696     }
697 
698     /**
699      * Calculate the multiplication of Dimensionless and Power, which results in a Power scalar.
700      * @param v Dimensionless; scalar
701      * @return Power; scalar as a multiplication of Dimensionless and Power
702      */
703     public final Powerle/scalar/Power.html#Power">Power times(final Power v)
704     {
705         return new Power(this.si * v.si, PowerUnit.SI);
706     }
707 
708     /**
709      * Calculate the multiplication of Dimensionless and Pressure, which results in a Pressure scalar.
710      * @param v Dimensionless; scalar
711      * @return Pressure; scalar as a multiplication of Dimensionless and Pressure
712      */
713     public final Pressurescalar/Pressure.html#Pressure">Pressure times(final Pressure v)
714     {
715         return new Pressure(this.si * v.si, PressureUnit.SI);
716     }
717 
718     /**
719      * Calculate the multiplication of Dimensionless and RadioActivity, which results in a RadioActivity scalar.
720      * @param v Dimensionless; scalar
721      * @return RadioActivity; scalar as a multiplication of Dimensionless and RadioActivity
722      */
723     public final RadioActivityr/RadioActivity.html#RadioActivity">RadioActivity times(final RadioActivity v)
724     {
725         return new RadioActivity(this.si * v.si, RadioActivityUnit.SI);
726     }
727 
728     /**
729      * Calculate the multiplication of Dimensionless and Speed, which results in a Speed scalar.
730      * @param v Dimensionless; scalar
731      * @return Speed; scalar as a multiplication of Dimensionless and Speed
732      */
733     public final Speedle/scalar/Speed.html#Speed">Speed times(final Speed v)
734     {
735         return new Speed(this.si * v.si, SpeedUnit.SI);
736     }
737 
738     /**
739      * Calculate the multiplication of Dimensionless and Temperature, which results in a Temperature scalar.
740      * @param v Dimensionless; scalar
741      * @return Temperature; scalar as a multiplication of Dimensionless and Temperature
742      */
743     public final Temperaturelar/Temperature.html#Temperature">Temperature times(final Temperature v)
744     {
745         return new Temperature(this.si * v.si, TemperatureUnit.SI);
746     }
747 
748     /**
749      * Calculate the multiplication of Dimensionless and Duration, which results in a Duration scalar.
750      * @param v Dimensionless; scalar
751      * @return Duration; scalar as a multiplication of Dimensionless and Duration
752      */
753     public final Durationscalar/Duration.html#Duration">Duration times(final Duration v)
754     {
755         return new Duration(this.si * v.si, DurationUnit.SI);
756     }
757 
758     /**
759      * Calculate the multiplication of Dimensionless and Torque, which results in a Torque scalar.
760      * @param v Dimensionless; scalar
761      * @return Torque; scalar as a multiplication of Dimensionless and Torque
762      */
763     public final Torquee/scalar/Torque.html#Torque">Torque times(final Torque v)
764     {
765         return new Torque(this.si * v.si, TorqueUnit.SI);
766     }
767 
768     /**
769      * Calculate the multiplication of Dimensionless and Volume, which results in a Volume scalar.
770      * @param v Dimensionless; scalar
771      * @return Volume; scalar as a multiplication of Dimensionless and Volume
772      */
773     public final Volumee/scalar/Volume.html#Volume">Volume times(final Volume v)
774     {
775         return new Volume(this.si * v.si, VolumeUnit.SI);
776     }
777 
778     /**
779      * Calculate the division of Dimensionless and Length, which results in a LinearDensity scalar.
780      * @param v Dimensionless; scalar
781      * @return LinearDensity; scalar as a division of Dimensionless and Length
782      */
783     public final LinearDensity divide(final Length v)
784     {
785         return new LinearDensity(this.si / v.si, LinearDensityUnit.SI);
786     }
787 
788     /**
789      * Calculate the division of Dimensionless and LinearDensity, which results in a Length scalar.
790      * @param v Dimensionless; scalar
791      * @return Length; scalar as a division of Dimensionless and LinearDensity
792      */
793     public final Length divide(final LinearDensity v)
794     {
795         return new Length(this.si / v.si, LengthUnit.SI);
796     }
797 
798     /**
799      * Calculate the division of Dimensionless and Duration, which results in a Frequency scalar.
800      * @param v Dimensionless; scalar
801      * @return Frequency; scalar as a division of Dimensionless and Duration
802      */
803     public final Frequency divide(final Duration v)
804     {
805         return new Frequency(this.si / v.si, FrequencyUnit.SI);
806     }
807 
808     /**
809      * Calculate the division of Dimensionless and Frequency, which results in a Duration scalar.
810      * @param v Dimensionless; scalar
811      * @return Duration; scalar as a division of Dimensionless and Frequency
812      */
813     public final Duration divide(final Frequency v)
814     {
815         return new Duration(this.si / v.si, DurationUnit.SI);
816     }
817 
818     /**
819      * Calculate the division of Dimensionless and ElectricalConductance, which results in a ElectricalResistance scalar.
820      * @param v Dimensionless; scalar
821      * @return ElectricalResistance; scalar as a division of Dimensionless and ElectricalConductance
822      */
823     public final ElectricalResistance divide(final ElectricalConductance v)
824     {
825         return new ElectricalResistance(this.si / v.si, ElectricalResistanceUnit.SI);
826     }
827 
828     /**
829      * Calculate the division of Dimensionless and ElectricalResistance, which results in a ElectricalConductance scalar.
830      * @param v Dimensionless; scalar
831      * @return ElectricalConductance; scalar as a division of Dimensionless and ElectricalResistance
832      */
833     public final ElectricalConductance divide(final ElectricalResistance v)
834     {
835         return new ElectricalConductance(this.si / v.si, ElectricalConductanceUnit.SI);
836     }
837 
838     /** {@inheritDoc} */
839     @Override
840     public Dimensionless reciprocal()
841     {
842         return Dimensionless.instantiateSI(1.0 / this.si);
843     }
844 
845 }