View Javadoc
1   package org.djunits.value.vdouble.scalar.base;
2   
3   import org.djunits.unit.Unit;
4   import org.djunits.value.Relative;
5   import org.djunits.value.util.ValueUtil;
6   import org.djunits.value.vdouble.scalar.SIScalar;
7   
8   /**
9    * The typed, abstract DoubleScalarRel class that forms the basis of all DoubleScalar definitions and extensions.<br>
10   * Note: A relative scalar class can implement the toAbs() method if it has an absolute equivalent.
11   * <p>
12   * Copyright (c) 2013-2024 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
13   * BSD-style license. See <a href="https://djunits.org/docs/license.html">DJUNITS License</a>.
14   * </p>
15   * @author <a href="https://www.tudelft.nl/averbraeck">Alexander Verbraeck</a>
16   * @author <a href="https://www.tudelft.nl/staff/p.knoppers/">Peter Knoppers</a>
17   * @param <U> the unit
18   * @param <R> the Relative class for reference purposes
19   */
20  public abstract class DoubleScalarRel<U extends Unit<U>, R extends DoubleScalarRel<U, R>>
21          extends DoubleScalar<U, R> implements Relative<U, R>
22  {
23      /**  */
24      private static final long serialVersionUID = 20150626L;
25  
26      /**
27       * Construct a new Relative Immutable DoubleScalar.
28       * @param value double; the value of the new Relative Immutable DoubleScalar
29       * @param unit U; the unit of the new Relative Immutable DoubleScalar
30       */
31      public DoubleScalarRel(final double value, final U unit)
32      {
33          super(unit, unit.isBaseSIUnit() ? value : ValueUtil.expressAsSIUnit(value, unit));
34      }
35  
36      /**
37       * Construct a new Relative Immutable DoubleScalar from an existing Relative Immutable DoubleScalar.
38       * @param value R, a relative typed DoubleScalar; the reference
39       */
40      public DoubleScalarRel(final R value)
41      {
42          super(value.getDisplayUnit(), value.getSI());
43      }
44  
45      /**
46       * Construct a new Relative Immutable DoubleScalar of the right type. Each extending class must implement this method.
47       * @param value double; the double value
48       * @param unit U; the unit
49       * @return R a new relative instance of the DoubleScalar of the right type
50       */
51      public abstract R instantiateRel(double value, U unit);
52  
53      @Override
54      public final R plus(final R increment)
55      {
56          if (getDisplayUnit().isBaseSIUnit())
57          {
58              return instantiateRel(this.getSI() + increment.getSI(), getDisplayUnit().getStandardUnit());
59          }
60          return getDisplayUnit().equals(increment.getDisplayUnit())
61                  ? instantiateRel(getInUnit() + increment.getInUnit(), getDisplayUnit())
62                  : instantiateRel(this.getSI() + increment.getSI(), getDisplayUnit().getStandardUnit());
63      }
64  
65      @Override
66      public final R minus(final R decrement)
67      {
68          if (getDisplayUnit().isBaseSIUnit())
69          {
70              return instantiateRel(this.getSI() - decrement.getSI(), getDisplayUnit().getStandardUnit());
71          }
72          return getDisplayUnit().equals(decrement.getDisplayUnit())
73                  ? instantiateRel(getInUnit() - decrement.getInUnit(), getDisplayUnit())
74                  : instantiateRel(this.getSI() - decrement.getSI(), getDisplayUnit().getStandardUnit());
75      }
76  
77      /**
78       * Multiply this scalar by another scalar and create a new scalar.
79       * @param otherScalar DoubleScalarRel&lt;?, ?&gt;; the value by which this scalar is multiplied
80       * @return DoubleScalar&lt;?&gt;; a new scalar instance with correct SI dimensions
81       */
82      public SIScalar times(final DoubleScalarRel<?, ?> otherScalar)
83      {
84          return DoubleScalar.multiply(this, otherScalar);
85      }
86  
87      /**
88       * Create the reciprocal of this scalar with the correct dimensions.
89       * @return DoubleScalar&lt;?&gt;; a new scalar instance with correct SI dimensions
90       */
91      public abstract DoubleScalarRel<?, ?> reciprocal();
92  
93      /**
94       * Divide this scalar by another scalar and create a new scalar.
95       * @param otherScalar DoubleScalarRel&lt;?, ?&gt;; the value by which this scalar is divided
96       * @return DoubleScalar&lt;?&gt;; a new scalar instance with correct SI dimensions
97       */
98      public SIScalar divide(final DoubleScalarRel<?, ?> otherScalar)
99      {
100         return DoubleScalar.divide(this, otherScalar);
101     }
102 
103     /**********************************************************************************/
104     /********************************** MATH METHODS **********************************/
105     /**********************************************************************************/
106 
107     @Override
108     public R abs()
109     {
110         return instantiateRel(Math.abs(getInUnit()), getDisplayUnit());
111     }
112 
113     @Override
114     public R ceil()
115     {
116         return instantiateRel(Math.ceil(getInUnit()), getDisplayUnit());
117     }
118 
119     @Override
120     public R floor()
121     {
122         return instantiateRel(Math.floor(getInUnit()), getDisplayUnit());
123     }
124 
125     @Override
126     public R rint()
127     {
128         return instantiateRel(Math.rint(getInUnit()), getDisplayUnit());
129     }
130 
131     @Override
132     public R neg()
133     {
134         return instantiateRel(-getInUnit(), getDisplayUnit());
135     }
136 
137     @Override
138     public R times(final double constant)
139     {
140         return instantiateRel(getInUnit() * constant, getDisplayUnit());
141     }
142 
143     @Override
144     public R divide(final double constant)
145     {
146         return instantiateRel(getInUnit() / constant, getDisplayUnit());
147     }
148 
149     @Override
150     public R times(final float constant)
151     {
152         return instantiateRel(getInUnit() * constant, getDisplayUnit());
153     }
154 
155     @Override
156     public R divide(final float constant)
157     {
158         return instantiateRel(getInUnit() / constant, getDisplayUnit());
159     }
160 
161 }