001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.lang3.mutable;
018
019 /**
020 * A mutable <code>double</code> wrapper.
021 * <p>
022 * Note that as MutableDouble does not extend Double, it is not treated by String.format as a Double parameter.
023 *
024 * @see Double
025 * @since 2.1
026 * @version $Id: MutableDouble.java 1199894 2011-11-09 17:53:59Z ggregory $
027 */
028 public class MutableDouble extends Number implements Comparable<MutableDouble>, Mutable<Number> {
029
030 /**
031 * Required for serialization support.
032 *
033 * @see java.io.Serializable
034 */
035 private static final long serialVersionUID = 1587163916L;
036
037 /** The mutable value. */
038 private double value;
039
040 /**
041 * Constructs a new MutableDouble with the default value of zero.
042 */
043 public MutableDouble() {
044 super();
045 }
046
047 /**
048 * Constructs a new MutableDouble with the specified value.
049 *
050 * @param value the initial value to store
051 */
052 public MutableDouble(double value) {
053 super();
054 this.value = value;
055 }
056
057 /**
058 * Constructs a new MutableDouble with the specified value.
059 *
060 * @param value the initial value to store, not null
061 * @throws NullPointerException if the object is null
062 */
063 public MutableDouble(Number value) {
064 super();
065 this.value = value.doubleValue();
066 }
067
068 /**
069 * Constructs a new MutableDouble parsing the given string.
070 *
071 * @param value the string to parse, not null
072 * @throws NumberFormatException if the string cannot be parsed into a double
073 * @since 2.5
074 */
075 public MutableDouble(String value) throws NumberFormatException {
076 super();
077 this.value = Double.parseDouble(value);
078 }
079
080 //-----------------------------------------------------------------------
081 /**
082 * Gets the value as a Double instance.
083 *
084 * @return the value as a Double, never null
085 */
086 public Double getValue() {
087 return Double.valueOf(this.value);
088 }
089
090 /**
091 * Sets the value.
092 *
093 * @param value the value to set
094 */
095 public void setValue(double value) {
096 this.value = value;
097 }
098
099 /**
100 * Sets the value from any Number instance.
101 *
102 * @param value the value to set, not null
103 * @throws NullPointerException if the object is null
104 */
105 public void setValue(Number value) {
106 this.value = value.doubleValue();
107 }
108
109 //-----------------------------------------------------------------------
110 /**
111 * Checks whether the double value is the special NaN value.
112 *
113 * @return true if NaN
114 */
115 public boolean isNaN() {
116 return Double.isNaN(value);
117 }
118
119 /**
120 * Checks whether the double value is infinite.
121 *
122 * @return true if infinite
123 */
124 public boolean isInfinite() {
125 return Double.isInfinite(value);
126 }
127
128 //-----------------------------------------------------------------------
129 /**
130 * Increments the value.
131 *
132 * @since Commons Lang 2.2
133 */
134 public void increment() {
135 value++;
136 }
137
138 /**
139 * Decrements the value.
140 *
141 * @since Commons Lang 2.2
142 */
143 public void decrement() {
144 value--;
145 }
146
147 //-----------------------------------------------------------------------
148 /**
149 * Adds a value to the value of this instance.
150 *
151 * @param operand the value to add
152 * @since Commons Lang 2.2
153 */
154 public void add(double operand) {
155 this.value += operand;
156 }
157
158 /**
159 * Adds a value to the value of this instance.
160 *
161 * @param operand the value to add, not null
162 * @throws NullPointerException if the object is null
163 * @since Commons Lang 2.2
164 */
165 public void add(Number operand) {
166 this.value += operand.doubleValue();
167 }
168
169 /**
170 * Subtracts a value from the value of this instance.
171 *
172 * @param operand the value to subtract, not null
173 * @since Commons Lang 2.2
174 */
175 public void subtract(double operand) {
176 this.value -= operand;
177 }
178
179 /**
180 * Subtracts a value from the value of this instance.
181 *
182 * @param operand the value to subtract, not null
183 * @throws NullPointerException if the object is null
184 * @since Commons Lang 2.2
185 */
186 public void subtract(Number operand) {
187 this.value -= operand.doubleValue();
188 }
189
190 //-----------------------------------------------------------------------
191 // shortValue and byteValue rely on Number implementation
192 /**
193 * Returns the value of this MutableDouble as an int.
194 *
195 * @return the numeric value represented by this object after conversion to type int.
196 */
197 @Override
198 public int intValue() {
199 return (int) value;
200 }
201
202 /**
203 * Returns the value of this MutableDouble as a long.
204 *
205 * @return the numeric value represented by this object after conversion to type long.
206 */
207 @Override
208 public long longValue() {
209 return (long) value;
210 }
211
212 /**
213 * Returns the value of this MutableDouble as a float.
214 *
215 * @return the numeric value represented by this object after conversion to type float.
216 */
217 @Override
218 public float floatValue() {
219 return (float) value;
220 }
221
222 /**
223 * Returns the value of this MutableDouble as a double.
224 *
225 * @return the numeric value represented by this object after conversion to type double.
226 */
227 @Override
228 public double doubleValue() {
229 return value;
230 }
231
232 //-----------------------------------------------------------------------
233 /**
234 * Gets this mutable as an instance of Double.
235 *
236 * @return a Double instance containing the value from this mutable, never null
237 */
238 public Double toDouble() {
239 return Double.valueOf(doubleValue());
240 }
241
242 //-----------------------------------------------------------------------
243 /**
244 * Compares this object against the specified object. The result is <code>true</code> if and only if the argument
245 * is not <code>null</code> and is a <code>Double</code> object that represents a double that has the identical
246 * bit pattern to the bit pattern of the double represented by this object. For this purpose, two
247 * <code>double</code> values are considered to be the same if and only if the method
248 * {@link Double#doubleToLongBits(double)}returns the same long value when applied to each.
249 * <p>
250 * Note that in most cases, for two instances of class <code>Double</code>,<code>d1</code> and <code>d2</code>,
251 * the value of <code>d1.equals(d2)</code> is <code>true</code> if and only if <blockquote>
252 *
253 * <pre>
254 * d1.doubleValue() == d2.doubleValue()
255 * </pre>
256 *
257 * </blockquote>
258 * <p>
259 * also has the value <code>true</code>. However, there are two exceptions:
260 * <ul>
261 * <li>If <code>d1</code> and <code>d2</code> both represent <code>Double.NaN</code>, then the
262 * <code>equals</code> method returns <code>true</code>, even though <code>Double.NaN==Double.NaN</code> has
263 * the value <code>false</code>.
264 * <li>If <code>d1</code> represents <code>+0.0</code> while <code>d2</code> represents <code>-0.0</code>,
265 * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though
266 * <code>+0.0==-0.0</code> has the value <code>true</code>. This allows hashtables to operate properly.
267 * </ul>
268 *
269 * @param obj the object to compare with, null returns false
270 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
271 */
272 @Override
273 public boolean equals(Object obj) {
274 return obj instanceof MutableDouble
275 && Double.doubleToLongBits(((MutableDouble) obj).value) == Double.doubleToLongBits(value);
276 }
277
278 /**
279 * Returns a suitable hash code for this mutable.
280 *
281 * @return a suitable hash code
282 */
283 @Override
284 public int hashCode() {
285 long bits = Double.doubleToLongBits(value);
286 return (int) (bits ^ bits >>> 32);
287 }
288
289 //-----------------------------------------------------------------------
290 /**
291 * Compares this mutable to another in ascending order.
292 *
293 * @param other the other mutable to compare to, not null
294 * @return negative if this is less, zero if equal, positive if greater
295 */
296 public int compareTo(MutableDouble other) {
297 double anotherVal = other.value;
298 return Double.compare(value, anotherVal);
299 }
300
301 //-----------------------------------------------------------------------
302 /**
303 * Returns the String value of this mutable.
304 *
305 * @return the mutable value as a string
306 */
307 @Override
308 public String toString() {
309 return String.valueOf(value);
310 }
311
312 }