mirror of
https://github.com/apache/commons-math.git
synced 2025-02-09 11:35:33 +00:00
Created Decimal64, a wrapper class around the primitive double type.
This class implements FieldElement<Decimal64>. See MATH-756. git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1306177 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Sebastien Brisard
parent
731daf82cf
commit
923800c071
304
src/main/java/org/apache/commons/math3/util/Decimal64.java
Normal file
304
src/main/java/org/apache/commons/math3/util/Decimal64.java
Normal file
@ -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);
|
||||
}
|
||||
}
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
421
src/test/java/org/apache/commons/math3/util/Decimal64Test.java
Normal file
421
src/test/java/org/apache/commons/math3/util/Decimal64Test.java
Normal file
@ -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());
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user