1 package org.djunits.value.vfloat.scalar;
2
3 import org.djunits.unit.DimensionlessUnit;
4 import org.djunits.unit.FlowMassUnit;
5 import org.djunits.unit.ForceUnit;
6 import org.djunits.unit.FrequencyUnit;
7 import org.djunits.unit.MassUnit;
8
9 /**
10 * Easy access methods for the FlowMass FloatScalar, which is relative by definition. An example is Speed. Instead of:
11 *
12 * <pre>
13 * FloatScalar.Rel<FlowMassUnit> value = new FloatScalar.Rel<FlowMassUnit>(100.0, FlowMassUnit.SI);
14 * </pre>
15 *
16 * we can now write:
17 *
18 * <pre>
19 * FloatFlowMass value = new FloatFlowMass(100.0, FlowMassUnit.SI);
20 * </pre>
21 *
22 * The compiler will automatically recognize which units belong to which quantity, and whether the quantity type and the unit
23 * used are compatible.
24 * <p>
25 * Copyright (c) 2013-2018 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
26 * BSD-style license. See <a href="http://djunits.org/docs/license.html">DJUNITS License</a>.
27 * <p>
28 * $LastChangedDate: 2018-01-28 03:17:44 +0100 (Sun, 28 Jan 2018) $, @version $Revision: 256 $, by $Author: averbraeck $,
29 * initial version Sep 5, 2015 <br>
30 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
31 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
32 */
33 public class FloatFlowMass extends AbstractFloatScalarRel<FlowMassUnit, FloatFlowMass>
34 {
35 /** */
36 private static final long serialVersionUID = 20150901L;
37
38 /** constant with value zero. */
39 public static final FloatFlowMass ZERO = new FloatFlowMass(0.0f, FlowMassUnit.SI);
40
41 /** constant with value NaN. */
42 @SuppressWarnings("checkstyle:constantname")
43 public static final FloatFlowMass NaN = new FloatFlowMass(Float.NaN, FlowMassUnit.SI);
44
45 /** constant with value POSITIVE_INFINITY. */
46 public static final FloatFlowMass POSITIVE_INFINITY = new FloatFlowMass(Float.POSITIVE_INFINITY, FlowMassUnit.SI);
47
48 /** constant with value NEGATIVE_INFINITY. */
49 public static final FloatFlowMass NEGATIVE_INFINITY = new FloatFlowMass(Float.NEGATIVE_INFINITY, FlowMassUnit.SI);
50
51 /** constant with value MAX_VALUE. */
52 public static final FloatFlowMass POS_MAXVALUE = new FloatFlowMass(Float.MAX_VALUE, FlowMassUnit.SI);
53
54 /** constant with value -MAX_VALUE. */
55 public static final FloatFlowMass NEG_MAXVALUE = new FloatFlowMass(-Float.MAX_VALUE, FlowMassUnit.SI);
56
57 /**
58 * Construct FloatFlowMass scalar.
59 * @param value float value
60 * @param unit unit for the float value
61 */
62 public FloatFlowMass(final float value, final FlowMassUnit unit)
63 {
64 super(value, unit);
65 }
66
67 /**
68 * Construct FloatFlowMass scalar.
69 * @param value Scalar from which to construct this instance
70 */
71 public FloatFlowMass(final FloatFlowMass value)
72 {
73 super(value);
74 }
75
76 /**
77 * Construct FloatFlowMass scalar using a double value.
78 * @param value double value
79 * @param unit unit for the resulting float value
80 */
81 public FloatFlowMass(final double value, final FlowMassUnit unit)
82 {
83 super((float) value, unit);
84 }
85
86 /** {@inheritDoc} */
87 @Override
88 public final FloatFlowMass instantiateRel(final float value, final FlowMassUnit unit)
89 {
90 return new FloatFlowMass(value, unit);
91 }
92
93 /**
94 * Construct FloatFlowMass scalar.
95 * @param value float value in SI units
96 * @return the new scalar with the SI value
97 */
98 public static final FloatFlowMass createSI(final float value)
99 {
100 return new FloatFlowMass(value, FlowMassUnit.SI);
101 }
102
103 /**
104 * Interpolate between two values.
105 * @param zero the low value
106 * @param one the high value
107 * @param ratio the ratio between 0 and 1, inclusive
108 * @return a Scalar at the ratio between
109 */
110 public static FloatFlowMass interpolate(final FloatFlowMass zero, final FloatFlowMass one, final float ratio)
111 {
112 return new FloatFlowMass(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit());
113 }
114
115 /**
116 * Return the maximum value of two relative scalars.
117 * @param r1 the first scalar
118 * @param r2 the second scalar
119 * @return the maximum value of two relative scalars
120 */
121 public static FloatFlowMass max(final FloatFlowMass r1, final FloatFlowMass r2)
122 {
123 return (r1.gt(r2)) ? r1 : r2;
124 }
125
126 /**
127 * Return the maximum value of more than two relative scalars.
128 * @param r1 the first scalar
129 * @param r2 the second scalar
130 * @param rn the other scalars
131 * @return the maximum value of more than two relative scalars
132 */
133 public static FloatFlowMass max(final FloatFlowMass r1, final FloatFlowMass r2, final FloatFlowMass... rn)
134 {
135 FloatFlowMass maxr = (r1.gt(r2)) ? r1 : r2;
136 for (FloatFlowMass r : rn)
137 {
138 if (r.gt(maxr))
139 {
140 maxr = r;
141 }
142 }
143 return maxr;
144 }
145
146 /**
147 * Return the minimum value of two relative scalars.
148 * @param r1 the first scalar
149 * @param r2 the second scalar
150 * @return the minimum value of two relative scalars
151 */
152 public static FloatFlowMass min(final FloatFlowMass r1, final FloatFlowMass r2)
153 {
154 return (r1.lt(r2)) ? r1 : r2;
155 }
156
157 /**
158 * Return the minimum 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 minimum value of more than two relative scalars
163 */
164 public static FloatFlowMass min(final FloatFlowMass r1, final FloatFlowMass r2, final FloatFlowMass... rn)
165 {
166 FloatFlowMass minr = (r1.lt(r2)) ? r1 : r2;
167 for (FloatFlowMass r : rn)
168 {
169 if (r.lt(minr))
170 {
171 minr = r;
172 }
173 }
174 return minr;
175 }
176
177 /**
178 * Calculate the division of FloatFlowMass and FloatFlowMass, which results in a FloatDimensionless scalar.
179 * @param v FloatFlowMass scalar
180 * @return FloatDimensionless scalar as a division of FloatFlowMass and FloatFlowMass
181 */
182 public final FloatDimensionless divideBy(final FloatFlowMass v)
183 {
184 return new FloatDimensionless(this.si / v.si, DimensionlessUnit.SI);
185 }
186
187 /**
188 * Calculate the multiplication of FloatFlowMass and FloatDuration, which results in a FloatMass scalar.
189 * @param v FloatFlowMass scalar
190 * @return FloatMass scalar as a multiplication of FloatFlowMass and FloatDuration
191 */
192 public final FloatMass multiplyBy(final FloatDuration v)
193 {
194 return new FloatMass(this.si * v.si, MassUnit.SI);
195 }
196
197 /**
198 * Calculate the division of FloatFlowMass and FloatFrequency, which results in a FloatMass scalar.
199 * @param v FloatFlowMass scalar
200 * @return FloatMass scalar as a division of FloatFlowMass and FloatFrequency
201 */
202 public final FloatMass divideBy(final FloatFrequency v)
203 {
204 return new FloatMass(this.si / v.si, MassUnit.SI);
205 }
206
207 /**
208 * Calculate the division of FloatFlowMass and FloatMass, which results in a FloatFrequency scalar.
209 * @param v FloatFlowMass scalar
210 * @return FloatFrequency scalar as a division of FloatFlowMass and FloatMass
211 */
212 public final FloatFrequency divideBy(final FloatMass v)
213 {
214 return new FloatFrequency(this.si / v.si, FrequencyUnit.SI);
215 }
216
217 /**
218 * Calculate the multiplication of FloatFlowMass and FloatSpeed, which results in a FloatForce scalar.
219 * @param v FloatFlowMass scalar
220 * @return FloatForce scalar as a multiplication of FloatFlowMass and FloatSpeed
221 */
222 public final FloatForce multiplyBy(final FloatSpeed v)
223 {
224 return new FloatForce(this.si * v.si, ForceUnit.SI);
225 }
226
227 }