    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.math3.util;
    018
    019    import org.apache.commons.math3.Field;
    020    import org.apache.commons.math3.FieldElement;
    021
    022    /**
    023     * This class wraps a {@code double} value in an object. It is similar to the
    024     * standard class {@link Double}, while also implementing the
    025     * {@link FieldElement} interface.
    026     *
    027     * @since 3.1
    028     * @version $Id: Decimal64.java 1306177 2012-03-28 05:40:46Z celestin $
    029     */
    030    public class Decimal64 extends Number implements FieldElement<Decimal64>,
    031    Comparable<Decimal64> {
    032
    033        /** The constant value of {@code 0d} as a {@code Decimal64}. */
    034        public static final Decimal64 ZERO;
    035
    036        /** The constant value of {@code 1d} as a {@code Decimal64}. */
    037        public static final Decimal64 ONE;
    038
    039        /**
    040         * The constant value of {@link Double#NEGATIVE_INFINITY} as a
    041         * {@code Decimal64}.
    042         */
    043        public static final Decimal64 NEGATIVE_INFINITY;
    044
    045        /**
    046         * The constant value of {@link Double#POSITIVE_INFINITY} as a
    047         * {@code Decimal64}.
    048         */
    049        public static final Decimal64 POSITIVE_INFINITY;
    050
    051        /** The constant value of {@link Double#NaN} as a {@code Decimal64}. */
    052        public static final Decimal64 NAN;
    053
    054        /** */
    055        private static final long serialVersionUID = 20120227L;
    056
    057        static {
    058            ZERO = new Decimal64(0d);
    059            ONE = new Decimal64(1d);
    060            NEGATIVE_INFINITY = new Decimal64(Double.NEGATIVE_INFINITY);
    061            POSITIVE_INFINITY = new Decimal64(Double.POSITIVE_INFINITY);
    062            NAN = new Decimal64(Double.NaN);
    063        }
    064
    065        /** The primitive {@code double} value of this object. */
    066        private final double value;
    067
    068        /**
    069         * Creates a new instance of this class.
    070         *
    071         * @param x the primitive {@code double} value of the object to be created
    072         */
    073        public Decimal64(final double x) {
    074            this.value = x;
    075        }
    076
    077        /*
    078         * Methods from the FieldElement interface.
    079         */
    080
    081        /** {@inheritDoc} */
    082        public Field<Decimal64> getField() {
    083            return Decimal64Field.getInstance();
    084        }
    085
    086        /**
    087         * {@inheritDoc}
    088         *
    089         * The current implementation strictly enforces
    090         * {@code this.add(a).equals(new Decimal64(this.doubleValue()
    091         * + a.doubleValue()))}.
    092         */
    093        public Decimal64 add(final Decimal64 a) {
    094            return new Decimal64(this.value + a.value);
    095        }
    096
    097        /**
    098         * {@inheritDoc}
    099         *
    100         * The current implementation strictly enforces
    101         * {@code this.subtract(a).equals(new Decimal64(this.doubleValue()
    102         * - a.doubleValue()))}.
    103         */
    104        public Decimal64 subtract(final Decimal64 a) {
    105            return new Decimal64(this.value - a.value);
    106        }
    107
    108        /**
    109         * {@inheritDoc}
    110         *
    111         * The current implementation strictly enforces
    112         * {@code this.negate().equals(new Decimal64(-this.doubleValue()))}.
    113         */
    114        public Decimal64 negate() {
    115            return new Decimal64(-this.value);
    116        }
    117
    118        /**
    119         * {@inheritDoc}
    120         *
    121         * The current implementation strictly enforces
    122         * {@code this.multiply(a).equals(new Decimal64(this.doubleValue()
    123         * * a.doubleValue()))}.
    124         */
    125        public Decimal64 multiply(final Decimal64 a) {
    126            return new Decimal64(this.value * a.value);
    127        }
    128
    129        /**
    130         * {@inheritDoc}
    131         *
    132         * The current implementation strictly enforces
    133         * {@code this.multiply(n).equals(new Decimal64(n * this.doubleValue()))}.
    134         */
    135        public Decimal64 multiply(final int n) {
    136            return new Decimal64(n * this.value);
    137        }
    138
    139        /**
    140         * {@inheritDoc}
    141         *
    142         * The current implementation strictly enforces
    143         * {@code this.divide(a).equals(new Decimal64(this.doubleValue()
    144         * / a.doubleValue()))}.
    145         *
    146         */
    147        public Decimal64 divide(final Decimal64 a) {
    148            return new Decimal64(this.value / a.value);
    149        }
    150
    151        /**
    152         * {@inheritDoc}
    153         *
    154         * The current implementation strictly enforces
    155         * {@code this.reciprocal().equals(new Decimal64(1.0
    156         * / this.doubleValue()))}.
    157         */
    158        public Decimal64 reciprocal() {
    159            return new Decimal64(1.0 / this.value);
    160        }
    161
    162        /*
    163         * Methods from the Number abstract class
    164         */
    165
    166        /**
    167         * {@inheritDoc}
    168         *
    169         * The current implementation performs casting to a {@code byte}.
    170         */
    171        @Override
    172        public byte byteValue() {
    173            return (byte) value;
    174        }
    175
    176        /**
    177         * {@inheritDoc}
    178         *
    179         * The current implementation performs casting to a {@code short}.
    180         */
    181        @Override
    182        public short shortValue() {
    183            return (short) value;
    184        }
    185
    186        /**
    187         * {@inheritDoc}
    188         *
    189         * The current implementation performs casting to a {@code int}.
    190         */
    191        @Override
    192        public int intValue() {
    193            return (int) value;
    194        }
    195
    196        /**
    197         * {@inheritDoc}
    198         *
    199         * The current implementation performs casting to a {@code long}.
    200         */
    201        @Override
    202        public long longValue() {
    203            return (long) value;
    204        }
    205
    206        /**
    207         * {@inheritDoc}
    208         *
    209         * The current implementation performs casting to a {@code float}.
    210         */
    211        @Override
    212        public float floatValue() {
    213            return (float) value;
    214        }
    215
    216        /** {@inheritDoc} */
    217        @Override
    218        public double doubleValue() {
    219            return value;
    220        }
    221
    222        /*
    223         * Methods from the Comparable interface.
    224         */
    225
    226        /**
    227         * {@inheritDoc}
    228         *
    229         * The current implementation returns the same value as
    230         * <center> {@code new Double(this.doubleValue()).compareTo(new
    231         * Double(o.doubleValue()))} </center>
    232         *
    233         * @see Double#compareTo(Double)
    234         */
    235        public int compareTo(final Decimal64 o) {
    236            return Double.compare(this.value, o.value);
    237        }
    238
    239        /*
    240         * Methods from the Object abstract class.
    241         */
    242
    243        /** {@inheritDoc} */
    244        @Override
    245        public boolean equals(final Object obj) {
    246            if (obj instanceof Decimal64) {
    247                final Decimal64 that = (Decimal64) obj;
    248                return Double.doubleToLongBits(this.value) == Double
    249                        .doubleToLongBits(that.value);
    250            }
    251            return false;
    252        }
    253
    254        /**
    255         * {@inheritDoc}
    256         *
    257         * The current implementation returns the same value as
    258         * {@code new Double(this.doubleValue()).hashCode()}
    259         *
    260         * @see Double#hashCode()
    261         */
    262        @Override
    263        public int hashCode() {
    264            long v = Double.doubleToLongBits(value);
    265            return (int) (v ^ (v >>> 32));
    266        }
    267
    268        /**
    269         * {@inheritDoc}
    270         *
    271         * The returned {@code String} is equal to
    272         * {@code Double.toString(this.doubleValue())}
    273         *
    274         * @see Double#toString(double)
    275         */
    276        @Override
    277        public String toString() {
    278            return Double.toString(value);
    279        }
    280
    281        /*
    282         * Methods inspired by the Double class.
    283         */
    284
    285        /**
    286         * Returns {@code true} if {@code this} double precision number is infinite
    287         * ({@link Double#POSITIVE_INFINITY} or {@link Double#NEGATIVE_INFINITY}).
    288         *
    289         * @return {@code true} if {@code this} number is infinite
    290         */
    291        public boolean isInfinite() {
    292            return Double.isInfinite(value);
    293        }
    294
    295        /**
    296         * Returns {@code true} if {@code this} double precision number is
    297         * Not-a-Number ({@code NaN}), false otherwise.
    298         *
    299         * @return {@code true} if {@code this} is {@code NaN}
    300         */
    301        public boolean isNaN() {
    302            return Double.isNaN(value);
    303        }
    304    }