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.lang.mutable; 018 019 import org.apache.commons.lang.math.NumberUtils; 020 021 /** 022 * A mutable <code>double</code> wrapper. 023 * 024 * @see Double 025 * @since 2.1 026 * @version $Id: MutableDouble.java 618693 2008-02-05 16:33:29Z sebb $ 027 */ 028 public class MutableDouble extends Number implements Comparable, Mutable { 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 051 * a value. 052 */ 053 public MutableDouble(double value) { 054 super(); 055 this.value = value; 056 } 057 058 /** 059 * Constructs a new MutableDouble with the specified value. 060 * 061 * @param value 062 * a value. 063 * @throws NullPointerException 064 * if the object is null 065 */ 066 public MutableDouble(Number value) { 067 super(); 068 this.value = value.doubleValue(); 069 } 070 071 //----------------------------------------------------------------------- 072 /** 073 * Gets the value as a Double instance. 074 * 075 * @return the value as a Double 076 */ 077 public Object getValue() { 078 return new Double(this.value); 079 } 080 081 /** 082 * Sets the value. 083 * 084 * @param value 085 * the value to set 086 */ 087 public void setValue(double value) { 088 this.value = value; 089 } 090 091 /** 092 * Sets the value from any Number instance. 093 * 094 * @param value 095 * the value to set 096 * @throws NullPointerException 097 * if the object is null 098 * @throws ClassCastException 099 * if the type is not a {@link Number} 100 */ 101 public void setValue(Object value) { 102 setValue(((Number) value).doubleValue()); 103 } 104 105 //----------------------------------------------------------------------- 106 // shortValue and bytValue rely on Number implementation 107 /** 108 * Returns the value of this MutableDouble as a int. 109 * 110 * @return the numeric value represented by this object after conversion to type int. 111 */ 112 public int intValue() { 113 return (int) value; 114 } 115 116 /** 117 * Returns the value of this MutableDouble as a long. 118 * 119 * @return the numeric value represented by this object after conversion to type long. 120 */ 121 public long longValue() { 122 return (long) value; 123 } 124 125 /** 126 * Returns the value of this MutableDouble as a float. 127 * 128 * @return the numeric value represented by this object after conversion to type float. 129 */ 130 public float floatValue() { 131 return (float) value; 132 } 133 134 /** 135 * Returns the value of this MutableDouble as a double. 136 * 137 * @return the numeric value represented by this object after conversion to type double. 138 */ 139 public double doubleValue() { 140 return value; 141 } 142 143 /** 144 * Checks whether the double value is the special NaN value. 145 * 146 * @return true if NaN 147 */ 148 public boolean isNaN() { 149 return Double.isNaN(value); 150 } 151 152 /** 153 * Checks whether the double value is infinite. 154 * 155 * @return true if infinite 156 */ 157 public boolean isInfinite() { 158 return Double.isInfinite(value); 159 } 160 161 //----------------------------------------------------------------------- 162 /** 163 * Gets this mutable as an instance of Double. 164 * 165 * @return a Double instance containing the value from this mutable 166 */ 167 public Double toDouble() { 168 return new Double(doubleValue()); 169 } 170 171 //----------------------------------------------------------------------- 172 /** 173 * Increments the value. 174 * 175 * @since Commons Lang 2.2 176 */ 177 public void increment() { 178 value++; 179 } 180 181 /** 182 * Decrements the value. 183 * 184 * @since Commons Lang 2.2 185 */ 186 public void decrement() { 187 value--; 188 } 189 190 //----------------------------------------------------------------------- 191 /** 192 * Adds a value. 193 * 194 * @param operand 195 * the value to add 196 * 197 * @since Commons Lang 2.2 198 */ 199 public void add(double operand) { 200 this.value += operand; 201 } 202 203 /** 204 * Adds a value. 205 * 206 * @param operand 207 * the value to add 208 * @throws NullPointerException 209 * if the object is null 210 * 211 * @since Commons Lang 2.2 212 */ 213 public void add(Number operand) { 214 this.value += operand.doubleValue(); 215 } 216 217 /** 218 * Subtracts a value. 219 * 220 * @param operand 221 * the value to add 222 * 223 * @since Commons Lang 2.2 224 */ 225 public void subtract(double operand) { 226 this.value -= operand; 227 } 228 229 /** 230 * Subtracts a value. 231 * 232 * @param operand 233 * the value to add 234 * @throws NullPointerException 235 * if the object is null 236 * 237 * @since Commons Lang 2.2 238 */ 239 public void subtract(Number operand) { 240 this.value -= operand.doubleValue(); 241 } 242 243 //----------------------------------------------------------------------- 244 /** 245 * Compares this object against the specified object. The result is <code>true</code> if and only if the argument 246 * is not <code>null</code> and is a <code>Double</code> object that represents a double that has the identical 247 * bit pattern to the bit pattern of the double represented by this object. For this purpose, two 248 * <code>double</code> values are considered to be the same if and only if the method 249 * {@link Double#doubleToLongBits(double)}returns the same long value when applied to each. 250 * <p> 251 * Note that in most cases, for two instances of class <code>Double</code>,<code>d1</code> and <code>d2</code>, 252 * the value of <code>d1.equals(d2)</code> is <code>true</code> if and only if <blockquote> 253 * 254 * <pre> 255 * d1.doubleValue() == d2.doubleValue() 256 * </pre> 257 * 258 * </blockquote> 259 * <p> 260 * also has the value <code>true</code>. However, there are two exceptions: 261 * <ul> 262 * <li>If <code>d1</code> and <code>d2</code> both represent <code>Double.NaN</code>, then the 263 * <code>equals</code> method returns <code>true</code>, even though <code>Double.NaN==Double.NaN</code> has 264 * the value <code>false</code>. 265 * <li>If <code>d1</code> represents <code>+0.0</code> while <code>d2</code> represents <code>-0.0</code>, 266 * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though 267 * <code>+0.0==-0.0</code> has the value <code>true</code>. This allows hashtables to operate properly. 268 * </ul> 269 * 270 * @param obj 271 * the object to compare with. 272 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise. 273 */ 274 public boolean equals(Object obj) { 275 return (obj instanceof MutableDouble) 276 && (Double.doubleToLongBits(((MutableDouble) obj).value) == Double.doubleToLongBits(value)); 277 } 278 279 /** 280 * Returns a suitable hashcode for this mutable. 281 * 282 * @return a suitable hashcode 283 */ 284 public int hashCode() { 285 long bits = Double.doubleToLongBits(value); 286 return (int) (bits ^ (bits >>> 32)); 287 } 288 289 /** 290 * Compares this mutable to another in ascending order. 291 * 292 * @param obj 293 * the mutable to compare to 294 * @return negative if this is less, zero if equal, positive if greater 295 * @throws ClassCastException if the argument is not a MutableDouble 296 */ 297 public int compareTo(Object obj) { 298 MutableDouble other = (MutableDouble) obj; 299 double anotherVal = other.value; 300 return NumberUtils.compare(value, anotherVal); 301 } 302 303 /** 304 * Returns the String value of this mutable. 305 * 306 * @return the mutable value as a string 307 */ 308 public String toString() { 309 return String.valueOf(value); 310 } 311 312 }