View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3.mutable;
18  
19  /**
20   * A mutable <code>double</code> wrapper.
21   * <p>
22   * Note that as MutableDouble does not extend Double, it is not treated by String.format as a Double parameter. 
23   * 
24   * @see Double
25   * @since 2.1
26   * @version $Id: MutableDouble.java 1436770 2013-01-22 07:09:45Z ggregory $
27   */
28  public class MutableDouble extends Number implements Comparable<MutableDouble>, Mutable<Number> {
29  
30      /**
31       * Required for serialization support.
32       * 
33       * @see java.io.Serializable
34       */
35      private static final long serialVersionUID = 1587163916L;
36  
37      /** The mutable value. */
38      private double value;
39  
40      /**
41       * Constructs a new MutableDouble with the default value of zero.
42       */
43      public MutableDouble() {
44          super();
45      }
46  
47      /**
48       * Constructs a new MutableDouble with the specified value.
49       * 
50       * @param value  the initial value to store
51       */
52      public MutableDouble(final double value) {
53          super();
54          this.value = value;
55      }
56  
57      /**
58       * Constructs a new MutableDouble with the specified value.
59       * 
60       * @param value  the initial value to store, not null
61       * @throws NullPointerException if the object is null
62       */
63      public MutableDouble(final Number value) {
64          super();
65          this.value = value.doubleValue();
66      }
67  
68      /**
69       * Constructs a new MutableDouble parsing the given string.
70       * 
71       * @param value  the string to parse, not null
72       * @throws NumberFormatException if the string cannot be parsed into a double
73       * @since 2.5
74       */
75      public MutableDouble(final String value) throws NumberFormatException {
76          super();
77          this.value = Double.parseDouble(value);
78      }
79  
80      //-----------------------------------------------------------------------
81      /**
82       * Gets the value as a Double instance.
83       * 
84       * @return the value as a Double, never null
85       */
86      @Override
87      public Double getValue() {
88          return Double.valueOf(this.value);
89      }
90  
91      /**
92       * Sets the value.
93       * 
94       * @param value  the value to set
95       */
96      public void setValue(final double value) {
97          this.value = value;
98      }
99  
100     /**
101      * Sets the value from any Number instance.
102      * 
103      * @param value  the value to set, not null
104      * @throws NullPointerException if the object is null
105      */
106     @Override
107     public void setValue(final Number value) {
108         this.value = value.doubleValue();
109     }
110 
111     //-----------------------------------------------------------------------
112     /**
113      * Checks whether the double value is the special NaN value.
114      * 
115      * @return true if NaN
116      */
117     public boolean isNaN() {
118         return Double.isNaN(value);
119     }
120 
121     /**
122      * Checks whether the double value is infinite.
123      * 
124      * @return true if infinite
125      */
126     public boolean isInfinite() {
127         return Double.isInfinite(value);
128     }
129 
130     //-----------------------------------------------------------------------
131     /**
132      * Increments the value.
133      *
134      * @since Commons Lang 2.2
135      */
136     public void increment() {
137         value++;
138     }
139 
140     /**
141      * Decrements the value.
142      *
143      * @since Commons Lang 2.2
144      */
145     public void decrement() {
146         value--;
147     }
148 
149     //-----------------------------------------------------------------------
150     /**
151      * Adds a value to the value of this instance.
152      * 
153      * @param operand  the value to add
154      * @since Commons Lang 2.2
155      */
156     public void add(final double operand) {
157         this.value += operand;
158     }
159 
160     /**
161      * Adds a value to the value of this instance.
162      * 
163      * @param operand  the value to add, not null
164      * @throws NullPointerException if the object is null
165      * @since Commons Lang 2.2
166      */
167     public void add(final Number operand) {
168         this.value += operand.doubleValue();
169     }
170 
171     /**
172      * Subtracts a value from the value of this instance.
173      * 
174      * @param operand  the value to subtract, not null
175      * @since Commons Lang 2.2
176      */
177     public void subtract(final double operand) {
178         this.value -= operand;
179     }
180 
181     /**
182      * Subtracts a value from the value of this instance.
183      * 
184      * @param operand  the value to subtract, not null
185      * @throws NullPointerException if the object is null
186      * @since Commons Lang 2.2
187      */
188     public void subtract(final Number operand) {
189         this.value -= operand.doubleValue();
190     }
191 
192     //-----------------------------------------------------------------------
193     // shortValue and byteValue rely on Number implementation
194     /**
195      * Returns the value of this MutableDouble as an int.
196      *
197      * @return the numeric value represented by this object after conversion to type int.
198      */
199     @Override
200     public int intValue() {
201         return (int) value;
202     }
203 
204     /**
205      * Returns the value of this MutableDouble as a long.
206      *
207      * @return the numeric value represented by this object after conversion to type long.
208      */
209     @Override
210     public long longValue() {
211         return (long) value;
212     }
213 
214     /**
215      * Returns the value of this MutableDouble as a float.
216      *
217      * @return the numeric value represented by this object after conversion to type float.
218      */
219     @Override
220     public float floatValue() {
221         return (float) value;
222     }
223 
224     /**
225      * Returns the value of this MutableDouble as a double.
226      *
227      * @return the numeric value represented by this object after conversion to type double.
228      */
229     @Override
230     public double doubleValue() {
231         return value;
232     }
233 
234     //-----------------------------------------------------------------------
235     /**
236      * Gets this mutable as an instance of Double.
237      *
238      * @return a Double instance containing the value from this mutable, never null
239      */
240     public Double toDouble() {
241         return Double.valueOf(doubleValue());
242     }
243 
244     //-----------------------------------------------------------------------
245     /**
246      * Compares this object against the specified object. The result is <code>true</code> if and only if the argument
247      * is not <code>null</code> and is a <code>Double</code> object that represents a double that has the identical
248      * bit pattern to the bit pattern of the double represented by this object. For this purpose, two
249      * <code>double</code> values are considered to be the same if and only if the method
250      * {@link Double#doubleToLongBits(double)}returns the same long value when applied to each.
251      * <p>
252      * Note that in most cases, for two instances of class <code>Double</code>,<code>d1</code> and <code>d2</code>,
253      * the value of <code>d1.equals(d2)</code> is <code>true</code> if and only if <blockquote>
254      * 
255      * <pre>
256      *   d1.doubleValue()&nbsp;== d2.doubleValue()
257      * </pre>
258      * 
259      * </blockquote>
260      * <p>
261      * also has the value <code>true</code>. However, there are two exceptions:
262      * <ul>
263      * <li>If <code>d1</code> and <code>d2</code> both represent <code>Double.NaN</code>, then the
264      * <code>equals</code> method returns <code>true</code>, even though <code>Double.NaN==Double.NaN</code> has
265      * the value <code>false</code>.
266      * <li>If <code>d1</code> represents <code>+0.0</code> while <code>d2</code> represents <code>-0.0</code>,
267      * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though
268      * <code>+0.0==-0.0</code> has the value <code>true</code>. This allows hashtables to operate properly.
269      * </ul>
270      * 
271      * @param obj  the object to compare with, null returns false
272      * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
273      */
274     @Override
275     public boolean equals(final Object obj) {
276         return obj instanceof MutableDouble
277             && Double.doubleToLongBits(((MutableDouble) obj).value) == Double.doubleToLongBits(value);
278     }
279 
280     /**
281      * Returns a suitable hash code for this mutable.
282      * 
283      * @return a suitable hash code
284      */
285     @Override
286     public int hashCode() {
287         final long bits = Double.doubleToLongBits(value);
288         return (int) (bits ^ bits >>> 32);
289     }
290 
291     //-----------------------------------------------------------------------
292     /**
293      * Compares this mutable to another in ascending order.
294      * 
295      * @param other  the other mutable to compare to, not null
296      * @return negative if this is less, zero if equal, positive if greater
297      */
298     @Override
299     public int compareTo(final MutableDouble other) {
300         final double anotherVal = other.value;
301         return Double.compare(value, anotherVal);
302     }
303 
304     //-----------------------------------------------------------------------
305     /**
306      * Returns the String value of this mutable.
307      * 
308      * @return the mutable value as a string
309      */
310     @Override
311     public String toString() {
312         return String.valueOf(value);
313     }
314 
315 }