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