1 package org.djunits.value.vdouble.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 DoubleScalar, which is relative by definition. Instead of:
39 *
40 * <pre>
41 * DoubleScalar.Rel<DimensionlessUnit> value = new DoubleScalar.Rel<DimensionlessUnit>(100.0, DimensionlessUnit.SI);
42 * </pre>
43 *
44 * we can now write:
45 *
46 * <pre>
47 * Dimensionless value = new Dimensionless(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 Dimensionless extends AbstractDoubleScalarRel<DimensionlessUnit, Dimensionless>
62 implements MathFunctionsDimensionless<Dimensionless>
63 {
64 /** */
65 private static final long serialVersionUID = 20150905L;
66
67 /** constant with value zero. */
68 public static final Dimensionless ZERO = new Dimensionless(0.0, DimensionlessUnit.SI);
69
70 /** constant with value NaN. */
71 @SuppressWarnings("checkstyle:constantname")
72 public static final Dimensionless NaN = new Dimensionless(Double.NaN, DimensionlessUnit.SI);
73
74 /** constant with value POSITIVE_INFINITY. */
75 public static final Dimensionless POSITIVE_INFINITY = new Dimensionless(Double.POSITIVE_INFINITY, DimensionlessUnit.SI);
76
77 /** constant with value NEGATIVE_INFINITY. */
78 public static final Dimensionless NEGATIVE_INFINITY = new Dimensionless(Double.NEGATIVE_INFINITY, DimensionlessUnit.SI);
79
80 /** constant with value MAX_VALUE. */
81 public static final Dimensionless POS_MAXVALUE = new Dimensionless(Double.MAX_VALUE, DimensionlessUnit.SI);
82
83 /** constant with value -MAX_VALUE. */
84 public static final Dimensionless NEG_MAXVALUE = new Dimensionless(-Double.MAX_VALUE, DimensionlessUnit.SI);
85
86 /**
87 * Construct Dimensionless scalar.
88 * @param value double value
89 * @param unit unit for the double value
90 */
91 public Dimensionless(final double value, final DimensionlessUnit unit)
92 {
93 super(value, unit);
94 }
95
96 /**
97 * Construct Dimensionless scalar.
98 * @param value Scalar from which to construct this instance
99 */
100 public Dimensionless(final Dimensionless value)
101 {
102 super(value);
103 }
104
105 /** {@inheritDoc} */
106 @Override
107 public final Dimensionless instantiateRel(final double value, final DimensionlessUnit unit)
108 {
109 return new Dimensionless(value, unit);
110 }
111
112 /**
113 * Construct Dimensionless scalar.
114 * @param value double value in SI units
115 * @return the new scalar with the SI value
116 */
117 public static final Dimensionless createSI(final double value)
118 {
119 return new Dimensionless(value, DimensionlessUnit.SI);
120 }
121
122 /**
123 * Interpolate between two values.
124 * @param zero the low value
125 * @param one the high value
126 * @param ratio the ratio between 0 and 1, inclusive
127 * @return a Scalar at the ratio between
128 */
129 public static Dimensionless interpolate(final Dimensionless zero, final Dimensionless one, final double ratio)
130 {
131 return new Dimensionless(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit());
132 }
133
134 /**
135 * Return the maximum value of two relative scalars.
136 * @param r1 the first scalar
137 * @param r2 the second scalar
138 * @return the maximum value of two relative scalars
139 */
140 public static Dimensionless max(final Dimensionless r1, final Dimensionless r2)
141 {
142 return (r1.gt(r2)) ? r1 : r2;
143 }
144
145 /**
146 * Return the maximum value of more than two relative scalars.
147 * @param r1 the first scalar
148 * @param r2 the second scalar
149 * @param rn the other scalars
150 * @return the maximum value of more than two relative scalars
151 */
152 public static Dimensionless max(final Dimensionless r1, final Dimensionless r2, final Dimensionless... rn)
153 {
154 Dimensionless maxr = (r1.gt(r2)) ? r1 : r2;
155 for (Dimensionless r : rn)
156 {
157 if (r.gt(maxr))
158 {
159 maxr = r;
160 }
161 }
162 return maxr;
163 }
164
165 /**
166 * Return the minimum value of two relative scalars.
167 * @param r1 the first scalar
168 * @param r2 the second scalar
169 * @return the minimum value of two relative scalars
170 */
171 public static Dimensionless min(final Dimensionless r1, final Dimensionless r2)
172 {
173 return (r1.lt(r2)) ? r1 : r2;
174 }
175
176 /**
177 * Return the minimum value of more than two relative scalars.
178 * @param r1 the first scalar
179 * @param r2 the second scalar
180 * @param rn the other scalars
181 * @return the minimum value of more than two relative scalars
182 */
183 public static Dimensionless min(final Dimensionless r1, final Dimensionless r2, final Dimensionless... rn)
184 {
185 Dimensionless minr = (r1.lt(r2)) ? r1 : r2;
186 for (Dimensionless r : rn)
187 {
188 if (r.lt(minr))
189 {
190 minr = r;
191 }
192 }
193 return minr;
194 }
195
196 /** {@inheritDoc} */
197 @Override
198 public final Dimensionless acos()
199 {
200 return instantiateRel(Math.acos(getInUnit()), getUnit());
201 }
202
203 /** {@inheritDoc} */
204 @Override
205 public final Dimensionless asin()
206 {
207 return instantiateRel(Math.asin(getInUnit()), getUnit());
208 }
209
210 /** {@inheritDoc} */
211 @Override
212 public final Dimensionless atan()
213 {
214 return instantiateRel(Math.atan(getInUnit()), getUnit());
215 }
216
217 /** {@inheritDoc} */
218 @Override
219 public final Dimensionless cbrt()
220 {
221 return instantiateRel(Math.cbrt(getInUnit()), getUnit());
222 }
223
224 /** {@inheritDoc} */
225 @Override
226 public final Dimensionless cos()
227 {
228 return instantiateRel(Math.cos(getInUnit()), getUnit());
229 }
230
231 /** {@inheritDoc} */
232 @Override
233 public final Dimensionless cosh()
234 {
235 return instantiateRel(Math.cosh(getInUnit()), getUnit());
236 }
237
238 /** {@inheritDoc} */
239 @Override
240 public final Dimensionless exp()
241 {
242 return instantiateRel(Math.exp(getInUnit()), getUnit());
243 }
244
245 /** {@inheritDoc} */
246 @Override
247 public final Dimensionless expm1()
248 {
249 return instantiateRel(Math.expm1(getInUnit()), getUnit());
250 }
251
252 /** {@inheritDoc} */
253 @Override
254 public final Dimensionless log()
255 {
256 return instantiateRel(Math.log(getInUnit()), getUnit());
257 }
258
259 /** {@inheritDoc} */
260 @Override
261 public final Dimensionless log10()
262 {
263 return instantiateRel(Math.log10(getInUnit()), getUnit());
264 }
265
266 /** {@inheritDoc} */
267 @Override
268 public final Dimensionless log1p()
269 {
270 return instantiateRel(Math.log1p(getInUnit()), getUnit());
271 }
272
273 /** {@inheritDoc} */
274 @Override
275 public final Dimensionless pow(final double x)
276 {
277 return instantiateRel(Math.pow(getInUnit(), x), getUnit());
278 }
279
280 /** {@inheritDoc} */
281 @Override
282 public final Dimensionless signum()
283 {
284 return instantiateRel(Math.signum(getInUnit()), getUnit());
285 }
286
287 /** {@inheritDoc} */
288 @Override
289 public final Dimensionless sin()
290 {
291 return instantiateRel(Math.sin(getInUnit()), getUnit());
292 }
293
294 /** {@inheritDoc} */
295 @Override
296 public final Dimensionless sinh()
297 {
298 return instantiateRel(Math.sinh(getInUnit()), getUnit());
299 }
300
301 /** {@inheritDoc} */
302 @Override
303 public final Dimensionless sqrt()
304 {
305 return instantiateRel(Math.sqrt(getInUnit()), getUnit());
306 }
307
308 /** {@inheritDoc} */
309 @Override
310 public final Dimensionless tan()
311 {
312 return instantiateRel(Math.tan(getInUnit()), getUnit());
313 }
314
315 /** {@inheritDoc} */
316 @Override
317 public final Dimensionless tanh()
318 {
319 return instantiateRel(Math.tanh(getInUnit()), getUnit());
320 }
321
322 /** {@inheritDoc} */
323 @Override
324 public final Dimensionless inv()
325 {
326 return instantiateRel(1.0 / getInUnit(), getUnit());
327 }
328
329 /**
330 * Calculate the division of Dimensionless and Dimensionless, which results in a Dimensionless scalar.
331 * @param v Dimensionless scalar
332 * @return Dimensionless scalar as a division of Dimensionless and Dimensionless
333 */
334 public final Dimensionless divideBy(final Dimensionless v)
335 {
336 return new Dimensionless(this.si / v.si, DimensionlessUnit.SI);
337 }
338
339 /**
340 * Calculate the multiplication of Dimensionless and Acceleration, which results in a Acceleration scalar.
341 * @param v Dimensionless scalar
342 * @return Acceleration scalar as a multiplication of Dimensionless and Acceleration
343 */
344 public final Acceleration multiplyBy(final Acceleration v)
345 {
346 return new Acceleration(this.si * v.si, AccelerationUnit.SI);
347 }
348
349 /**
350 * Calculate the multiplication of Dimensionless and Angle, which results in a Angle scalar.
351 * @param v Dimensionless scalar
352 * @return Angle scalar as a multiplication of Dimensionless and Angle
353 */
354 public final Angle multiplyBy(final Angle v)
355 {
356 return new Angle(this.si * v.si, AngleUnit.SI);
357 }
358
359 /**
360 * Calculate the multiplication of Dimensionless and AngleSolid, which results in a AngleSolid scalar.
361 * @param v Dimensionless scalar
362 * @return AngleSolid scalar as a multiplication of Dimensionless and AngleSolid
363 */
364 public final AngleSolid multiplyBy(final AngleSolid v)
365 {
366 return new AngleSolid(this.si * v.si, AngleSolidUnit.SI);
367 }
368
369 /**
370 * Calculate the multiplication of Dimensionless and Area, which results in a Area scalar.
371 * @param v Dimensionless scalar
372 * @return Area scalar as a multiplication of Dimensionless and Area
373 */
374 public final Area multiplyBy(final Area v)
375 {
376 return new Area(this.si * v.si, AreaUnit.SI);
377 }
378
379 /**
380 * Calculate the multiplication of Dimensionless and Density, which results in a Density scalar.
381 * @param v Dimensionless scalar
382 * @return Density scalar as a multiplication of Dimensionless and Density
383 */
384 public final Density multiplyBy(final Density v)
385 {
386 return new Density(this.si * v.si, DensityUnit.SI);
387 }
388
389 /**
390 * Calculate the multiplication of Dimensionless and Dimensionless, which results in a Dimensionless scalar.
391 * @param v Dimensionless scalar
392 * @return Dimensionless scalar as a multiplication of Dimensionless and Dimensionless
393 */
394 public final Dimensionless multiplyBy(final Dimensionless v)
395 {
396 return new Dimensionless(this.si * v.si, DimensionlessUnit.SI);
397 }
398
399 /**
400 * Calculate the multiplication of Dimensionless and ElectricalCharge, which results in a ElectricalCharge scalar.
401 * @param v Dimensionless scalar
402 * @return ElectricalCharge scalar as a multiplication of Dimensionless and ElectricalCharge
403 */
404 public final ElectricalCharge multiplyBy(final ElectricalCharge v)
405 {
406 return new ElectricalCharge(this.si * v.si, ElectricalChargeUnit.SI);
407 }
408
409 /**
410 * Calculate the multiplication of Dimensionless and ElectricalCurrent, which results in a ElectricalCurrent scalar.
411 * @param v Dimensionless scalar
412 * @return ElectricalCurrent scalar as a multiplication of Dimensionless and ElectricalCurrent
413 */
414 public final ElectricalCurrent multiplyBy(final ElectricalCurrent v)
415 {
416 return new ElectricalCurrent(this.si * v.si, ElectricalCurrentUnit.SI);
417 }
418
419 /**
420 * Calculate the multiplication of Dimensionless and ElectricalPotential, which results in a ElectricalPotential scalar.
421 * @param v Dimensionless scalar
422 * @return ElectricalPotential scalar as a multiplication of Dimensionless and ElectricalPotential
423 */
424 public final ElectricalPotential multiplyBy(final ElectricalPotential v)
425 {
426 return new ElectricalPotential(this.si * v.si, ElectricalPotentialUnit.SI);
427 }
428
429 /**
430 * Calculate the multiplication of Dimensionless and ElectricalResistance, which results in a ElectricalResistance scalar.
431 * @param v Dimensionless scalar
432 * @return ElectricalResistance scalar as a multiplication of Dimensionless and ElectricalResistance
433 */
434 public final ElectricalResistance multiplyBy(final ElectricalResistance v)
435 {
436 return new ElectricalResistance(this.si * v.si, ElectricalResistanceUnit.SI);
437 }
438
439 /**
440 * Calculate the multiplication of Dimensionless and Energy, which results in a Energy scalar.
441 * @param v Dimensionless scalar
442 * @return Energy scalar as a multiplication of Dimensionless and Energy
443 */
444 public final Energy multiplyBy(final Energy v)
445 {
446 return new Energy(this.si * v.si, EnergyUnit.SI);
447 }
448
449 /**
450 * Calculate the multiplication of Dimensionless and FlowMass, which results in a FlowMass scalar.
451 * @param v Dimensionless scalar
452 * @return FlowMass scalar as a multiplication of Dimensionless and FlowMass
453 */
454 public final FlowMass multiplyBy(final FlowMass v)
455 {
456 return new FlowMass(this.si * v.si, FlowMassUnit.SI);
457 }
458
459 /**
460 * Calculate the multiplication of Dimensionless and FlowVolume, which results in a FlowVolume scalar.
461 * @param v Dimensionless scalar
462 * @return FlowVolume scalar as a multiplication of Dimensionless and FlowVolume
463 */
464 public final FlowVolume multiplyBy(final FlowVolume v)
465 {
466 return new FlowVolume(this.si * v.si, FlowVolumeUnit.SI);
467 }
468
469 /**
470 * Calculate the multiplication of Dimensionless and Force, which results in a Force scalar.
471 * @param v Dimensionless scalar
472 * @return Force scalar as a multiplication of Dimensionless and Force
473 */
474 public final Force multiplyBy(final Force v)
475 {
476 return new Force(this.si * v.si, ForceUnit.SI);
477 }
478
479 /**
480 * Calculate the multiplication of Dimensionless and Frequency, which results in a Frequency scalar.
481 * @param v Dimensionless scalar
482 * @return Frequency scalar as a multiplication of Dimensionless and Frequency
483 */
484 public final Frequency multiplyBy(final Frequency v)
485 {
486 return new Frequency(this.si * v.si, FrequencyUnit.SI);
487 }
488
489 /**
490 * Calculate the multiplication of Dimensionless and Length, which results in a Length scalar.
491 * @param v Dimensionless scalar
492 * @return Length scalar as a multiplication of Dimensionless and Length
493 */
494 public final Length multiplyBy(final Length v)
495 {
496 return new Length(this.si * v.si, LengthUnit.SI);
497 }
498
499 /**
500 * Calculate the multiplication of Dimensionless and LinearDensity, which results in a LinearDensity scalar.
501 * @param v Dimensionless scalar
502 * @return LinearDensity scalar as a multiplication of Dimensionless and LinearDensity
503 */
504 public final LinearDensity multiplyBy(final LinearDensity v)
505 {
506 return new LinearDensity(this.si * v.si, LinearDensityUnit.SI);
507 }
508
509 /**
510 * Calculate the multiplication of Dimensionless and Mass, which results in a Mass scalar.
511 * @param v Dimensionless scalar
512 * @return Mass scalar as a multiplication of Dimensionless and Mass
513 */
514 public final Mass multiplyBy(final Mass v)
515 {
516 return new Mass(this.si * v.si, MassUnit.SI);
517 }
518
519 /**
520 * Calculate the multiplication of Dimensionless and Money, which results in a Money scalar.
521 * @param v Dimensionless scalar
522 * @return Money scalar as a multiplication of Dimensionless and Money
523 */
524 public final Money multiplyBy(final Money v)
525 {
526 return new Money(this.si * v.si, MoneyUnit.getStandardMoneyUnit());
527 }
528
529 /**
530 * Calculate the multiplication of Dimensionless and MoneyPerArea, which results in a MoneyPerArea scalar.
531 * @param v Dimensionless scalar
532 * @return MoneyPerArea scalar as a multiplication of Dimensionless and MoneyPerArea
533 */
534 public final MoneyPerArea multiplyBy(final MoneyPerArea v)
535 {
536 return new MoneyPerArea(this.si * v.si, MoneyPerAreaUnit.getStandardMoneyPerAreaUnit());
537 }
538
539 /**
540 * Calculate the multiplication of Dimensionless and MoneyPerEnergy, which results in a MoneyPerEnergy scalar.
541 * @param v Dimensionless scalar
542 * @return MoneyPerEnergy scalar as a multiplication of Dimensionless and MoneyPerEnergy
543 */
544 public final MoneyPerEnergy multiplyBy(final MoneyPerEnergy v)
545 {
546 return new MoneyPerEnergy(this.si * v.si, MoneyPerEnergyUnit.getStandardMoneyPerEnergyUnit());
547 }
548
549 /**
550 * Calculate the multiplication of Dimensionless and MoneyPerLength, which results in a MoneyPerLength scalar.
551 * @param v Dimensionless scalar
552 * @return MoneyPerLength scalar as a multiplication of Dimensionless and MoneyPerLength
553 */
554 public final MoneyPerLength multiplyBy(final MoneyPerLength v)
555 {
556 return new MoneyPerLength(this.si * v.si, MoneyPerLengthUnit.getStandardMoneyPerLengthUnit());
557 }
558
559 /**
560 * Calculate the multiplication of Dimensionless and MoneyPerMass, which results in a MoneyPerMass scalar.
561 * @param v Dimensionless scalar
562 * @return MoneyPerMass scalar as a multiplication of Dimensionless and MoneyPerMass
563 */
564 public final MoneyPerMass multiplyBy(final MoneyPerMass v)
565 {
566 return new MoneyPerMass(this.si * v.si, MoneyPerMassUnit.getStandardMoneyPerMassUnit());
567 }
568
569 /**
570 * Calculate the multiplication of Dimensionless and MoneyPerDuration, which results in a MoneyPerDuration scalar.
571 * @param v Dimensionless scalar
572 * @return MoneyPerDuration scalar as a multiplication of Dimensionless and MoneyPerDuration
573 */
574 public final MoneyPerDuration multiplyBy(final MoneyPerDuration v)
575 {
576 return new MoneyPerDuration(this.si * v.si, MoneyPerDurationUnit.getStandardMoneyPerDurationUnit());
577 }
578
579 /**
580 * Calculate the multiplication of Dimensionless and MoneyPerVolume, which results in a MoneyPerVolume scalar.
581 * @param v Dimensionless scalar
582 * @return MoneyPerVolume scalar as a multiplication of Dimensionless and MoneyPerVolume
583 */
584 public final MoneyPerVolume multiplyBy(final MoneyPerVolume v)
585 {
586 return new MoneyPerVolume(this.si * v.si, MoneyPerVolumeUnit.getStandardMoneyPerVolumeUnit());
587 }
588
589 /**
590 * Calculate the multiplication of Dimensionless and Power, which results in a Power scalar.
591 * @param v Dimensionless scalar
592 * @return Power scalar as a multiplication of Dimensionless and Power
593 */
594 public final Power multiplyBy(final Power v)
595 {
596 return new Power(this.si * v.si, PowerUnit.SI);
597 }
598
599 /**
600 * Calculate the multiplication of Dimensionless and Pressure, which results in a Pressure scalar.
601 * @param v Dimensionless scalar
602 * @return Pressure scalar as a multiplication of Dimensionless and Pressure
603 */
604 public final Pressure multiplyBy(final Pressure v)
605 {
606 return new Pressure(this.si * v.si, PressureUnit.SI);
607 }
608
609 /**
610 * Calculate the multiplication of Dimensionless and Speed, which results in a Speed scalar.
611 * @param v Dimensionless scalar
612 * @return Speed scalar as a multiplication of Dimensionless and Speed
613 */
614 public final Speed multiplyBy(final Speed v)
615 {
616 return new Speed(this.si * v.si, SpeedUnit.SI);
617 }
618
619 /**
620 * Calculate the multiplication of Dimensionless and Temperature, which results in a Temperature scalar.
621 * @param v Dimensionless scalar
622 * @return Temperature scalar as a multiplication of Dimensionless and Temperature
623 */
624 public final Temperature multiplyBy(final Temperature v)
625 {
626 return new Temperature(this.si * v.si, TemperatureUnit.SI);
627 }
628
629 /**
630 * Calculate the multiplication of Dimensionless and Duration, which results in a Duration scalar.
631 * @param v Dimensionless scalar
632 * @return Duration scalar as a multiplication of Dimensionless and Duration
633 */
634 public final Duration multiplyBy(final Duration v)
635 {
636 return new Duration(this.si * v.si, DurationUnit.SI);
637 }
638
639 /**
640 * Calculate the multiplication of Dimensionless and Torque, which results in a Torque scalar.
641 * @param v Dimensionless scalar
642 * @return Torque scalar as a multiplication of Dimensionless and Torque
643 */
644 public final Torque multiplyBy(final Torque v)
645 {
646 return new Torque(this.si * v.si, TorqueUnit.SI);
647 }
648
649 /**
650 * Calculate the multiplication of Dimensionless and Volume, which results in a Volume scalar.
651 * @param v Dimensionless scalar
652 * @return Volume scalar as a multiplication of Dimensionless and Volume
653 */
654 public final Volume multiplyBy(final Volume v)
655 {
656 return new Volume(this.si * v.si, VolumeUnit.SI);
657 }
658
659 /**
660 * Calculate the division of Dimensionless and Length, which results in a LinearDensity scalar.
661 * @param v Dimensionless scalar
662 * @return LinearDensity scalar as a division of Dimensionless and Length
663 */
664 public final LinearDensity divideBy(final Length v)
665 {
666 return new LinearDensity(this.si / v.si, LinearDensityUnit.SI);
667 }
668
669 /**
670 * Calculate the division of Dimensionless and LinearDensity, which results in a Length scalar.
671 * @param v Dimensionless scalar
672 * @return Length scalar as a division of Dimensionless and LinearDensity
673 */
674 public final Length divideBy(final LinearDensity v)
675 {
676 return new Length(this.si / v.si, LengthUnit.SI);
677 }
678
679 /**
680 * Calculate the division of Dimensionless and Duration, which results in a Frequency scalar.
681 * @param v Dimensionless scalar
682 * @return Frequency scalar as a division of Dimensionless and Duration
683 */
684 public final Frequency divideBy(final Duration v)
685 {
686 return new Frequency(this.si / v.si, FrequencyUnit.SI);
687 }
688
689 /**
690 * Calculate the division of Dimensionless and Frequency, which results in a Duration scalar.
691 * @param v Dimensionless scalar
692 * @return Duration scalar as a division of Dimensionless and Frequency
693 */
694 public final Duration divideBy(final Frequency v)
695 {
696 return new Duration(this.si / v.si, DurationUnit.SI);
697 }
698
699 }