1 package org.djunits.value.vfloat.scalar;
2
3 import java.util.regex.Matcher;
4
5 import org.djunits.unit.AccelerationUnit;
6 import org.djunits.unit.AngleSolidUnit;
7 import org.djunits.unit.AngleUnit;
8 import org.djunits.unit.AreaUnit;
9 import org.djunits.unit.DensityUnit;
10 import org.djunits.unit.DimensionlessUnit;
11 import org.djunits.unit.DurationUnit;
12 import org.djunits.unit.ElectricalChargeUnit;
13 import org.djunits.unit.ElectricalCurrentUnit;
14 import org.djunits.unit.ElectricalPotentialUnit;
15 import org.djunits.unit.ElectricalResistanceUnit;
16 import org.djunits.unit.EnergyUnit;
17 import org.djunits.unit.FlowMassUnit;
18 import org.djunits.unit.FlowVolumeUnit;
19 import org.djunits.unit.ForceUnit;
20 import org.djunits.unit.FrequencyUnit;
21 import org.djunits.unit.LengthUnit;
22 import org.djunits.unit.LinearDensityUnit;
23 import org.djunits.unit.MassUnit;
24 import org.djunits.unit.MoneyPerAreaUnit;
25 import org.djunits.unit.MoneyPerDurationUnit;
26 import org.djunits.unit.MoneyPerEnergyUnit;
27 import org.djunits.unit.MoneyPerLengthUnit;
28 import org.djunits.unit.MoneyPerMassUnit;
29 import org.djunits.unit.MoneyPerVolumeUnit;
30 import org.djunits.unit.MoneyUnit;
31 import org.djunits.unit.PowerUnit;
32 import org.djunits.unit.PressureUnit;
33 import org.djunits.unit.SpeedUnit;
34 import org.djunits.unit.TemperatureUnit;
35 import org.djunits.unit.TorqueUnit;
36 import org.djunits.unit.Unit;
37 import org.djunits.unit.VolumeUnit;
38 import org.djunits.value.MathFunctionsDimensionless;
39
40 /**
41 * Easy access methods for the Dimensionless FloatScalar, which is relative by definition. An example is Speed. Instead of:
42 *
43 * <pre>
44 * FloatScalar.Rel<DimensionlessUnit> value = new FloatScalar.Rel<DimensionlessUnit>(100.0, DimensionlessUnit.SI);
45 * </pre>
46 *
47 * we can now write:
48 *
49 * <pre>
50 * FloatDimensionless value = new FloatDimensionless(100.0, DimensionlessUnit.SI);
51 * </pre>
52 *
53 * The compiler will automatically recognize which units belong to which quantity, and whether the quantity type and the unit
54 * used are compatible.
55 * <p>
56 * Copyright (c) 2013-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
57 * BSD-style license. See <a href="http://djunits.org/docs/license.html">DJUNITS License</a>.
58 * <p>
59 * $LastChangedDate: 2019-03-03 00:53:50 +0100 (Sun, 03 Mar 2019) $, @version $Revision: 349 $, by $Author: averbraeck $,
60 * initial version Sep 5, 2015 <br>
61 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
62 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
63 */
64 public class FloatDimensionless extends AbstractFloatScalarRel<DimensionlessUnit, FloatDimensionless>
65 implements MathFunctionsDimensionless<FloatDimensionless>
66 {
67 /** */
68 private static final long serialVersionUID = 20150901L;
69
70 /** constant with value zero. */
71 public static final FloatDimensionless ZERO = new FloatDimensionless(0.0f, DimensionlessUnit.SI);
72
73 /** constant with value NaN. */
74 @SuppressWarnings("checkstyle:constantname")
75 public static final FloatDimensionless NaN = new FloatDimensionless(Float.NaN, DimensionlessUnit.SI);
76
77 /** constant with value POSITIVE_INFINITY. */
78 public static final FloatDimensionless POSITIVE_INFINITY =
79 new FloatDimensionless(Float.POSITIVE_INFINITY, DimensionlessUnit.SI);
80
81 /** constant with value NEGATIVE_INFINITY. */
82 public static final FloatDimensionless NEGATIVE_INFINITY =
83 new FloatDimensionless(Float.NEGATIVE_INFINITY, DimensionlessUnit.SI);
84
85 /** constant with value MAX_VALUE. */
86 public static final FloatDimensionless POS_MAXVALUE = new FloatDimensionless(Float.MAX_VALUE, DimensionlessUnit.SI);
87
88 /** constant with value -MAX_VALUE. */
89 public static final FloatDimensionless NEG_MAXVALUE = new FloatDimensionless(-Float.MAX_VALUE, DimensionlessUnit.SI);
90
91 /**
92 * Construct FloatDimensionless scalar.
93 * @param value float value
94 * @param unit unit for the float value
95 */
96 public FloatDimensionless(final float value, final DimensionlessUnit unit)
97 {
98 super(value, unit);
99 }
100
101 /**
102 * Construct FloatDimensionless scalar.
103 * @param value Scalar from which to construct this instance
104 */
105 public FloatDimensionless(final FloatDimensionless value)
106 {
107 super(value);
108 }
109
110 /**
111 * Construct FloatDimensionless scalar using a double value.
112 * @param value double value
113 * @param unit unit for the resulting float value
114 */
115 public FloatDimensionless(final double value, final DimensionlessUnit unit)
116 {
117 super((float) value, unit);
118 }
119
120 /** {@inheritDoc} */
121 @Override
122 public final FloatDimensionless instantiateRel(final float value, final DimensionlessUnit unit)
123 {
124 return new FloatDimensionless(value, unit);
125 }
126
127 /**
128 * Construct FloatDimensionless scalar.
129 * @param value float value in SI units
130 * @return the new scalar with the SI value
131 */
132 public static final FloatDimensionless createSI(final float value)
133 {
134 return new FloatDimensionless(value, DimensionlessUnit.SI);
135 }
136
137 /**
138 * Interpolate between two values.
139 * @param zero the low value
140 * @param one the high value
141 * @param ratio the ratio between 0 and 1, inclusive
142 * @return a Scalar at the ratio between
143 */
144 public static FloatDimensionless interpolate(final FloatDimensionless zero, final FloatDimensionless one, final float ratio)
145 {
146 return new FloatDimensionless(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit());
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 FloatDimensionless max(final 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 FloatDimensionless max(final 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 FloatDimensionless min(final 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 FloatDimensionless min(final 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 necessary, between the value and the unit.
217 * @param text String; the textual representation to parse into a FloatDimensionless
218 * @return the String representation of the value in its unit, followed by the official abbreviation of the unit
219 * @throws IllegalArgumentException when the text cannot be parsed
220 */
221 public static FloatDimensionless valueOf(final String text) throws IllegalArgumentException
222 {
223 if (text == null || text.length() == 0)
224 {
225 throw new IllegalArgumentException("Error parsing FloatDimensionless -- null or empty argument");
226 }
227 Matcher matcher = NUMBER_PATTERN.matcher(text);
228 if (matcher.find())
229 {
230 int index = matcher.end();
231 try
232 {
233 String unitString = text.substring(index).trim();
234 String valueString = text.substring(0, index).trim();
235 for (DimensionlessUnit unit : Unit.getUnits(DimensionlessUnit.class))
236 {
237 if (unit.getDefaultLocaleTextualRepresentations().contains(unitString))
238 {
239 float f = Float.parseFloat(valueString);
240 return new FloatDimensionless(f, unit);
241 }
242 }
243 }
244 catch (Exception exception)
245 {
246 throw new IllegalArgumentException("Error parsing FloatDimensionless from " + text, exception);
247 }
248 }
249 throw new IllegalArgumentException("Error parsing FloatDimensionless from " + text);
250 }
251
252 /** {@inheritDoc} */
253 @Override
254 public final FloatDimensionless acos()
255 {
256 return instantiateRel((float) Math.acos(getInUnit()), getUnit());
257 }
258
259 /** {@inheritDoc} */
260 @Override
261 public final FloatDimensionless asin()
262 {
263 return instantiateRel((float) Math.asin(getInUnit()), getUnit());
264 }
265
266 /** {@inheritDoc} */
267 @Override
268 public final FloatDimensionless atan()
269 {
270 return instantiateRel((float) Math.atan(getInUnit()), getUnit());
271 }
272
273 /** {@inheritDoc} */
274 @Override
275 public final FloatDimensionless cbrt()
276 {
277 return instantiateRel((float) Math.cbrt(getInUnit()), getUnit());
278 }
279
280 /** {@inheritDoc} */
281 @Override
282 public final FloatDimensionless cos()
283 {
284 return instantiateRel((float) Math.cos(getInUnit()), getUnit());
285 }
286
287 /** {@inheritDoc} */
288 @Override
289 public final FloatDimensionless cosh()
290 {
291 return instantiateRel((float) Math.cosh(getInUnit()), getUnit());
292 }
293
294 /** {@inheritDoc} */
295 @Override
296 public final FloatDimensionless exp()
297 {
298 return instantiateRel((float) Math.exp(getInUnit()), getUnit());
299 }
300
301 /** {@inheritDoc} */
302 @Override
303 public final FloatDimensionless expm1()
304 {
305 return instantiateRel((float) Math.expm1(getInUnit()), getUnit());
306 }
307
308 /** {@inheritDoc} */
309 @Override
310 public final FloatDimensionless log()
311 {
312 return instantiateRel((float) Math.log(getInUnit()), getUnit());
313 }
314
315 /** {@inheritDoc} */
316 @Override
317 public final FloatDimensionless log10()
318 {
319 return instantiateRel((float) Math.log10(getInUnit()), getUnit());
320 }
321
322 /** {@inheritDoc} */
323 @Override
324 public final FloatDimensionless log1p()
325 {
326 return instantiateRel((float) Math.log1p(getInUnit()), getUnit());
327 }
328
329 /** {@inheritDoc} */
330 @Override
331 public final FloatDimensionless pow(final double x)
332 {
333 return instantiateRel((float) Math.pow(getInUnit(), x), getUnit());
334 }
335
336 /** {@inheritDoc} */
337 @Override
338 public final FloatDimensionless signum()
339 {
340 return instantiateRel(Math.signum(getInUnit()), getUnit());
341 }
342
343 /** {@inheritDoc} */
344 @Override
345 public final FloatDimensionless sin()
346 {
347 return instantiateRel((float) Math.sin(getInUnit()), getUnit());
348 }
349
350 /** {@inheritDoc} */
351 @Override
352 public final FloatDimensionless sinh()
353 {
354 return instantiateRel((float) Math.sinh(getInUnit()), getUnit());
355 }
356
357 /** {@inheritDoc} */
358 @Override
359 public final FloatDimensionless sqrt()
360 {
361 return instantiateRel((float) Math.sqrt(getInUnit()), getUnit());
362 }
363
364 /** {@inheritDoc} */
365 @Override
366 public final FloatDimensionless tan()
367 {
368 return instantiateRel((float) Math.tan(getInUnit()), getUnit());
369 }
370
371 /** {@inheritDoc} */
372 @Override
373 public final FloatDimensionless tanh()
374 {
375 return instantiateRel((float) Math.tanh(getInUnit()), getUnit());
376 }
377
378 /** {@inheritDoc} */
379 @Override
380 public final FloatDimensionless inv()
381 {
382 return instantiateRel(1.0f / getInUnit(), getUnit());
383 }
384
385 /**
386 * Calculate the division of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
387 * @param v FloatDimensionless scalar
388 * @return FloatDimensionless scalar as a division of FloatDimensionless and FloatDimensionless
389 */
390 public final FloatDimensionless divideBy(final FloatDimensionless v)
391 {
392 return new FloatDimensionless(this.si / v.si, DimensionlessUnit.SI);
393 }
394
395 /**
396 * Calculate the multiplication of FloatDimensionless and FloatAcceleration, which results in a FloatAcceleration scalar.
397 * @param v FloatDimensionless scalar
398 * @return FloatAcceleration scalar as a multiplication of FloatDimensionless and FloatAcceleration
399 */
400 public final FloatAcceleration multiplyBy(final FloatAcceleration v)
401 {
402 return new FloatAcceleration(this.si * v.si, AccelerationUnit.SI);
403 }
404
405 /**
406 * Calculate the multiplication of FloatDimensionless and FloatAngle, which results in a FloatAngle scalar.
407 * @param v FloatDimensionless scalar
408 * @return FloatAngle scalar as a multiplication of FloatDimensionless and FloatAngle
409 */
410 public final FloatAngle multiplyBy(final FloatAngle v)
411 {
412 return new FloatAngle(this.si * v.si, AngleUnit.SI);
413 }
414
415 /**
416 * Calculate the multiplication of FloatDimensionless and FloatAngleSolid, which results in a FloatAngleSolid scalar.
417 * @param v FloatDimensionless scalar
418 * @return FloatAngleSolid scalar as a multiplication of FloatDimensionless and FloatAngleSolid
419 */
420 public final FloatAngleSolid multiplyBy(final FloatAngleSolid v)
421 {
422 return new FloatAngleSolid(this.si * v.si, AngleSolidUnit.SI);
423 }
424
425 /**
426 * Calculate the multiplication of FloatDimensionless and FloatArea, which results in a FloatArea scalar.
427 * @param v FloatDimensionless scalar
428 * @return FloatArea scalar as a multiplication of FloatDimensionless and FloatArea
429 */
430 public final FloatArea multiplyBy(final FloatArea v)
431 {
432 return new FloatArea(this.si * v.si, AreaUnit.SI);
433 }
434
435 /**
436 * Calculate the multiplication of FloatDimensionless and FloatDensity, which results in a FloatDensity scalar.
437 * @param v FloatDimensionless scalar
438 * @return FloatDensity scalar as a multiplication of FloatDimensionless and FloatDensity
439 */
440 public final FloatDensity multiplyBy(final FloatDensity v)
441 {
442 return new FloatDensity(this.si * v.si, DensityUnit.SI);
443 }
444
445 /**
446 * Calculate the multiplication of FloatDimensionless and FloatDimensionless, which results in a FloatDimensionless scalar.
447 * @param v FloatDimensionless scalar
448 * @return FloatDimensionless scalar as a multiplication of FloatDimensionless and FloatDimensionless
449 */
450 public final FloatDimensionless multiplyBy(final FloatDimensionless v)
451 {
452 return new FloatDimensionless(this.si * v.si, DimensionlessUnit.SI);
453 }
454
455 /**
456 * Calculate the multiplication of FloatDimensionless and FloatElectricalCharge, which results in a FloatElectricalCharge
457 * scalar.
458 * @param v FloatDimensionless scalar
459 * @return FloatElectricalCharge scalar as a multiplication of FloatDimensionless and FloatElectricalCharge
460 */
461 public final FloatElectricalCharge multiplyBy(final FloatElectricalCharge v)
462 {
463 return new FloatElectricalCharge(this.si * v.si, ElectricalChargeUnit.SI);
464 }
465
466 /**
467 * Calculate the multiplication of FloatDimensionless and FloatElectricalCurrent, which results in a FloatElectricalCurrent
468 * scalar.
469 * @param v FloatDimensionless scalar
470 * @return FloatElectricalCurrent scalar as a multiplication of FloatDimensionless and FloatElectricalCurrent
471 */
472 public final FloatElectricalCurrent multiplyBy(final FloatElectricalCurrent v)
473 {
474 return new FloatElectricalCurrent(this.si * v.si, ElectricalCurrentUnit.SI);
475 }
476
477 /**
478 * Calculate the multiplication of FloatDimensionless and FloatElectricalPotential, which results in a
479 * FloatElectricalPotential scalar.
480 * @param v FloatDimensionless scalar
481 * @return FloatElectricalPotential scalar as a multiplication of FloatDimensionless and FloatElectricalPotential
482 */
483 public final FloatElectricalPotential multiplyBy(final FloatElectricalPotential v)
484 {
485 return new FloatElectricalPotential(this.si * v.si, ElectricalPotentialUnit.SI);
486 }
487
488 /**
489 * Calculate the multiplication of FloatDimensionless and FloatElectricalResistance, which results in a
490 * FloatElectricalResistance scalar.
491 * @param v FloatDimensionless scalar
492 * @return FloatElectricalResistance scalar as a multiplication of FloatDimensionless and FloatElectricalResistance
493 */
494 public final FloatElectricalResistance multiplyBy(final FloatElectricalResistance v)
495 {
496 return new FloatElectricalResistance(this.si * v.si, ElectricalResistanceUnit.SI);
497 }
498
499 /**
500 * Calculate the multiplication of FloatDimensionless and FloatEnergy, which results in a FloatEnergy scalar.
501 * @param v FloatDimensionless scalar
502 * @return FloatEnergy scalar as a multiplication of FloatDimensionless and FloatEnergy
503 */
504 public final FloatEnergy multiplyBy(final FloatEnergy v)
505 {
506 return new FloatEnergy(this.si * v.si, EnergyUnit.SI);
507 }
508
509 /**
510 * Calculate the multiplication of FloatDimensionless and FloatFlowMass, which results in a FloatFlowMass scalar.
511 * @param v FloatDimensionless scalar
512 * @return FloatFlowMass scalar as a multiplication of FloatDimensionless and FloatFlowMass
513 */
514 public final FloatFlowMass multiplyBy(final FloatFlowMass v)
515 {
516 return new FloatFlowMass(this.si * v.si, FlowMassUnit.SI);
517 }
518
519 /**
520 * Calculate the multiplication of FloatDimensionless and FloatFlowVolume, which results in a FloatFlowVolume scalar.
521 * @param v FloatDimensionless scalar
522 * @return FloatFlowVolume scalar as a multiplication of FloatDimensionless and FloatFlowVolume
523 */
524 public final FloatFlowVolume multiplyBy(final FloatFlowVolume v)
525 {
526 return new FloatFlowVolume(this.si * v.si, FlowVolumeUnit.SI);
527 }
528
529 /**
530 * Calculate the multiplication of FloatDimensionless and FloatForce, which results in a FloatForce scalar.
531 * @param v FloatDimensionless scalar
532 * @return FloatForce scalar as a multiplication of FloatDimensionless and FloatForce
533 */
534 public final FloatForce multiplyBy(final FloatForce v)
535 {
536 return new FloatForce(this.si * v.si, ForceUnit.SI);
537 }
538
539 /**
540 * Calculate the multiplication of FloatDimensionless and FloatFrequency, which results in a FloatFrequency scalar.
541 * @param v FloatDimensionless scalar
542 * @return FloatFrequency scalar as a multiplication of FloatDimensionless and FloatFrequency
543 */
544 public final FloatFrequency multiplyBy(final FloatFrequency v)
545 {
546 return new FloatFrequency(this.si * v.si, FrequencyUnit.SI);
547 }
548
549 /**
550 * Calculate the multiplication of FloatDimensionless and FloatLength, which results in a FloatLength scalar.
551 * @param v FloatDimensionless scalar
552 * @return FloatLength scalar as a multiplication of FloatDimensionless and FloatLength
553 */
554 public final FloatLength multiplyBy(final FloatLength v)
555 {
556 return new FloatLength(this.si * v.si, LengthUnit.SI);
557 }
558
559 /**
560 * Calculate the multiplication of FloatDimensionless and FloatLinearDensity, which results in a FloatLinearDensity scalar.
561 * @param v FloatDimensionless scalar
562 * @return FloatLinearDensity scalar as a multiplication of FloatDimensionless and FloatLinearDensity
563 */
564 public final FloatLinearDensity multiplyBy(final FloatLinearDensity v)
565 {
566 return new FloatLinearDensity(this.si * v.si, LinearDensityUnit.SI);
567 }
568
569 /**
570 * Calculate the multiplication of FloatDimensionless and FloatMass, which results in a FloatMass scalar.
571 * @param v FloatDimensionless scalar
572 * @return FloatMass scalar as a multiplication of FloatDimensionless and FloatMass
573 */
574 public final FloatMass multiplyBy(final FloatMass v)
575 {
576 return new FloatMass(this.si * v.si, MassUnit.SI);
577 }
578
579 /**
580 * Calculate the multiplication of FloatDimensionless and FloatMoney, which results in a FloatMoney scalar.
581 * @param v FloatDimensionless scalar
582 * @return FloatMoney scalar as a multiplication of FloatDimensionless and FloatMoney
583 */
584 public final FloatMoney multiplyBy(final FloatMoney v)
585 {
586 return new FloatMoney(this.si * v.si, MoneyUnit.getStandardMoneyUnit());
587 }
588
589 /**
590 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerArea, which results in a FloatMoneyPerArea scalar.
591 * @param v FloatDimensionless scalar
592 * @return FloatMoneyPerArea scalar as a multiplication of FloatDimensionless and FloatMoneyPerArea
593 */
594 public final FloatMoneyPerArea multiplyBy(final FloatMoneyPerArea v)
595 {
596 return new FloatMoneyPerArea(this.si * v.si, MoneyPerAreaUnit.getStandardMoneyPerAreaUnit());
597 }
598
599 /**
600 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerEnergy, which results in a FloatMoneyPerEnergy
601 * scalar.
602 * @param v FloatDimensionless scalar
603 * @return FloatMoneyPerEnergy scalar as a multiplication of FloatDimensionless and FloatMoneyPerEnergy
604 */
605 public final FloatMoneyPerEnergy multiplyBy(final FloatMoneyPerEnergy v)
606 {
607 return new FloatMoneyPerEnergy(this.si * v.si, MoneyPerEnergyUnit.getStandardMoneyPerEnergyUnit());
608 }
609
610 /**
611 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerLength, which results in a FloatMoneyPerLength
612 * scalar.
613 * @param v FloatDimensionless scalar
614 * @return FloatMoneyPerLength scalar as a multiplication of FloatDimensionless and FloatMoneyPerLength
615 */
616 public final FloatMoneyPerLength multiplyBy(final FloatMoneyPerLength v)
617 {
618 return new FloatMoneyPerLength(this.si * v.si, MoneyPerLengthUnit.getStandardMoneyPerLengthUnit());
619 }
620
621 /**
622 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerMass, which results in a FloatMoneyPerMass scalar.
623 * @param v FloatDimensionless scalar
624 * @return FloatMoneyPerMass scalar as a multiplication of FloatDimensionless and FloatMoneyPerMass
625 */
626 public final FloatMoneyPerMass multiplyBy(final FloatMoneyPerMass v)
627 {
628 return new FloatMoneyPerMass(this.si * v.si, MoneyPerMassUnit.getStandardMoneyPerMassUnit());
629 }
630
631 /**
632 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerDuration, which results in a FloatMoneyPerDuration
633 * scalar.
634 * @param v FloatDimensionless scalar
635 * @return FloatMoneyPerDuration scalar as a multiplication of FloatDimensionless and FloatMoneyPerDuration
636 */
637 public final FloatMoneyPerDuration multiplyBy(final FloatMoneyPerDuration v)
638 {
639 return new FloatMoneyPerDuration(this.si * v.si, MoneyPerDurationUnit.getStandardMoneyPerDurationUnit());
640 }
641
642 /**
643 * Calculate the multiplication of FloatDimensionless and FloatMoneyPerVolume, which results in a FloatMoneyPerVolume
644 * scalar.
645 * @param v FloatDimensionless scalar
646 * @return FloatMoneyPerVolume scalar as a multiplication of FloatDimensionless and FloatMoneyPerVolume
647 */
648 public final FloatMoneyPerVolume multiplyBy(final FloatMoneyPerVolume v)
649 {
650 return new FloatMoneyPerVolume(this.si * v.si, MoneyPerVolumeUnit.getStandardMoneyPerVolumeUnit());
651 }
652
653 /**
654 * Calculate the multiplication of FloatDimensionless and FloatPower, which results in a FloatPower scalar.
655 * @param v FloatDimensionless scalar
656 * @return FloatPower scalar as a multiplication of FloatDimensionless and FloatPower
657 */
658 public final FloatPower multiplyBy(final FloatPower v)
659 {
660 return new FloatPower(this.si * v.si, PowerUnit.SI);
661 }
662
663 /**
664 * Calculate the multiplication of FloatDimensionless and FloatPressure, which results in a FloatPressure scalar.
665 * @param v FloatDimensionless scalar
666 * @return FloatPressure scalar as a multiplication of FloatDimensionless and FloatPressure
667 */
668 public final FloatPressure multiplyBy(final FloatPressure v)
669 {
670 return new FloatPressure(this.si * v.si, PressureUnit.SI);
671 }
672
673 /**
674 * Calculate the multiplication of FloatDimensionless and FloatSpeed, which results in a FloatSpeed scalar.
675 * @param v FloatDimensionless scalar
676 * @return FloatSpeed scalar as a multiplication of FloatDimensionless and FloatSpeed
677 */
678 public final FloatSpeed multiplyBy(final FloatSpeed v)
679 {
680 return new FloatSpeed(this.si * v.si, SpeedUnit.SI);
681 }
682
683 /**
684 * Calculate the multiplication of FloatDimensionless and FloatTemperature, which results in a FloatTemperature scalar.
685 * @param v FloatDimensionless scalar
686 * @return FloatTemperature scalar as a multiplication of FloatDimensionless and FloatTemperature
687 */
688 public final FloatTemperature multiplyBy(final FloatTemperature v)
689 {
690 return new FloatTemperature(this.si * v.si, TemperatureUnit.SI);
691 }
692
693 /**
694 * Calculate the multiplication of FloatDimensionless and FloatDuration, which results in a FloatDuration scalar.
695 * @param v FloatDimensionless scalar
696 * @return FloatDuration scalar as a multiplication of FloatDimensionless and FloatDuration
697 */
698 public final FloatDuration multiplyBy(final FloatDuration v)
699 {
700 return new FloatDuration(this.si * v.si, DurationUnit.SI);
701 }
702
703 /**
704 * Calculate the multiplication of FloatDimensionless and FloatTorque, which results in a FloatTorque scalar.
705 * @param v FloatDimensionless scalar
706 * @return FloatTorque scalar as a multiplication of FloatDimensionless and FloatTorque
707 */
708 public final FloatTorque multiplyBy(final FloatTorque v)
709 {
710 return new FloatTorque(this.si * v.si, TorqueUnit.SI);
711 }
712
713 /**
714 * Calculate the multiplication of FloatDimensionless and FloatVolume, which results in a FloatVolume scalar.
715 * @param v FloatDimensionless scalar
716 * @return FloatVolume scalar as a multiplication of FloatDimensionless and FloatVolume
717 */
718 public final FloatVolume multiplyBy(final FloatVolume v)
719 {
720 return new FloatVolume(this.si * v.si, VolumeUnit.SI);
721 }
722
723 /**
724 * Calculate the division of FloatDimensionless and FloatLength, which results in a FloatLinearDensity scalar.
725 * @param v FloatDimensionless scalar
726 * @return FloatLinearDensity scalar as a division of FloatDimensionless and FloatLength
727 */
728 public final FloatLinearDensity divideBy(final FloatLength v)
729 {
730 return new FloatLinearDensity(this.si / v.si, LinearDensityUnit.SI);
731 }
732
733 /**
734 * Calculate the division of FloatDimensionless and FloatLinearDensity, which results in a FloatLength scalar.
735 * @param v FloatDimensionless scalar
736 * @return FloatLength scalar as a division of FloatDimensionless and FloatLinearDensity
737 */
738 public final FloatLength divideBy(final FloatLinearDensity v)
739 {
740 return new FloatLength(this.si / v.si, LengthUnit.SI);
741 }
742
743 /**
744 * Calculate the division of FloatDimensionless and FloatDuration, which results in a FloatFrequency scalar.
745 * @param v FloatDimensionless scalar
746 * @return FloatFrequency scalar as a division of FloatDimensionless and FloatDuration
747 */
748 public final FloatFrequency divideBy(final FloatDuration v)
749 {
750 return new FloatFrequency(this.si / v.si, FrequencyUnit.SI);
751 }
752
753 /**
754 * Calculate the division of FloatDimensionless and FloatFrequency, which results in a FloatDuration scalar.
755 * @param v FloatDimensionless scalar
756 * @return FloatDuration scalar as a division of FloatDimensionless and FloatFrequency
757 */
758 public final FloatDuration divideBy(final FloatFrequency v)
759 {
760 return new FloatDuration(this.si / v.si, DurationUnit.SI);
761 }
762
763 }