MutableDoubleScalar.java

package org.opentrafficsim.core.value.vdouble.scalar;

import org.opentrafficsim.core.unit.Unit;
import org.opentrafficsim.core.value.Absolute;
import org.opentrafficsim.core.value.Relative;
import org.opentrafficsim.core.value.ValueUtil;
import org.opentrafficsim.core.value.vdouble.DoubleMathFunctions;

/**
 * MutableDoubleScalar.
 * <p>
 * This file was generated by the OpenTrafficSim value classes generator, 09 mrt, 2015
 * <p>
 * Copyright (c) 2014 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
 * BSD-style license. See <a href="http://opentrafficsim.org/node/13">OpenTrafficSim License</a>.
 * <p>
 * @version 09 mrt, 2015 <br>
 * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
 * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
 * @param <U> Unit; the unit of this MutableDoubleScalar
 */
public abstract class MutableDoubleScalar<U extends Unit<U>> extends DoubleScalar<U> implements
        DoubleMathFunctions<DoubleScalar<U>>
{
    /**  */
    private static final long serialVersionUID = 20150309L;

    /**
     * Construct a new MutableDoubleScalar.
     * @param unit U; the unit of the new MutableDoubleScalar
     */
    protected MutableDoubleScalar(final U unit)
    {
        super(unit);
        // System.out.println("Created MutableDoubleScalar");
    }

    /**
     * @param <U> Unit
     */
    public static class Abs<U extends Unit<U>> extends MutableDoubleScalar<U> implements Absolute, Comparable<Abs<U>>
    {
        /**  */
        private static final long serialVersionUID = 20150309L;

        /**
         * Construct a new Absolute MutableDoubleScalar.
         * @param value double; the value of the new Absolute MutableDoubleScalar
         * @param unit U; the unit of the new Absolute MutableDoubleScalar
         */
        public Abs(final double value, final U unit)
        {
            super(unit);
            // System.out.println("Created Abs");
            initialize(value);
        }

        /**
         * Construct a new Absolute MutableDoubleScalar from an existing Absolute Immutable DoubleScalar.
         * @param value DoubleScalar.Abs&lt;U&gt;; the reference
         */
        public Abs(final DoubleScalar.Abs<U> value)
        {
            super(value.getUnit());
            // System.out.println("Created Abs");
            initialize(value);
        }

        /**
         * Construct a new Absolute MutableDoubleScalar from an existing Absolute MutableDoubleScalar.
         * @param value MutableDoubleScalar.Abs&lt;U&gt;; the reference
         */
        public Abs(final MutableDoubleScalar.Abs<U> value)
        {
            super(value.getUnit());
            // System.out.println("Created Abs");
            initialize(value);
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> mutable()
        {
            return new MutableDoubleScalar.Abs<U>(this);
        }

        /** {@inheritDoc} */
        @Override
        public final DoubleScalar.Abs<U> immutable()
        {
            return new DoubleScalar.Abs<U>(this);
        }

        /** {@inheritDoc} */
        @Override
        public final int compareTo(final Abs<U> o)
        {
            return new Double(getSI()).compareTo(o.getSI());
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> copy()
        {
            return new MutableDoubleScalar.Abs<U>(this);
        }

        /**
         * Increment the value by the supplied value and return the result.
         * @param increment DoubleScalar.Rel&lt;U&gt;; amount by which the value is incremented
         * @return MutableDoubleScalar.Abs&lt;U&gt;
         */
        public final MutableDoubleScalar.Abs<U> incrementBy(final DoubleScalar.Rel<U> increment)
        {
            return (MutableDoubleScalar.Abs<U>) incrementByImpl(increment);
        }

        /**
         * Decrement the value by the supplied value and return the result.
         * @param decrement DoubleScalar.Rel&lt;U&gt;; amount by which the value is decremented
         * @return MutableDoubleScalar.Abs&lt;U&gt;
         */
        public final MutableDoubleScalar.Abs<U> decrementBy(final DoubleScalar.Rel<U> decrement)
        {
            return (MutableDoubleScalar.Abs<U>) decrementByImpl(decrement);
        }

        /**********************************************************************************/
        /********************************** MATH METHODS **********************************/
        /**********************************************************************************/

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> abs()
        {
            setValueSI(Math.abs(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> acos()
        {
            setValueSI(Math.acos(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> asin()
        {
            setValueSI(Math.asin(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> atan()
        {
            setValueSI(Math.atan(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> cbrt()
        {
            setValueSI(Math.cbrt(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> ceil()
        {
            setValueSI(Math.ceil(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> cos()
        {
            setValueSI(Math.cos(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> cosh()
        {
            setValueSI(Math.cosh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> exp()
        {
            setValueSI(Math.exp(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> expm1()
        {
            setValueSI(Math.expm1(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> floor()
        {
            setValueSI(Math.floor(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> log()
        {
            setValueSI(Math.log(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> log10()
        {
            setValueSI(Math.log10(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> log1p()
        {
            setValueSI(Math.log1p(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> pow(final double x)
        {
            setValueSI(Math.pow(getSI(), x));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> rint()
        {
            setValueSI(Math.rint(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> round()
        {
            setValueSI(Math.round(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> signum()
        {
            setValueSI(Math.signum(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> sin()
        {
            setValueSI(Math.sin(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> sinh()
        {
            setValueSI(Math.sinh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> sqrt()
        {
            setValueSI(Math.sqrt(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> tan()
        {
            setValueSI(Math.tan(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> tanh()
        {
            setValueSI(Math.tanh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> toDegrees()
        {
            setValueSI(Math.toDegrees(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> toRadians()
        {
            setValueSI(Math.toRadians(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Abs<U> inv()
        {
            setValueSI(1.0 / getSI());
            return this;
        }

    }

    /**
     * @param <U> Unit
     */
    public static class Rel<U extends Unit<U>> extends MutableDoubleScalar<U> implements Relative, Comparable<Rel<U>>
    {
        /**  */
        private static final long serialVersionUID = 20150309L;

        /**
         * Construct a new Relative MutableDoubleScalar.
         * @param value double; the value of the new Relative MutableDoubleScalar
         * @param unit U; the unit of the new Relative MutableDoubleScalar
         */
        public Rel(final double value, final U unit)
        {
            super(unit);
            // System.out.println("Created Rel");
            initialize(value);
        }

        /**
         * Construct a new Relative MutableDoubleScalar from an existing Relative Immutable DoubleScalar.
         * @param value DoubleScalar.Rel&lt;U&gt;; the reference
         */
        public Rel(final DoubleScalar.Rel<U> value)
        {
            super(value.getUnit());
            // System.out.println("Created Rel");
            initialize(value);
        }

        /**
         * Construct a new Relative MutableDoubleScalar from an existing Relative MutableDoubleScalar.
         * @param value MutableDoubleScalar.Rel&lt;U&gt;; the reference
         */
        public Rel(final MutableDoubleScalar.Rel<U> value)
        {
            super(value.getUnit());
            // System.out.println("Created Rel");
            initialize(value);
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> mutable()
        {
            return new MutableDoubleScalar.Rel<U>(this);
        }

        /** {@inheritDoc} */
        @Override
        public final DoubleScalar.Rel<U> immutable()
        {
            return new DoubleScalar.Rel<U>(this);
        }

        /** {@inheritDoc} */
        @Override
        public final int compareTo(final Rel<U> o)
        {
            return new Double(getSI()).compareTo(o.getSI());
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> copy()
        {
            return new MutableDoubleScalar.Rel<U>(this);
        }

        /**
         * Increment the value by the supplied value and return the result.
         * @param increment DoubleScalar.Rel&lt;U&gt;; amount by which the value is incremented
         * @return MutableDoubleScalar.Rel&lt;U&gt;
         */
        public final MutableDoubleScalar.Rel<U> incrementBy(final DoubleScalar.Rel<U> increment)
        {
            return (MutableDoubleScalar.Rel<U>) incrementByImpl(increment);
        }

        /**
         * Decrement the value by the supplied value and return the result.
         * @param decrement DoubleScalar.Rel&lt;U&gt;; amount by which the value is decremented
         * @return MutableDoubleScalar.Rel&lt;U&gt;
         */
        public final MutableDoubleScalar.Rel<U> decrementBy(final DoubleScalar.Rel<U> decrement)
        {
            return (MutableDoubleScalar.Rel<U>) decrementByImpl(decrement);
        }

        /**********************************************************************************/
        /********************************** MATH METHODS **********************************/
        /**********************************************************************************/

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> abs()
        {
            setValueSI(Math.abs(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> acos()
        {
            setValueSI(Math.acos(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> asin()
        {
            setValueSI(Math.asin(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> atan()
        {
            setValueSI(Math.atan(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> cbrt()
        {
            setValueSI(Math.cbrt(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> ceil()
        {
            setValueSI(Math.ceil(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> cos()
        {
            setValueSI(Math.cos(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> cosh()
        {
            setValueSI(Math.cosh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> exp()
        {
            setValueSI(Math.exp(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> expm1()
        {
            setValueSI(Math.expm1(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> floor()
        {
            setValueSI(Math.floor(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> log()
        {
            setValueSI(Math.log(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> log10()
        {
            setValueSI(Math.log10(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> log1p()
        {
            setValueSI(Math.log1p(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> pow(final double x)
        {
            setValueSI(Math.pow(getSI(), x));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> rint()
        {
            setValueSI(Math.rint(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> round()
        {
            setValueSI(Math.round(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> signum()
        {
            setValueSI(Math.signum(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> sin()
        {
            setValueSI(Math.sin(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> sinh()
        {
            setValueSI(Math.sinh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> sqrt()
        {
            setValueSI(Math.sqrt(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> tan()
        {
            setValueSI(Math.tan(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> tanh()
        {
            setValueSI(Math.tanh(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> toDegrees()
        {
            setValueSI(Math.toDegrees(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> toRadians()
        {
            setValueSI(Math.toRadians(getSI()));
            return this;
        }

        /** {@inheritDoc} */
        @Override
        public final MutableDoubleScalar.Rel<U> inv()
        {
            setValueSI(1.0 / getSI());
            return this;
        }

    }

    /**
     * Make (immutable) DoubleScalar equivalent for any type of MutableDoubleScalar. <br>
     * The immutable version is created as a deep copy of this. Delayed copying is not worthwhile for a Scalar.
     * @return DoubleScalar&lt;U&gt;; immutable version of this DoubleScalar
     */
    public abstract DoubleScalar<U> immutable();

    /**
     * Replace the stored value by the supplied value which is expressed in the standard SI unit.
     * @param valueSI double; the value to store (value must already be in the standard SI unit)
     */
    final void setSI(final double valueSI)
    {
        setValueSI(valueSI);
    }

    /**
     * Replace the stored value by the supplied value.
     * @param value DoubleScalar&lt;U&gt;; the strongly typed value to store
     */
    final void set(final DoubleScalar<U> value)
    {
        setValueSI(value.getSI());
    }

    /**
     * Replace the stored value by the supplied value which can be expressed in any compatible unit.
     * @param value double; the value to store
     * @param valueUnit U; the unit of the supplied value
     */
    final void setInUnit(final double value, final U valueUnit)
    {
        setValueSI(ValueUtil.expressAsSIUnit(value, valueUnit));
    }

    /** {@inheritDoc} */
    @Override
    public final MutableDoubleScalar<U> multiply(final double constant)
    {
        setValueSI(getSI() * constant);
        return this;
    }

    /** {@inheritDoc} */
    @Override
    public final MutableDoubleScalar<U> divide(final double constant)
    {
        setValueSI(getSI() / constant);
        return this;
    }

    /**********************************************************************************/
    /******************************* NON-STATIC METHODS *******************************/
    /**********************************************************************************/

    /**
     * Increment the value in this MutableDoubleScalar by the value in a DoubleScalar.
     * @param increment DoubleScalar&lt;U&gt;; the amount by which to increment the value in this MutableDoubleScalar
     * @return MutableDoubleScalar&lt;U&gt;; this modified MutableDoubleScalar
     */
    protected final MutableDoubleScalar<U> incrementBy(final DoubleScalar<U> increment)
    {
        setValueSI(getSI() + increment.getSI());
        return this;
    }

    /**
     * Decrement the value in this MutableDoubleScalar by the value in a DoubleScalar.
     * @param decrement DoubleScalar&lt;U&gt;; the amount by which to decrement the value in this MutableDoubleScalar
     * @return MutableDoubleScalar&lt;U&gt;; this modified MutableDoubleScalar
     */
    protected final MutableDoubleScalar<U> decrementBy(final DoubleScalar<U> decrement)
    {
        setValueSI(getSI() - decrement.getSI());
        return this;
    }

    /**
     * Increment the value in this MutableDoubleScalar by the value in a Relative DoubleScalar. <br>
     * Only Relative values are allowed; adding an Absolute value to an Absolute value is not allowed. Adding an
     * Absolute value to an existing Relative value would require the result to become Absolute, which is a type change
     * that is impossible. For that operation use a static method.
     * @param rel DoubleScalar.Rel&lt;U&gt;; the Relative DoubleScalar
     * @return MutableDoubleScalar&lt;U&gt;; this modified MutableDoubleScalar
     */
    protected final MutableDoubleScalar<U> incrementByImpl(final DoubleScalar.Rel<U> rel)
    {
        setValueSI(getSI() + rel.getSI());
        return this;
    }

    /**
     * Decrement the value of this Relative DoubleScalar from the value of this MutableDoubleScalar. <br>
     * Only Relative values are allowed; subtracting an Absolute value from a Relative value is not allowed. Subtracting
     * an Absolute value from an existing Absolute value would require the result to become Relative, which is a type
     * change that is impossible. For that operation use a static method.
     * @param rel DoubleScalar.Rel&lt;U&gt;; the Relative DoubleScalar
     * @return MutableDoubleScalar&lt;U&gt;; this modified MutableDoubleScalar
     */
    protected final MutableDoubleScalar<U> decrementByImpl(final DoubleScalar.Rel<U> rel)
    {
        setValueSI(getSI() - rel.getSI());
        return this;
    }

}