commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From celes...@apache.org
Subject svn commit: r1306177 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math3/util/Decimal64.java main/java/org/apache/commons/math3/util/Decimal64Field.java test/java/org/apache/commons/math3/util/Decimal64Test.java
Date Wed, 28 Mar 2012 05:40:47 GMT
Author: celestin
Date: Wed Mar 28 05:40:46 2012
New Revision: 1306177

URL: http://svn.apache.org/viewvc?rev=1306177&view=rev
Log:
Created Decimal64, a wrapper class around the primitive double type.
This class implements FieldElement<Decimal64>.
See MATH-756.

Added:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java 
 (with props)
    commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
  (with props)
    commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
  (with props)

Added: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java?rev=1306177&view=auto
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java (added)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java Wed
Mar 28 05:40:46 2012
@@ -0,0 +1,304 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.util;
+
+import org.apache.commons.math3.Field;
+import org.apache.commons.math3.FieldElement;
+
+/**
+ * This class wraps a {@code double} value in an object. It is similar to the
+ * standard class {@link Double}, while also implementing the
+ * {@link FieldElement} interface.
+ *
+ * @since 3.1
+ * @version $Id$
+ */
+public class Decimal64 extends Number implements FieldElement<Decimal64>,
+Comparable<Decimal64> {
+
+    /** The constant value of {@code 0d} as a {@code Decimal64}. */
+    public static final Decimal64 ZERO;
+
+    /** The constant value of {@code 1d} as a {@code Decimal64}. */
+    public static final Decimal64 ONE;
+
+    /**
+     * The constant value of {@link Double#NEGATIVE_INFINITY} as a
+     * {@code Decimal64}.
+     */
+    public static final Decimal64 NEGATIVE_INFINITY;
+
+    /**
+     * The constant value of {@link Double#POSITIVE_INFINITY} as a
+     * {@code Decimal64}.
+     */
+    public static final Decimal64 POSITIVE_INFINITY;
+
+    /** The constant value of {@link Double#NaN} as a {@code Decimal64}. */
+    public static final Decimal64 NAN;
+
+    /** */
+    private static final long serialVersionUID = 20120227L;
+
+    static {
+        ZERO = new Decimal64(0d);
+        ONE = new Decimal64(1d);
+        NEGATIVE_INFINITY = new Decimal64(Double.NEGATIVE_INFINITY);
+        POSITIVE_INFINITY = new Decimal64(Double.POSITIVE_INFINITY);
+        NAN = new Decimal64(Double.NaN);
+    }
+
+    /** The primitive {@code double} value of this object. */
+    private final double value;
+
+    /**
+     * Creates a new instance of this class.
+     *
+     * @param x the primitive {@code double} value of the object to be created
+     */
+    public Decimal64(final double x) {
+        this.value = x;
+    }
+
+    /*
+     * Methods from the FieldElement interface.
+     */
+
+    /** {@inheritDoc} */
+    public Field<Decimal64> getField() {
+        return Decimal64Field.getInstance();
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.add(a).equals(new Decimal64(this.doubleValue()
+     * + a.doubleValue()))}.
+     */
+    public Decimal64 add(final Decimal64 a) {
+        return new Decimal64(this.value + a.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.subtract(a).equals(new Decimal64(this.doubleValue()
+     * - a.doubleValue()))}.
+     */
+    public Decimal64 subtract(final Decimal64 a) {
+        return new Decimal64(this.value - a.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.negate().equals(new Decimal64(-this.doubleValue()))}.
+     */
+    public Decimal64 negate() {
+        return new Decimal64(-this.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.multiply(a).equals(new Decimal64(this.doubleValue()
+     * * a.doubleValue()))}.
+     */
+    public Decimal64 multiply(final Decimal64 a) {
+        return new Decimal64(this.value * a.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.multiply(n).equals(new Decimal64(n * this.doubleValue()))}.
+     */
+    public Decimal64 multiply(final int n) {
+        return new Decimal64(n * this.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.divide(a).equals(new Decimal64(this.doubleValue()
+     * / a.doubleValue()))}.
+     *
+     */
+    public Decimal64 divide(final Decimal64 a) {
+        return new Decimal64(this.value / a.value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation strictly enforces
+     * {@code this.reciprocal().equals(new Decimal64(1.0
+     * / this.doubleValue()))}.
+     */
+    public Decimal64 reciprocal() {
+        return new Decimal64(1.0 / this.value);
+    }
+
+    /*
+     * Methods from the Number abstract class
+     */
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation performs casting to a {@code byte}.
+     */
+    @Override
+    public byte byteValue() {
+        return (byte) value;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation performs casting to a {@code short}.
+     */
+    @Override
+    public short shortValue() {
+        return (short) value;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation performs casting to a {@code int}.
+     */
+    @Override
+    public int intValue() {
+        return (int) value;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation performs casting to a {@code long}.
+     */
+    @Override
+    public long longValue() {
+        return (long) value;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation performs casting to a {@code float}.
+     */
+    @Override
+    public float floatValue() {
+        return (float) value;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public double doubleValue() {
+        return value;
+    }
+
+    /*
+     * Methods from the Comparable interface.
+     */
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation returns the same value as
+     * <center> {@code new Double(this.doubleValue()).compareTo(new
+     * Double(o.doubleValue()))} </center>
+     *
+     * @see Double#compareTo(Double)
+     */
+    public int compareTo(final Decimal64 o) {
+        return Double.compare(this.value, o.value);
+    }
+
+    /*
+     * Methods from the Object abstract class.
+     */
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean equals(final Object obj) {
+        if (obj instanceof Decimal64) {
+            final Decimal64 that = (Decimal64) obj;
+            return Double.doubleToLongBits(this.value) == Double
+                    .doubleToLongBits(that.value);
+        }
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The current implementation returns the same value as
+     * {@code new Double(this.doubleValue()).hashCode()}
+     *
+     * @see Double#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        long v = Double.doubleToLongBits(value);
+        return (int) (v ^ (v >>> 32));
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * The returned {@code String} is equal to
+     * {@code Double.toString(this.doubleValue())}
+     *
+     * @see Double#toString(double)
+     */
+    @Override
+    public String toString() {
+        return Double.toString(value);
+    }
+
+    /*
+     * Methods inspired by the Double class.
+     */
+
+    /**
+     * Returns {@code true} if {@code this} double precision number is infinite
+     * ({@link Double#POSITIVE_INFINITY} or {@link Double#NEGATIVE_INFINITY}).
+     *
+     * @return {@code true} if {@code this} number is infinite
+     */
+    public boolean isInfinite() {
+        return Double.isInfinite(value);
+    }
+
+    /**
+     * Returns {@code true} if {@code this} double precision number is
+     * Not-a-Number ({@code NaN}), false otherwise.
+     *
+     * @return {@code true} if {@code this} is {@code NaN}
+     */
+    public boolean isNaN() {
+        return Double.isNaN(value);
+    }
+}

Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java
------------------------------------------------------------------------------
    svn:keywords = Id Revision

Added: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java?rev=1306177&view=auto
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
(added)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
Wed Mar 28 05:40:46 2012
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.util;
+
+import org.apache.commons.math3.Field;
+import org.apache.commons.math3.FieldElement;
+
+/**
+ * The field of double precision floating-point numbers.
+ *
+ * @since 3.1
+ * @version $Id$
+ * @see Decimal64
+ */
+public class Decimal64Field implements Field<Decimal64> {
+
+    /** The unique instance of this class. */
+    private static final Decimal64Field INSTANCE = new Decimal64Field();
+
+    /** Default constructor. */
+    private Decimal64Field() {
+        // Do nothing
+    }
+
+    /**
+     * Returns the unique instance of this class.
+     *
+     * @return the unique instance of this class
+     */
+    public static final Decimal64Field getInstance() {
+        return INSTANCE;
+    }
+
+    /** {@inheritDoc} */
+    public Decimal64 getZero() {
+        return Decimal64.ZERO;
+    }
+
+    /** {@inheritDoc} */
+    public Decimal64 getOne() {
+        return Decimal64.ONE;
+    }
+
+    /** {@inheritDoc} */
+    public Class<? extends FieldElement<Decimal64>> getRuntimeClass() {
+        return Decimal64.class;
+    }
+}

Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64Field.java
------------------------------------------------------------------------------
    svn:keywords = Id Revision

Added: commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java?rev=1306177&view=auto
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
(added)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
Wed Mar 28 05:40:46 2012
@@ -0,0 +1,421 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.util;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+public class Decimal64Test {
+    public static final double X = 1.2345;
+
+    public static final Decimal64 PLUS_X = new Decimal64(X);
+
+    public static final Decimal64 MINUS_X = new Decimal64(-X);
+
+    public static final double Y = 6.789;
+
+    public static final Decimal64 PLUS_Y = new Decimal64(Y);
+
+    public static final Decimal64 MINUS_Y = new Decimal64(-Y);
+
+    public static final Decimal64 PLUS_ZERO = new Decimal64(0.0);
+
+    public static final Decimal64 MINUS_ZERO = new Decimal64(-0.0);
+
+    @Test
+    public void testAdd() {
+        Decimal64 expected, actual;
+
+        expected = new Decimal64(X + Y);
+        actual = PLUS_X.add(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_Y.add(PLUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64(X + (-Y));
+        actual = PLUS_X.add(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_Y.add(PLUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) + (-Y));
+        actual = MINUS_X.add(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_Y.add(MINUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.POSITIVE_INFINITY;
+        actual = PLUS_X.add(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.add(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.add(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.add(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NEGATIVE_INFINITY;
+        actual = PLUS_X.add(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.add(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.add(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.add(MINUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NAN;
+        actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.add(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.add(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.add(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.add(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.add(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.add(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.add(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.add(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.add(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testSubtract() {
+        Decimal64 expected, actual;
+
+        expected = new Decimal64(X - Y);
+        actual = PLUS_X.subtract(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64(X - (-Y));
+        actual = PLUS_X.subtract(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) - Y);
+        actual = MINUS_X.subtract(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) - (-Y));
+        actual = MINUS_X.subtract(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NEGATIVE_INFINITY;
+        actual = PLUS_X.subtract(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.subtract(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .subtract(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.POSITIVE_INFINITY;
+        actual = PLUS_X.subtract(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.subtract(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY
+                .subtract(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NAN;
+        actual = Decimal64.POSITIVE_INFINITY
+                .subtract(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .subtract(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.subtract(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.subtract(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.subtract(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.subtract(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.subtract(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.subtract(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.subtract(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.subtract(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.subtract(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testNegate() {
+        Decimal64 expected, actual;
+
+        expected = MINUS_X;
+        actual = PLUS_X.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = PLUS_X;
+        actual = MINUS_X.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = MINUS_ZERO;
+        actual = PLUS_ZERO.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = PLUS_ZERO;
+        actual = MINUS_ZERO.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.POSITIVE_INFINITY;
+        actual = Decimal64.NEGATIVE_INFINITY.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NEGATIVE_INFINITY;
+        actual = Decimal64.POSITIVE_INFINITY.negate();
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NAN;
+        actual = Decimal64.NAN.negate();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testMultiply() {
+        Decimal64 expected, actual;
+
+        expected = new Decimal64(X * Y);
+        actual = PLUS_X.multiply(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_Y.multiply(PLUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64(X * (-Y));
+        actual = PLUS_X.multiply(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_Y.multiply(PLUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) * (-Y));
+        actual = MINUS_X.multiply(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_Y.multiply(MINUS_X);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.POSITIVE_INFINITY;
+        actual = PLUS_X.multiply(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.multiply(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.multiply(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.multiply(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY
+                .multiply(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .multiply(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NEGATIVE_INFINITY;
+        actual = PLUS_X.multiply(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.multiply(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.multiply(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.multiply(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY
+                .multiply(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .multiply(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NAN;
+        actual = PLUS_X.multiply(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.multiply(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.multiply(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.multiply(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.multiply(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.multiply(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.multiply(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.multiply(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.multiply(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testDivide() {
+        Decimal64 expected, actual;
+
+        expected = new Decimal64(X / Y);
+        actual = PLUS_X.divide(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64(X / (-Y));
+        actual = PLUS_X.divide(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) / Y);
+        actual = MINUS_X.divide(PLUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64((-X) / (-Y));
+        actual = MINUS_X.divide(MINUS_Y);
+        Assert.assertEquals(expected, actual);
+
+        expected = PLUS_ZERO;
+        actual = PLUS_X.divide(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.divide(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = MINUS_ZERO;
+        actual = MINUS_X.divide(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.divide(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.POSITIVE_INFINITY;
+        actual = Decimal64.POSITIVE_INFINITY.divide(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.divide(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.divide(PLUS_ZERO);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.divide(MINUS_ZERO);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NEGATIVE_INFINITY;
+        actual = Decimal64.POSITIVE_INFINITY.divide(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.divide(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.divide(MINUS_ZERO);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.divide(PLUS_ZERO);
+        Assert.assertEquals(expected, actual);
+
+        expected = Decimal64.NAN;
+        actual = Decimal64.POSITIVE_INFINITY
+                .divide(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY
+                .divide(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .divide(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY
+                .divide(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_X.divide(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.divide(PLUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_X.divide(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.divide(MINUS_X);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.POSITIVE_INFINITY.divide(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.divide(Decimal64.POSITIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NEGATIVE_INFINITY.divide(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.divide(Decimal64.NEGATIVE_INFINITY);
+        Assert.assertEquals(expected, actual);
+        actual = Decimal64.NAN.divide(Decimal64.NAN);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_ZERO.divide(PLUS_ZERO);
+        Assert.assertEquals(expected, actual);
+        actual = PLUS_ZERO.divide(MINUS_ZERO);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_ZERO.divide(PLUS_ZERO);
+        Assert.assertEquals(expected, actual);
+        actual = MINUS_ZERO.divide(MINUS_ZERO);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testReciprocal() {
+        Decimal64 expected, actual;
+
+        expected = new Decimal64(1.0 / X);
+        actual = PLUS_X.reciprocal();
+        Assert.assertEquals(expected, actual);
+
+        expected = new Decimal64(1.0 / (-X));
+        actual = MINUS_X.reciprocal();
+        Assert.assertEquals(expected, actual);
+
+        expected = PLUS_ZERO;
+        actual = Decimal64.POSITIVE_INFINITY.reciprocal();
+        Assert.assertEquals(expected, actual);
+
+        expected = MINUS_ZERO;
+        actual = Decimal64.NEGATIVE_INFINITY.reciprocal();
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testIsInfinite() {
+        Assert.assertFalse(MINUS_X.isInfinite());
+        Assert.assertFalse(PLUS_X.isInfinite());
+        Assert.assertFalse(MINUS_Y.isInfinite());
+        Assert.assertFalse(PLUS_Y.isInfinite());
+        Assert.assertFalse(Decimal64.NAN.isInfinite());
+
+        Assert.assertTrue(Decimal64.NEGATIVE_INFINITY.isInfinite());
+        Assert.assertTrue(Decimal64.POSITIVE_INFINITY.isInfinite());
+    }
+
+    @Test
+    public void testIsNaN() {
+        Assert.assertFalse(MINUS_X.isNaN());
+        Assert.assertFalse(PLUS_X.isNaN());
+        Assert.assertFalse(MINUS_Y.isNaN());
+        Assert.assertFalse(PLUS_Y.isNaN());
+        Assert.assertFalse(Decimal64.NEGATIVE_INFINITY.isNaN());
+        Assert.assertFalse(Decimal64.POSITIVE_INFINITY.isNaN());
+
+        Assert.assertTrue(Decimal64.NAN.isNaN());
+    }
+}

Propchange: commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: commons/proper/math/trunk/src/test/java/org/apache/commons/math3/util/Decimal64Test.java
------------------------------------------------------------------------------
    svn:keywords = Id Revision



Mime
View raw message