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
