1 package org.djunits.value.vfloat.scalar; 2 3 import org.djunits.unit.AbsoluteLinearUnit; 4 import org.djunits.unit.SICoefficients; 5 import org.djunits.unit.SIUnit; 6 import org.djunits.unit.Unit; 7 8 /** 9 * Immutable FloatScalar. 10 * <p> 11 * This file was generated by the djunits value classes generator, 26 jun, 2015 12 * <p> 13 * Copyright (c) 2015-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br> 14 * BSD-style license. See <a href="http://djunits.org/docs/license.html">DJUNITS License</a>. 15 * <p> 16 * $LastChangedDate: 2019-01-18 00:35:01 +0100 (Fri, 18 Jan 2019) $, @version $Revision: 324 $, by $Author: averbraeck $, 17 * initial version 26 jun, 2015 <br> 18 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a> 19 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a> 20 */ 21 public abstract class FloatScalar 22 { 23 /** 24 * Absolute Immutable FloatScalar. 25 * @param <AU> Absolute unit 26 * @param <RU> Relative unit 27 */ 28 public static class Abs<AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>> 29 extends AbstractFloatScalarAbs<AU, FloatScalar.Abs<AU, RU>, RU, FloatScalar.Rel<RU>> 30 { 31 /** */ 32 private static final long serialVersionUID = 20150626L; 33 34 /** 35 * Construct a new Absolute Immutable FloatScalar. 36 * @param value float; the value of the new Absolute Immutable FloatScalar 37 * @param unit AU; the unit of the new Absolute Immutable FloatScalar 38 */ 39 public Abs(final float value, final AU unit) 40 { 41 super(value, unit); 42 } 43 44 /** 45 * Construct a new Absolute Immutable FloatScalar from an existing Absolute Immutable FloatScalar. 46 * @param value FloatScalar.Abs<AU, RU>; the reference 47 */ 48 public Abs(final FloatScalar.Abs<AU, RU> value) 49 { 50 super(value); 51 } 52 53 /** {@inheritDoc} */ 54 @Override 55 public final FloatScalar.Abs<AU, RU> instantiateAbs(final float value, final AU unit) 56 { 57 return new FloatScalar.Abs<>(value, unit); 58 } 59 60 /** {@inheritDoc} */ 61 @Override 62 public final FloatScalar.Rel<RU> instantiateRel(final float value, final RU unit) 63 { 64 return new FloatScalar.Rel<>(value, unit); 65 } 66 67 } 68 69 /** 70 * Relative Immutable FloatScalar. 71 * @param <U> Unit 72 */ 73 public static class Rel<U extends Unit<U>> extends AbstractFloatScalarRel<U, FloatScalar.Rel<U>> 74 { 75 /** */ 76 private static final long serialVersionUID = 20150626L; 77 78 /** 79 * Construct a new Relative Immutable FloatScalar. 80 * @param value float; the value of the new Relative Immutable FloatScalar 81 * @param unit U; the unit of the new Relative Immutable FloatScalar 82 */ 83 public Rel(final float value, final U unit) 84 { 85 super(value, unit); 86 } 87 88 /** 89 * Construct a new Relative Immutable FloatScalar from an existing Relative Immutable FloatScalar. 90 * @param value FloatScalar.Rel<U>; the reference 91 */ 92 public Rel(final FloatScalar.Rel<U> value) 93 { 94 super(value); 95 } 96 97 /** {@inheritDoc} */ 98 @Override 99 public final FloatScalar.Rel<U> instantiateRel(final float value, final U unit) 100 { 101 return new FloatScalar.Rel<>(value, unit); 102 } 103 104 } 105 106 /**********************************************************************************/ 107 /********************************* STATIC METHODS *********************************/ 108 /**********************************************************************************/ 109 110 /** 111 * Add a Relative value to an Absolute value. Return a new instance of the value. The unit of the return value will be the 112 * unit of the left argument. 113 * @param left A, an absolute typed FloatScalar; the left argument 114 * @param right R, a relative typed FloatScalar; the right argument 115 * @param <AU> Unit; the absolute unit of the parameter and the result 116 * @param <RU> Unit; the relative unit of the parameter 117 * @param <R> the relative type 118 * @param <A> the corresponding absolute type 119 * @return A, an absolute typed FloatScalar; the sum of the values as an Absolute value 120 */ 121 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>, R extends AbstractFloatScalarRel<RU, R>, 122 A extends AbstractFloatScalarAbs<AU, A, RU, R>> A plus(final A left, final R right) 123 { 124 return left.plus(right); 125 } 126 127 /** 128 * Add an Absolute value to a Relative value. Return a new instance of the value. The unit of the return value will be the 129 * unit of the left argument. 130 * @param left A, an absolute typed FloatScalar; the left argument 131 * @param right R, a relative typed FloatScalar; the right argument 132 * @param <AU> Unit; the absolute unit of the parameter and the result 133 * @param <RU> Unit; the relative unit of the parameter 134 * @param <R> the relative type 135 * @param <A> the corresponding absolute type 136 * @return A, an absolute typed FloatScalar; the sum of the values as an Absolute value 137 */ 138 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>, R extends AbstractFloatScalarRel<RU, R>, 139 A extends AbstractFloatScalarAbs<AU, A, RU, R>> A plus(final R left, final A right) 140 { 141 return right.plus(left); 142 } 143 144 /** 145 * Add a Relative value to a Relative value. Return a new instance of the value. The unit of the return value will be the 146 * unit of the left argument. 147 * @param left R, a relative typed FloatScalar; the left argument 148 * @param right R, a relative typed FloatScalar; the right argument 149 * @param <U> Unit; the unit of the parameters and the result 150 * @param <R> the relative type 151 * @return R, a relative typed FloatScalar; the sum of the values as a Relative value 152 */ 153 public static <U extends Unit<U>, R extends AbstractFloatScalarRel<U, R>> R plus(final R left, final R right) 154 { 155 return left.plus(right); 156 } 157 158 /** 159 * Subtract a Relative value from an absolute value. Return a new instance of the value. The unit of the return value will 160 * be the unit of the left argument. 161 * @param left A, an absolute typed FloatScalar; the left value 162 * @param right R, a relative typed FloatScalar; the right value 163 * @param <AU> Unit; the absolute unit of the parameter and the result 164 * @param <RU> Unit; the relative unit of the parameter 165 * @param <R> the relative type 166 * @param <A> the corresponding absolute type 167 * @return A, an absolute typed FloatScalar; the resulting value as an absolute value 168 */ 169 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>, R extends AbstractFloatScalarRel<RU, R>, 170 A extends AbstractFloatScalarAbs<AU, A, RU, R>> A minus(final A left, final R right) 171 { 172 return left.minus(right); 173 } 174 175 /** 176 * Subtract a relative value from a relative value. Return a new instance of the value. The unit of the value will be the 177 * unit of the first argument. 178 * @param left R, a relative typed FloatScalar; the left value 179 * @param right R, a relative typed FloatScalar; the right value 180 * @param <U> Unit; the unit of the parameters and the result 181 * @param <R> the relative type 182 * @return R, a relative typed FloatScalar; the resulting value as a relative value 183 */ 184 public static <U extends Unit<U>, R extends AbstractFloatScalarRel<U, R>> R minus(final R left, final R right) 185 { 186 return left.minus(right); 187 } 188 189 /** 190 * Subtract two absolute values. Return a new instance of a relative value of the difference. The unit of the value will be 191 * the unit of the first argument. 192 * @param left A, an absolute typed FloatScalar; value 1 193 * @param right A, an absolute typed FloatScalar; value 2 194 * @param <AU> Unit; the absolute unit of the parameter 195 * @param <RU> Unit; the relative unit of the parameter and the result 196 * @param <R> the relative type 197 * @param <A> the corresponding absolute type 198 * @return R, a relative typed FloatScalar; the difference of the two absolute values as a relative value 199 */ 200 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>, R extends AbstractFloatScalarRel<RU, R>, 201 A extends AbstractFloatScalarAbs<AU, A, RU, R>> R minus(final A left, final A right) 202 { 203 return left.minus(right); 204 } 205 206 /** 207 * Interpolate between or extrapolate over two values. 208 * @param zero A, an absolute typed FloatScalar; zero reference (returned when ratio == 0) 209 * @param one A, an absolute typed FloatScalar; one reference (returned when ratio == 1) 210 * @param ratio float; the ratio that determines where between (or outside) zero and one the result lies 211 * @param <AU> Unit; the absolute unit of the parameter and the result 212 * @param <RU> Unit; the relative unit belonging to the absolute unit 213 * @param <R> the relative type 214 * @param <A> the corresponding absolute type 215 * @return Absolute FloatScalar 216 */ 217 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>, R extends AbstractFloatScalarRel<RU, R>, 218 A extends AbstractFloatScalarAbs<AU, A, RU, R>> A interpolate(final A zero, final A one, final float ratio) 219 { 220 return zero.instantiateAbs(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit()); 221 } 222 223 /** 224 * Interpolate between or extrapolate over two values. 225 * @param zero R, a relative typed FloatScalar; zero reference (returned when ratio == 0) 226 * @param one R, a relative typed FloatScalar; one reference (returned when ratio == 1) 227 * @param ratio float; the ratio that determines where between (or outside) zero and one the result lies 228 * @param <U> Unit; the unit of the parameters and the result 229 * @param <R> the relative type 230 * @return Relative FloatScalar 231 */ 232 public static <U extends Unit<U>, R extends AbstractFloatScalarRel<U, R>> R interpolate(final R zero, final R one, 233 final float ratio) 234 { 235 return zero.instantiateRel(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit()); 236 } 237 238 /** 239 * Multiply two values; the result is a new instance with a different (existing or generated) SI unit. 240 * @param left AbstractFloatScalarRel<?, ?>; the left operand 241 * @param right AbstractFloatScalarRel<?, ?>; the right operand 242 * @return FloatScalar.Rel<SIUnit>; the product of the two values 243 */ 244 public static FloatScalar.Rel<SIUnit> multiply(final AbstractFloatScalarRel<?, ?> left, 245 final AbstractFloatScalarRel<?, ?> right) 246 { 247 SIUnit targetUnit = Unit.lookupOrCreateSIUnitWithSICoefficients( 248 SICoefficients.multiply(left.getUnit().getSICoefficients(), right.getUnit().getSICoefficients()).toString()); 249 return new FloatScalar.Rel<SIUnit>(left.getSI() * right.getSI(), targetUnit); 250 } 251 252 /** 253 * Divide two values; the result is a new instance with a different (existing or generated) SI unit. 254 * @param left AbstractFloatScalarRel<?, ?>; the left operand 255 * @param right AbstractFloatScalarRel<?, ?>; the right operand 256 * @return FloatScalar.Rel<SIUnit>; the ratio of the two values 257 */ 258 public static FloatScalar.Rel<SIUnit> divide(final AbstractFloatScalarRel<?, ?> left, 259 final AbstractFloatScalarRel<?, ?> right) 260 { 261 SIUnit targetUnit = Unit.lookupOrCreateSIUnitWithSICoefficients( 262 SICoefficients.divide(left.getUnit().getSICoefficients(), right.getUnit().getSICoefficients()).toString()); 263 return new FloatScalar.Rel<SIUnit>(left.getSI() / right.getSI(), targetUnit); 264 } 265 266 /** 267 * Interpolate between or extrapolate over two values. 268 * @param zero FloatScalar.Abs<AU, RU>; zero reference (returned when ratio == 0) 269 * @param one FloatScalar.Abs<AU, RU>; one reference (returned when ratio == 1) 270 * @param ratio float; the ratio that determines where between (or outside) zero and one the result lies 271 * @param <AU> Unit; the absolute unit of the parameter and the result 272 * @param <RU> Unit; the relative unit belonging to the absolute unit 273 * @return FloatScalar.Abs<U> 274 */ 275 public static <AU extends AbsoluteLinearUnit<AU, RU>, RU extends Unit<RU>> FloatScalar.Abs<AU, RU> interpolate( 276 final FloatScalar.Abs<AU, RU> zero, final FloatScalar.Abs<AU, RU> one, final float ratio) 277 { 278 return new FloatScalar.Abs<AU, RU>(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, 279 zero.getUnit()); 280 } 281 282 /** 283 * Interpolate between or extrapolate over two values. 284 * @param zero FloatScalar.Rel<U>; zero reference (returned when ratio == 0) 285 * @param one FloatScalar.Rel<U>; one reference (returned when ratio == 1) 286 * @param ratio float; the ratio that determines where between (or outside) zero and one the result lies 287 * @param <U> Unit; the unit of the parameters and the result 288 * @return FloatScalar.Rel<U> 289 */ 290 public static <U extends Unit<U>> FloatScalar.Rel<U> interpolate(final FloatScalar.Rel<U> zero, 291 final FloatScalar.Rel<U> one, final float ratio) 292 { 293 return new FloatScalar.Rel<U>(zero.getInUnit() * (1 - ratio) + one.getInUnit(zero.getUnit()) * ratio, zero.getUnit()); 294 } 295 296 }