panda.lang.mutable.MutableDouble Maven / Gradle / Ivy

Go to download
package panda.lang.mutable;

/**
 * A mutable double wrapper.
 * 
 * Note that as MutableDouble does not extend Double, it is not treated by String.format as a Double parameter. 
 * 
 */
public class MutableDouble extends Number implements Comparable, Mutable {

	/**
	 * Required for serialization support.
	 * 
	 * @see java.io.Serializable
	 */
	private static final long serialVersionUID = 1587163916L;

	/** The mutable value. */
	private double value;

	/**
	 * Constructs a new MutableDouble with the default value of zero.
	 */
	public MutableDouble() {
		super();
	}

	/**
	 * Constructs a new MutableDouble with the specified value.
	 * 
	 * @param value the initial value to store
	 */
	public MutableDouble(double value) {
		super();
		this.value = value;
	}

	/**
	 * Constructs a new MutableDouble with the specified value.
	 * 
	 * @param value the initial value to store, not null
	 * @throws NullPointerException if the object is null
	 */
	public MutableDouble(Number value) {
		super();
		this.value = value.doubleValue();
	}

	/**
	 * Constructs a new MutableDouble parsing the given string.
	 * 
	 * @param value the string to parse, not null
	 * @throws NumberFormatException if the string cannot be parsed into a double
	 */
	public MutableDouble(String value) throws NumberFormatException {
		super();
		this.value = Double.parseDouble(value);
	}

	// -----------------------------------------------------------------------
	/**
	 * Gets the value as a Double instance.
	 * 
	 * @return the value as a Double, never null
	 */
	public Double getValue() {
		return Double.valueOf(this.value);
	}

	/**
	 * Sets the value.
	 * 
	 * @param value the value to set
	 */
	public void setValue(double value) {
		this.value = value;
	}

	/**
	 * Sets the value from any Number instance.
	 * 
	 * @param value the value to set, not null
	 * @throws NullPointerException if the object is null
	 */
	public void setValue(Number value) {
		this.value = value.doubleValue();
	}

	// -----------------------------------------------------------------------
	/**
	 * Checks whether the double value is the special NaN value.
	 * 
	 * @return true if NaN
	 */
	public boolean isNaN() {
		return Double.isNaN(value);
	}

	/**
	 * Checks whether the double value is infinite.
	 * 
	 * @return true if infinite
	 */
	public boolean isInfinite() {
		return Double.isInfinite(value);
	}

	// -----------------------------------------------------------------------
	/**
	 * Increments the value.
	 */
	public void increment() {
		value++;
	}

	/**
	 * Decrements the value.
	 */
	public void decrement() {
		value--;
	}

	// -----------------------------------------------------------------------
	/**
	 * Adds a value to the value of this instance.
	 * 
	 * @param operand the value to add
	 */
	public void add(double operand) {
		this.value += operand;
	}

	/**
	 * Adds a value to the value of this instance.
	 * 
	 * @param operand the value to add, not null
	 * @throws NullPointerException if the object is null
	 */
	public void add(Number operand) {
		this.value += operand.doubleValue();
	}

	/**
	 * Subtracts a value from the value of this instance.
	 * 
	 * @param operand the value to subtract, not null
	 */
	public void subtract(double operand) {
		this.value -= operand;
	}

	/**
	 * Subtracts a value from the value of this instance.
	 * 
	 * @param operand the value to subtract, not null
	 * @throws NullPointerException if the object is null
	 */
	public void subtract(Number operand) {
		this.value -= operand.doubleValue();
	}

	// -----------------------------------------------------------------------
	// shortValue and byteValue rely on Number implementation
	/**
	 * Returns the value of this MutableDouble as an int.
	 * 
	 * @return the numeric value represented by this object after conversion to type int.
	 */
	@Override
	public int intValue() {
		return (int)value;
	}

	/**
	 * Returns the value of this MutableDouble as a long.
	 * 
	 * @return the numeric value represented by this object after conversion to type long.
	 */
	@Override
	public long longValue() {
		return (long)value;
	}

	/**
	 * Returns the value of this MutableDouble as a float.
	 * 
	 * @return the numeric value represented by this object after conversion to type float.
	 */
	@Override
	public float floatValue() {
		return (float)value;
	}

	/**
	 * Returns the value of this MutableDouble as a double.
	 * 
	 * @return the numeric value represented by this object after conversion to type double.
	 */
	@Override
	public double doubleValue() {
		return value;
	}

	// -----------------------------------------------------------------------
	/**
	 * Gets this mutable as an instance of Double.
	 * 
	 * @return a Double instance containing the value from this mutable, never null
	 */
	public Double toDouble() {
		return Double.valueOf(doubleValue());
	}

	// -----------------------------------------------------------------------
	/**
	 * Compares this object against the specified object. The result is true if and
	 * only if the argument is not null and is a Double object that
	 * represents a double that has the identical bit pattern to the bit pattern of the double
	 * represented by this object. For this purpose, two double values are considered
	 * to be the same if and only if the method {@link Double#doubleToLongBits(double)}returns the
	 * same long value when applied to each.
	 * 

	 * Note that in most cases, for two instances of class Double,d1 and
	 * d2, the value of d1.equals(d2) is true if and only if
	 * 

	 * 
	 * 	 * d1.doubleValue() == d2.doubleValue()
	 * 
	 * 
	 * 
	 * 
	 * also has the value true. However, there are two exceptions:
	 * 

	 * If d1 and d2 both represent Double.NaN, then the
	 * equals method returns true, even though
	 * Double.NaN==Double.NaN has the value false.
	 * 
If d1 represents +0.0 while d2 represents
	 * -0.0, or vice versa, the equal test has the value
	 * false, even though +0.0==-0.0 has the value true. This
	 * allows hashtables to operate properly.
	 * 
	 * 
	 * @param obj the object to compare with, null returns false
	 * @return true if the objects are the same; false otherwise.
	 */
	@Override
	public boolean equals(Object obj) {
		return obj instanceof MutableDouble
				&& Double.doubleToLongBits(((MutableDouble)obj).value) == Double.doubleToLongBits(value);
	}

	/**
	 * Returns a suitable hash code for this mutable.
	 * 
	 * @return a suitable hash code
	 */
	@Override
	public int hashCode() {
		long bits = Double.doubleToLongBits(value);
		return (int)(bits ^ bits >>> 32);
	}

	// -----------------------------------------------------------------------
	/**
	 * Compares this mutable to another in ascending order.
	 * 
	 * @param other the other mutable to compare to, not null
	 * @return negative if this is less, zero if equal, positive if greater
	 */
	public int compareTo(MutableDouble other) {
		double anotherVal = other.value;
		return Double.compare(value, anotherVal);
	}

	// -----------------------------------------------------------------------
	/**
	 * Returns the String value of this mutable.
	 * 
	 * @return the mutable value as a string
	 */
	@Override
	public String toString() {
		return String.valueOf(value);
	}

}