MATH-1504: Removed "BigFraction" class (ported to "Commons Numbers").
Functionality unused within "Commons Math" was also removed: * Utility to build "FieldMatrix<BigFraction>" instances. * Utility to convert from "FieldMatrix<BigFraction>" to "RealMatrix". Class "BigFraction" was used for testing "Field" functionalities. Corresponding unit tests were refactored to use class "Dfp" instead.
This commit is contained in:
Gilles Sadowski
parent
b8d96de587
commit
cf2b9e7479
|
|
@ -54,6 +54,9 @@ If the output is not quite correct, check for invisible trailing spaces!
|
|||
</release>
|
||||
|
||||
<release version="4.0" date="XXXX-XX-XX" description="">
|
||||
<action dev="erans" type="update" issue="MATH-1504">
|
||||
Removed class "BigFraction" (ported to "Commons Numbers").
|
||||
</action>
|
||||
<action dev="erans" type="update" issue="MATH-1446">
|
||||
Removed class "Fraction" (ported to "Commons Numbers").
|
||||
</action>
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,85 +0,0 @@
|
|||
/*
|
||||
* 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.math4.fraction;
|
||||
|
||||
import java.io.Serializable;
|
||||
|
||||
import org.apache.commons.math4.Field;
|
||||
import org.apache.commons.math4.FieldElement;
|
||||
|
||||
/**
|
||||
* Representation of the fractional numbers without any overflow field.
|
||||
* <p>
|
||||
* This class is a singleton.
|
||||
* </p>
|
||||
* @see Fraction
|
||||
* @since 2.0
|
||||
*/
|
||||
public class BigFractionField implements Field<BigFraction>, Serializable {
|
||||
|
||||
/** Serializable version identifier */
|
||||
private static final long serialVersionUID = -1699294557189741703L;
|
||||
|
||||
/** Private constructor for the singleton.
|
||||
*/
|
||||
private BigFractionField() {
|
||||
}
|
||||
|
||||
/** Get the unique instance.
|
||||
* @return the unique instance
|
||||
*/
|
||||
public static BigFractionField getInstance() {
|
||||
return LazyHolder.INSTANCE;
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public BigFraction getOne() {
|
||||
return BigFraction.ONE;
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public BigFraction getZero() {
|
||||
return BigFraction.ZERO;
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public Class<? extends FieldElement<BigFraction>> getRuntimeClass() {
|
||||
return BigFraction.class;
|
||||
}
|
||||
// CHECKSTYLE: stop HideUtilityClassConstructor
|
||||
/** Holder for the instance.
|
||||
* <p>We use here the Initialization On Demand Holder Idiom.</p>
|
||||
*/
|
||||
private static class LazyHolder {
|
||||
/** Cached field instance. */
|
||||
private static final BigFractionField INSTANCE = new BigFractionField();
|
||||
}
|
||||
// CHECKSTYLE: resume HideUtilityClassConstructor
|
||||
|
||||
/** Handle deserialization of the singleton.
|
||||
* @return the singleton instance
|
||||
*/
|
||||
private Object readResolve() {
|
||||
// return the singleton instance
|
||||
return LazyHolder.INSTANCE;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -32,7 +32,6 @@ import org.apache.commons.math4.exception.NumberIsTooSmallException;
|
|||
import org.apache.commons.math4.exception.OutOfRangeException;
|
||||
import org.apache.commons.math4.exception.ZeroException;
|
||||
import org.apache.commons.math4.exception.util.LocalizedFormats;
|
||||
import org.apache.commons.math4.fraction.BigFraction;
|
||||
import org.apache.commons.math4.util.FastMath;
|
||||
import org.apache.commons.math4.util.MathArrays;
|
||||
import org.apache.commons.math4.util.MathUtils;
|
||||
|
|
@ -607,50 +606,6 @@ public class MatrixUtils {
|
|||
left.checkMultiply(right);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a {@link FieldMatrix}/{@link BigFraction} matrix to a {@link RealMatrix}.
|
||||
*
|
||||
* @param m Matrix to convert.
|
||||
* @return the converted matrix.
|
||||
*/
|
||||
public static Array2DRowRealMatrix bigFractionMatrixToRealMatrix(final FieldMatrix<BigFraction> m) {
|
||||
final BigFractionMatrixConverter converter = new BigFractionMatrixConverter();
|
||||
m.walkInOptimizedOrder(converter);
|
||||
return converter.getConvertedMatrix();
|
||||
}
|
||||
|
||||
/** Converter for {@link FieldMatrix}/{@link BigFraction}. */
|
||||
private static class BigFractionMatrixConverter extends DefaultFieldMatrixPreservingVisitor<BigFraction> {
|
||||
/** Converted array. */
|
||||
private double[][] data;
|
||||
/** Simple constructor. */
|
||||
BigFractionMatrixConverter() {
|
||||
super(BigFraction.ZERO);
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public void start(int rows, int columns,
|
||||
int startRow, int endRow, int startColumn, int endColumn) {
|
||||
data = new double[rows][columns];
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public void visit(int row, int column, BigFraction value) {
|
||||
data[row][column] = value.doubleValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the converted matrix.
|
||||
*
|
||||
* @return the converted matrix.
|
||||
*/
|
||||
Array2DRowRealMatrix getConvertedMatrix() {
|
||||
return new Array2DRowRealMatrix(data, false);
|
||||
}
|
||||
}
|
||||
|
||||
/** Serialize a {@link RealVector}.
|
||||
* <p>
|
||||
* This method is intended to be called from within a private
|
||||
|
|
|
|||
|
|
@ -22,9 +22,9 @@ import org.apache.commons.math4.analysis.interpolation.FieldHermiteInterpolator;
|
|||
import org.apache.commons.math4.analysis.polynomials.PolynomialFunction;
|
||||
import org.apache.commons.math4.dfp.Dfp;
|
||||
import org.apache.commons.math4.dfp.DfpField;
|
||||
import org.apache.commons.math4.linear.Dfp25;
|
||||
import org.apache.commons.math4.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math4.exception.NoDataException;
|
||||
import org.apache.commons.math4.fraction.BigFraction;
|
||||
import org.apache.commons.math4.util.FastMath;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
|
@ -33,61 +33,61 @@ public class FieldHermiteInterpolatorTest {
|
|||
|
||||
@Test
|
||||
public void testZero() {
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(0), new BigFraction[] { new BigFraction(0) });
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(0), new Dfp[] { Dfp25.of(0) });
|
||||
for (int x = -10; x < 10; x++) {
|
||||
BigFraction y = interpolator.value(new BigFraction(x))[0];
|
||||
Assert.assertEquals(BigFraction.ZERO, y);
|
||||
BigFraction[][] derivatives = interpolator.derivatives(new BigFraction(x), 1);
|
||||
Assert.assertEquals(BigFraction.ZERO, derivatives[0][0]);
|
||||
Assert.assertEquals(BigFraction.ZERO, derivatives[1][0]);
|
||||
Dfp y = interpolator.value(Dfp25.of(x))[0];
|
||||
Assert.assertEquals(Dfp25.ZERO, y);
|
||||
Dfp[][] derivatives = interpolator.derivatives(Dfp25.of(x), 1);
|
||||
Assert.assertEquals(Dfp25.ZERO, derivatives[0][0]);
|
||||
Assert.assertEquals(Dfp25.ZERO, derivatives[1][0]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testQuadratic() {
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(0), new BigFraction[] { new BigFraction(2) });
|
||||
interpolator.addSamplePoint(new BigFraction(1), new BigFraction[] { new BigFraction(0) });
|
||||
interpolator.addSamplePoint(new BigFraction(2), new BigFraction[] { new BigFraction(0) });
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(0), new Dfp[] { Dfp25.of(2) });
|
||||
interpolator.addSamplePoint(Dfp25.of(1), new Dfp[] { Dfp25.of(0) });
|
||||
interpolator.addSamplePoint(Dfp25.of(2), new Dfp[] { Dfp25.of(0) });
|
||||
for (double x = -10; x < 10; x += 1.0) {
|
||||
BigFraction y = interpolator.value(new BigFraction(x))[0];
|
||||
Assert.assertEquals((x - 1) * (x - 2), y.doubleValue(), 1.0e-15);
|
||||
BigFraction[][] derivatives = interpolator.derivatives(new BigFraction(x), 3);
|
||||
Assert.assertEquals((x - 1) * (x - 2), derivatives[0][0].doubleValue(), 1.0e-15);
|
||||
Assert.assertEquals(2 * x - 3, derivatives[1][0].doubleValue(), 1.0e-15);
|
||||
Assert.assertEquals(2, derivatives[2][0].doubleValue(), 1.0e-15);
|
||||
Assert.assertEquals(0, derivatives[3][0].doubleValue(), 1.0e-15);
|
||||
Dfp y = interpolator.value(Dfp25.of(x))[0];
|
||||
Assert.assertEquals((x - 1) * (x - 2), y.toDouble(), 1.0e-15);
|
||||
Dfp[][] derivatives = interpolator.derivatives(Dfp25.of(x), 3);
|
||||
Assert.assertEquals((x - 1) * (x - 2), derivatives[0][0].toDouble(), 1.0e-15);
|
||||
Assert.assertEquals(2 * x - 3, derivatives[1][0].toDouble(), 1.0e-15);
|
||||
Assert.assertEquals(2, derivatives[2][0].toDouble(), 1.0e-15);
|
||||
Assert.assertEquals(0, derivatives[3][0].toDouble(), 1.0e-15);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMixedDerivatives() {
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(0), new BigFraction[] { new BigFraction(1) }, new BigFraction[] { new BigFraction(2) });
|
||||
interpolator.addSamplePoint(new BigFraction(1), new BigFraction[] { new BigFraction(4) });
|
||||
interpolator.addSamplePoint(new BigFraction(2), new BigFraction[] { new BigFraction(5) }, new BigFraction[] { new BigFraction(2) });
|
||||
BigFraction[][] derivatives = interpolator.derivatives(new BigFraction(0), 5);
|
||||
Assert.assertEquals(new BigFraction( 1), derivatives[0][0]);
|
||||
Assert.assertEquals(new BigFraction( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(new BigFraction( 8), derivatives[2][0]);
|
||||
Assert.assertEquals(new BigFraction(-24), derivatives[3][0]);
|
||||
Assert.assertEquals(new BigFraction( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(new BigFraction( 0), derivatives[5][0]);
|
||||
derivatives = interpolator.derivatives(new BigFraction(1), 5);
|
||||
Assert.assertEquals(new BigFraction( 4), derivatives[0][0]);
|
||||
Assert.assertEquals(new BigFraction( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(new BigFraction( -4), derivatives[2][0]);
|
||||
Assert.assertEquals(new BigFraction( 0), derivatives[3][0]);
|
||||
Assert.assertEquals(new BigFraction( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(new BigFraction( 0), derivatives[5][0]);
|
||||
derivatives = interpolator.derivatives(new BigFraction(2), 5);
|
||||
Assert.assertEquals(new BigFraction( 5), derivatives[0][0]);
|
||||
Assert.assertEquals(new BigFraction( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(new BigFraction( 8), derivatives[2][0]);
|
||||
Assert.assertEquals(new BigFraction( 24), derivatives[3][0]);
|
||||
Assert.assertEquals(new BigFraction( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(new BigFraction( 0), derivatives[5][0]);
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(0), new Dfp[] { Dfp25.of(1) }, new Dfp[] { Dfp25.of(2) });
|
||||
interpolator.addSamplePoint(Dfp25.of(1), new Dfp[] { Dfp25.of(4) });
|
||||
interpolator.addSamplePoint(Dfp25.of(2), new Dfp[] { Dfp25.of(5) }, new Dfp[] { Dfp25.of(2) });
|
||||
Dfp[][] derivatives = interpolator.derivatives(Dfp25.of(0), 5);
|
||||
Assert.assertEquals(Dfp25.of( 1), derivatives[0][0]);
|
||||
Assert.assertEquals(Dfp25.of( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(Dfp25.of( 8), derivatives[2][0]);
|
||||
Assert.assertEquals(Dfp25.of(-24), derivatives[3][0]);
|
||||
Assert.assertEquals(Dfp25.of( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(Dfp25.of( 0), derivatives[5][0]);
|
||||
derivatives = interpolator.derivatives(Dfp25.of(1), 5);
|
||||
Assert.assertEquals(Dfp25.of( 4), derivatives[0][0]);
|
||||
Assert.assertEquals(Dfp25.of( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(Dfp25.of( -4), derivatives[2][0]);
|
||||
Assert.assertEquals(Dfp25.of( 0), derivatives[3][0]);
|
||||
Assert.assertEquals(Dfp25.of( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(Dfp25.of( 0), derivatives[5][0]);
|
||||
derivatives = interpolator.derivatives(Dfp25.of(2), 5);
|
||||
Assert.assertEquals(Dfp25.of( 5), derivatives[0][0]);
|
||||
Assert.assertEquals(Dfp25.of( 2), derivatives[1][0]);
|
||||
Assert.assertEquals(Dfp25.of( 8), derivatives[2][0]);
|
||||
Assert.assertEquals(Dfp25.of( 24), derivatives[3][0]);
|
||||
Assert.assertEquals(Dfp25.of( 24), derivatives[4][0]);
|
||||
Assert.assertEquals(Dfp25.of( 0), derivatives[5][0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -213,38 +213,38 @@ public class FieldHermiteInterpolatorTest {
|
|||
public void testWikipedia() {
|
||||
// this test corresponds to the example from Wikipedia page:
|
||||
// http://en.wikipedia.org/wiki/Hermite_interpolation
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(-1),
|
||||
new BigFraction[] { new BigFraction( 2) },
|
||||
new BigFraction[] { new BigFraction(-8) },
|
||||
new BigFraction[] { new BigFraction(56) });
|
||||
interpolator.addSamplePoint(new BigFraction( 0),
|
||||
new BigFraction[] { new BigFraction( 1) },
|
||||
new BigFraction[] { new BigFraction( 0) },
|
||||
new BigFraction[] { new BigFraction( 0) });
|
||||
interpolator.addSamplePoint(new BigFraction( 1),
|
||||
new BigFraction[] { new BigFraction( 2) },
|
||||
new BigFraction[] { new BigFraction( 8) },
|
||||
new BigFraction[] { new BigFraction(56) });
|
||||
for (BigFraction x = new BigFraction(-1); x.doubleValue() <= 1.0; x = x.add(new BigFraction(1, 8))) {
|
||||
BigFraction y = interpolator.value(x)[0];
|
||||
BigFraction x2 = x.multiply(x);
|
||||
BigFraction x4 = x2.multiply(x2);
|
||||
BigFraction x8 = x4.multiply(x4);
|
||||
Assert.assertEquals(x8.add(new BigFraction(1)), y);
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(-1),
|
||||
new Dfp[] { Dfp25.of( 2) },
|
||||
new Dfp[] { Dfp25.of(-8) },
|
||||
new Dfp[] { Dfp25.of(56) });
|
||||
interpolator.addSamplePoint(Dfp25.of( 0),
|
||||
new Dfp[] { Dfp25.of( 1) },
|
||||
new Dfp[] { Dfp25.of( 0) },
|
||||
new Dfp[] { Dfp25.of( 0) });
|
||||
interpolator.addSamplePoint(Dfp25.of( 1),
|
||||
new Dfp[] { Dfp25.of( 2) },
|
||||
new Dfp[] { Dfp25.of( 8) },
|
||||
new Dfp[] { Dfp25.of(56) });
|
||||
for (Dfp x = Dfp25.of(-1); x.toDouble() <= 1.0; x = x.add(Dfp25.of(1, 8))) {
|
||||
Dfp y = interpolator.value(x)[0];
|
||||
Dfp x2 = x.multiply(x);
|
||||
Dfp x4 = x2.multiply(x2);
|
||||
Dfp x8 = x4.multiply(x4);
|
||||
Assert.assertEquals(x8.add(Dfp25.of(1)), y);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOnePointParabola() {
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(0),
|
||||
new BigFraction[] { new BigFraction(1) },
|
||||
new BigFraction[] { new BigFraction(1) },
|
||||
new BigFraction[] { new BigFraction(2) });
|
||||
for (BigFraction x = new BigFraction(-1); x.doubleValue() <= 1.0; x = x.add(new BigFraction(1, 8))) {
|
||||
BigFraction y = interpolator.value(x)[0];
|
||||
Assert.assertEquals(BigFraction.ONE.add(x.multiply(BigFraction.ONE.add(x))), y);
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(0),
|
||||
new Dfp[] { Dfp25.of(1) },
|
||||
new Dfp[] { Dfp25.of(1) },
|
||||
new Dfp[] { Dfp25.of(2) });
|
||||
for (Dfp x = Dfp25.of(-1); x.toDouble() <= 1.0; x = x.add(Dfp25.of(1, 8))) {
|
||||
Dfp y = interpolator.value(x)[0];
|
||||
Assert.assertEquals(Dfp25.ONE.add(x.multiply(Dfp25.ONE.add(x))), y);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -258,19 +258,19 @@ public class FieldHermiteInterpolatorTest {
|
|||
|
||||
@Test(expected=NoDataException.class)
|
||||
public void testEmptySampleValue() {
|
||||
new FieldHermiteInterpolator<BigFraction>().value(BigFraction.ZERO);
|
||||
new FieldHermiteInterpolator<Dfp>().value(Dfp25.ZERO);
|
||||
}
|
||||
|
||||
@Test(expected=NoDataException.class)
|
||||
public void testEmptySampleDerivative() {
|
||||
new FieldHermiteInterpolator<BigFraction>().derivatives(BigFraction.ZERO, 1);
|
||||
new FieldHermiteInterpolator<Dfp>().derivatives(Dfp25.ZERO, 1);
|
||||
}
|
||||
|
||||
@Test(expected=MathIllegalArgumentException.class)
|
||||
public void testDuplicatedAbscissa() {
|
||||
FieldHermiteInterpolator<BigFraction> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(new BigFraction(1), new BigFraction[] { new BigFraction(0) });
|
||||
interpolator.addSamplePoint(new BigFraction(1), new BigFraction[] { new BigFraction(1) });
|
||||
FieldHermiteInterpolator<Dfp> interpolator = new FieldHermiteInterpolator<>();
|
||||
interpolator.addSamplePoint(Dfp25.of(1), new Dfp[] { Dfp25.of(0) });
|
||||
interpolator.addSamplePoint(Dfp25.of(1), new Dfp[] { Dfp25.of(1) });
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,45 +0,0 @@
|
|||
/*
|
||||
* 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.math4.fraction;
|
||||
|
||||
|
||||
import org.apache.commons.math4.TestUtils;
|
||||
import org.apache.commons.math4.fraction.BigFraction;
|
||||
import org.apache.commons.math4.fraction.BigFractionField;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class BigFractionFieldTest {
|
||||
|
||||
@Test
|
||||
public void testZero() {
|
||||
Assert.assertEquals(BigFraction.ZERO, BigFractionField.getInstance().getZero());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOne() {
|
||||
Assert.assertEquals(BigFraction.ONE, BigFractionField.getInstance().getOne());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSerial() {
|
||||
// deserializing the singleton should give the singleton itself back
|
||||
BigFractionField field = BigFractionField.getInstance();
|
||||
Assert.assertTrue(field == TestUtils.serializeAndRecover(field));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,643 +0,0 @@
|
|||
/*
|
||||
* 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.math4.fraction;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.math.BigInteger;
|
||||
|
||||
import org.apache.commons.math4.TestUtils;
|
||||
import org.apache.commons.math4.exception.ConvergenceException;
|
||||
import org.apache.commons.math4.exception.MathArithmeticException;
|
||||
import org.apache.commons.math4.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math4.exception.NullArgumentException;
|
||||
import org.apache.commons.math4.exception.ZeroException;
|
||||
import org.apache.commons.math4.fraction.BigFraction;
|
||||
import org.apache.commons.math4.fraction.FractionConversionException;
|
||||
import org.apache.commons.math4.util.FastMath;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
|
||||
public class BigFractionTest {
|
||||
|
||||
private void assertFraction(int expectedNumerator, int expectedDenominator, BigFraction actual) {
|
||||
Assert.assertEquals(expectedNumerator, actual.getNumeratorAsInt());
|
||||
Assert.assertEquals(expectedDenominator, actual.getDenominatorAsInt());
|
||||
}
|
||||
|
||||
private void assertFraction(long expectedNumerator, long expectedDenominator, BigFraction actual) {
|
||||
Assert.assertEquals(expectedNumerator, actual.getNumeratorAsLong());
|
||||
Assert.assertEquals(expectedDenominator, actual.getDenominatorAsLong());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructor() {
|
||||
assertFraction(0, 1, new BigFraction(0, 1));
|
||||
assertFraction(0, 1, new BigFraction(0l, 2l));
|
||||
assertFraction(0, 1, new BigFraction(0, -1));
|
||||
assertFraction(1, 2, new BigFraction(1, 2));
|
||||
assertFraction(1, 2, new BigFraction(2, 4));
|
||||
assertFraction(-1, 2, new BigFraction(-1, 2));
|
||||
assertFraction(-1, 2, new BigFraction(1, -2));
|
||||
assertFraction(-1, 2, new BigFraction(-2, 4));
|
||||
assertFraction(-1, 2, new BigFraction(2, -4));
|
||||
assertFraction(11, 1, new BigFraction(11));
|
||||
assertFraction(11, 1, new BigFraction(11l));
|
||||
assertFraction(11, 1, new BigFraction(new BigInteger("11")));
|
||||
|
||||
assertFraction(0, 1, new BigFraction(0.00000000000001, 1.0e-5, 100));
|
||||
assertFraction(2, 5, new BigFraction(0.40000000000001, 1.0e-5, 100));
|
||||
assertFraction(15, 1, new BigFraction(15.0000000000001, 1.0e-5, 100));
|
||||
|
||||
Assert.assertEquals(0.00000000000001, new BigFraction(0.00000000000001).doubleValue(), 0.0);
|
||||
Assert.assertEquals(0.40000000000001, new BigFraction(0.40000000000001).doubleValue(), 0.0);
|
||||
Assert.assertEquals(15.0000000000001, new BigFraction(15.0000000000001).doubleValue(), 0.0);
|
||||
assertFraction(3602879701896487l, 9007199254740992l, new BigFraction(0.40000000000001));
|
||||
assertFraction(1055531162664967l, 70368744177664l, new BigFraction(15.0000000000001));
|
||||
try {
|
||||
new BigFraction(null, BigInteger.ONE);
|
||||
Assert.fail("Expecting NullArgumentException");
|
||||
} catch (NullArgumentException npe) {
|
||||
// expected
|
||||
}
|
||||
try {
|
||||
new BigFraction(BigInteger.ONE, null);
|
||||
Assert.fail("Expecting NullArgumentException");
|
||||
} catch (NullArgumentException npe) {
|
||||
// expected
|
||||
}
|
||||
try {
|
||||
new BigFraction(BigInteger.ONE, BigInteger.ZERO);
|
||||
Assert.fail("Expecting ZeroException");
|
||||
} catch (ZeroException npe) {
|
||||
// expected
|
||||
}
|
||||
try {
|
||||
new BigFraction(2.0 * Integer.MAX_VALUE, 1.0e-5, 100000);
|
||||
Assert.fail("Expecting FractionConversionException");
|
||||
} catch (FractionConversionException fce) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected=ConvergenceException.class)
|
||||
public void testGoldenRatio() {
|
||||
// the golden ratio is notoriously a difficult number for continuous fraction
|
||||
new BigFraction((1 + FastMath.sqrt(5)) / 2, 1.0e-12, 25);
|
||||
}
|
||||
|
||||
// MATH-179
|
||||
@Test
|
||||
public void testDoubleConstructor() throws ConvergenceException {
|
||||
assertFraction(1, 2, new BigFraction((double) 1 / (double) 2, 1.0e-5, 100));
|
||||
assertFraction(1, 3, new BigFraction((double) 1 / (double) 3, 1.0e-5, 100));
|
||||
assertFraction(2, 3, new BigFraction((double) 2 / (double) 3, 1.0e-5, 100));
|
||||
assertFraction(1, 4, new BigFraction((double) 1 / (double) 4, 1.0e-5, 100));
|
||||
assertFraction(3, 4, new BigFraction((double) 3 / (double) 4, 1.0e-5, 100));
|
||||
assertFraction(1, 5, new BigFraction((double) 1 / (double) 5, 1.0e-5, 100));
|
||||
assertFraction(2, 5, new BigFraction((double) 2 / (double) 5, 1.0e-5, 100));
|
||||
assertFraction(3, 5, new BigFraction((double) 3 / (double) 5, 1.0e-5, 100));
|
||||
assertFraction(4, 5, new BigFraction((double) 4 / (double) 5, 1.0e-5, 100));
|
||||
assertFraction(1, 6, new BigFraction((double) 1 / (double) 6, 1.0e-5, 100));
|
||||
assertFraction(5, 6, new BigFraction((double) 5 / (double) 6, 1.0e-5, 100));
|
||||
assertFraction(1, 7, new BigFraction((double) 1 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(2, 7, new BigFraction((double) 2 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(3, 7, new BigFraction((double) 3 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(4, 7, new BigFraction((double) 4 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(5, 7, new BigFraction((double) 5 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(6, 7, new BigFraction((double) 6 / (double) 7, 1.0e-5, 100));
|
||||
assertFraction(1, 8, new BigFraction((double) 1 / (double) 8, 1.0e-5, 100));
|
||||
assertFraction(3, 8, new BigFraction((double) 3 / (double) 8, 1.0e-5, 100));
|
||||
assertFraction(5, 8, new BigFraction((double) 5 / (double) 8, 1.0e-5, 100));
|
||||
assertFraction(7, 8, new BigFraction((double) 7 / (double) 8, 1.0e-5, 100));
|
||||
assertFraction(1, 9, new BigFraction((double) 1 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(2, 9, new BigFraction((double) 2 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(4, 9, new BigFraction((double) 4 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(5, 9, new BigFraction((double) 5 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(7, 9, new BigFraction((double) 7 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(8, 9, new BigFraction((double) 8 / (double) 9, 1.0e-5, 100));
|
||||
assertFraction(1, 10, new BigFraction((double) 1 / (double) 10, 1.0e-5, 100));
|
||||
assertFraction(3, 10, new BigFraction((double) 3 / (double) 10, 1.0e-5, 100));
|
||||
assertFraction(7, 10, new BigFraction((double) 7 / (double) 10, 1.0e-5, 100));
|
||||
assertFraction(9, 10, new BigFraction((double) 9 / (double) 10, 1.0e-5, 100));
|
||||
assertFraction(1, 11, new BigFraction((double) 1 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(2, 11, new BigFraction((double) 2 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(3, 11, new BigFraction((double) 3 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(4, 11, new BigFraction((double) 4 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(5, 11, new BigFraction((double) 5 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(6, 11, new BigFraction((double) 6 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(7, 11, new BigFraction((double) 7 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(8, 11, new BigFraction((double) 8 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(9, 11, new BigFraction((double) 9 / (double) 11, 1.0e-5, 100));
|
||||
assertFraction(10, 11, new BigFraction((double) 10 / (double) 11, 1.0e-5, 100));
|
||||
}
|
||||
|
||||
// MATH-181
|
||||
@Test
|
||||
public void testDigitLimitConstructor() throws ConvergenceException {
|
||||
assertFraction(2, 5, new BigFraction(0.4, 9));
|
||||
assertFraction(2, 5, new BigFraction(0.4, 99));
|
||||
assertFraction(2, 5, new BigFraction(0.4, 999));
|
||||
|
||||
assertFraction(3, 5, new BigFraction(0.6152, 9));
|
||||
assertFraction(8, 13, new BigFraction(0.6152, 99));
|
||||
assertFraction(510, 829, new BigFraction(0.6152, 999));
|
||||
assertFraction(769, 1250, new BigFraction(0.6152, 9999));
|
||||
|
||||
// MATH-996
|
||||
assertFraction(1, 2, new BigFraction(0.5000000001, 10));
|
||||
}
|
||||
|
||||
// MATH-1029
|
||||
@Test(expected=FractionConversionException.class)
|
||||
public void testPositiveValueOverflow() {
|
||||
assertFraction((long) 1e10, 1, new BigFraction(1e10, 1000));
|
||||
}
|
||||
|
||||
// MATH-1029
|
||||
@Test(expected=FractionConversionException.class)
|
||||
public void testNegativeValueOverflow() {
|
||||
assertFraction((long) -1e10, 1, new BigFraction(-1e10, 1000));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEpsilonLimitConstructor() throws ConvergenceException {
|
||||
assertFraction(2, 5, new BigFraction(0.4, 1.0e-5, 100));
|
||||
|
||||
assertFraction(3, 5, new BigFraction(0.6152, 0.02, 100));
|
||||
assertFraction(8, 13, new BigFraction(0.6152, 1.0e-3, 100));
|
||||
assertFraction(251, 408, new BigFraction(0.6152, 1.0e-4, 100));
|
||||
assertFraction(251, 408, new BigFraction(0.6152, 1.0e-5, 100));
|
||||
assertFraction(510, 829, new BigFraction(0.6152, 1.0e-6, 100));
|
||||
assertFraction(769, 1250, new BigFraction(0.6152, 1.0e-7, 100));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCompareTo() {
|
||||
BigFraction first = new BigFraction(1, 2);
|
||||
BigFraction second = new BigFraction(1, 3);
|
||||
BigFraction third = new BigFraction(1, 2);
|
||||
|
||||
Assert.assertEquals(0, first.compareTo(first));
|
||||
Assert.assertEquals(0, first.compareTo(third));
|
||||
Assert.assertEquals(1, first.compareTo(second));
|
||||
Assert.assertEquals(-1, second.compareTo(first));
|
||||
|
||||
// these two values are different approximations of PI
|
||||
// the first one is approximately PI - 3.07e-18
|
||||
// the second one is approximately PI + 1.936e-17
|
||||
BigFraction pi1 = new BigFraction(1068966896, 340262731);
|
||||
BigFraction pi2 = new BigFraction( 411557987, 131002976);
|
||||
Assert.assertEquals(-1, pi1.compareTo(pi2));
|
||||
Assert.assertEquals( 1, pi2.compareTo(pi1));
|
||||
Assert.assertEquals(0.0, pi1.doubleValue() - pi2.doubleValue(), 1.0e-20);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDoubleValue() {
|
||||
BigFraction first = new BigFraction(1, 2);
|
||||
BigFraction second = new BigFraction(1, 3);
|
||||
|
||||
Assert.assertEquals(0.5, first.doubleValue(), 0.0);
|
||||
Assert.assertEquals(1.0 / 3.0, second.doubleValue(), 0.0);
|
||||
}
|
||||
|
||||
// MATH-744
|
||||
@Test
|
||||
public void testDoubleValueForLargeNumeratorAndDenominator() {
|
||||
final BigInteger pow400 = BigInteger.TEN.pow(400);
|
||||
final BigInteger pow401 = BigInteger.TEN.pow(401);
|
||||
final BigInteger two = new BigInteger("2");
|
||||
final BigFraction large = new BigFraction(pow401.add(BigInteger.ONE),
|
||||
pow400.multiply(two));
|
||||
|
||||
Assert.assertEquals(5, large.doubleValue(), 1e-15);
|
||||
}
|
||||
|
||||
// MATH-744
|
||||
@Test
|
||||
public void testFloatValueForLargeNumeratorAndDenominator() {
|
||||
final BigInteger pow400 = BigInteger.TEN.pow(400);
|
||||
final BigInteger pow401 = BigInteger.TEN.pow(401);
|
||||
final BigInteger two = new BigInteger("2");
|
||||
final BigFraction large = new BigFraction(pow401.add(BigInteger.ONE),
|
||||
pow400.multiply(two));
|
||||
|
||||
Assert.assertEquals(5, large.floatValue(), 1e-15);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFloatValue() {
|
||||
BigFraction first = new BigFraction(1, 2);
|
||||
BigFraction second = new BigFraction(1, 3);
|
||||
|
||||
Assert.assertEquals(0.5f, first.floatValue(), 0.0f);
|
||||
Assert.assertEquals((float) (1.0 / 3.0), second.floatValue(), 0.0f);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntValue() {
|
||||
BigFraction first = new BigFraction(1, 2);
|
||||
BigFraction second = new BigFraction(3, 2);
|
||||
|
||||
Assert.assertEquals(0, first.intValue());
|
||||
Assert.assertEquals(1, second.intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLongValue() {
|
||||
BigFraction first = new BigFraction(1, 2);
|
||||
BigFraction second = new BigFraction(3, 2);
|
||||
|
||||
Assert.assertEquals(0L, first.longValue());
|
||||
Assert.assertEquals(1L, second.longValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructorDouble() {
|
||||
assertFraction(1, 2, new BigFraction(0.5));
|
||||
assertFraction(6004799503160661l, 18014398509481984l, new BigFraction(1.0 / 3.0));
|
||||
assertFraction(6124895493223875l, 36028797018963968l, new BigFraction(17.0 / 100.0));
|
||||
assertFraction(1784551352345559l, 562949953421312l, new BigFraction(317.0 / 100.0));
|
||||
assertFraction(-1, 2, new BigFraction(-0.5));
|
||||
assertFraction(-6004799503160661l, 18014398509481984l, new BigFraction(-1.0 / 3.0));
|
||||
assertFraction(-6124895493223875l, 36028797018963968l, new BigFraction(17.0 / -100.0));
|
||||
assertFraction(-1784551352345559l, 562949953421312l, new BigFraction(-317.0 / 100.0));
|
||||
for (double v : new double[] { Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}) {
|
||||
try {
|
||||
new BigFraction(v);
|
||||
Assert.fail("Expecting MathIllegalArgumentException");
|
||||
} catch (MathIllegalArgumentException iae) {
|
||||
// expected
|
||||
}
|
||||
}
|
||||
Assert.assertEquals(1l, new BigFraction(Double.MAX_VALUE).getDenominatorAsLong());
|
||||
Assert.assertEquals(1l, new BigFraction(Double.longBitsToDouble(0x0010000000000000L)).getNumeratorAsLong());
|
||||
Assert.assertEquals(1l, new BigFraction(Double.MIN_VALUE).getNumeratorAsLong());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAbs() {
|
||||
BigFraction a = new BigFraction(10, 21);
|
||||
BigFraction b = new BigFraction(-10, 21);
|
||||
BigFraction c = new BigFraction(10, -21);
|
||||
|
||||
assertFraction(10, 21, a.abs());
|
||||
assertFraction(10, 21, b.abs());
|
||||
assertFraction(10, 21, c.abs());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReciprocal() {
|
||||
BigFraction f = null;
|
||||
|
||||
f = new BigFraction(50, 75);
|
||||
f = f.reciprocal();
|
||||
Assert.assertEquals(3, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(2, f.getDenominatorAsInt());
|
||||
|
||||
f = new BigFraction(4, 3);
|
||||
f = f.reciprocal();
|
||||
Assert.assertEquals(3, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(4, f.getDenominatorAsInt());
|
||||
|
||||
f = new BigFraction(-15, 47);
|
||||
f = f.reciprocal();
|
||||
Assert.assertEquals(-47, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(15, f.getDenominatorAsInt());
|
||||
|
||||
f = new BigFraction(0, 3);
|
||||
try {
|
||||
f = f.reciprocal();
|
||||
Assert.fail("expecting ZeroException");
|
||||
} catch (ZeroException ex) {
|
||||
}
|
||||
|
||||
// large values
|
||||
f = new BigFraction(Integer.MAX_VALUE, 1);
|
||||
f = f.reciprocal();
|
||||
Assert.assertEquals(1, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getDenominatorAsInt());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNegate() {
|
||||
BigFraction f = null;
|
||||
|
||||
f = new BigFraction(50, 75);
|
||||
f = f.negate();
|
||||
Assert.assertEquals(-2, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(3, f.getDenominatorAsInt());
|
||||
|
||||
f = new BigFraction(-50, 75);
|
||||
f = f.negate();
|
||||
Assert.assertEquals(2, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(3, f.getDenominatorAsInt());
|
||||
|
||||
// large values
|
||||
f = new BigFraction(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
|
||||
f = f.negate();
|
||||
Assert.assertEquals(Integer.MIN_VALUE + 2, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getDenominatorAsInt());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAdd() {
|
||||
BigFraction a = new BigFraction(1, 2);
|
||||
BigFraction b = new BigFraction(2, 3);
|
||||
|
||||
assertFraction(1, 1, a.add(a));
|
||||
assertFraction(7, 6, a.add(b));
|
||||
assertFraction(7, 6, b.add(a));
|
||||
assertFraction(4, 3, b.add(b));
|
||||
|
||||
BigFraction f1 = new BigFraction(Integer.MAX_VALUE - 1, 1);
|
||||
BigFraction f2 = BigFraction.ONE;
|
||||
BigFraction f = f1.add(f2);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(-1, 13 * 13 * 2 * 2);
|
||||
f2 = new BigFraction(-2, 13 * 17 * 2);
|
||||
f = f1.add(f2);
|
||||
Assert.assertEquals(13 * 13 * 17 * 2 * 2, f.getDenominatorAsInt());
|
||||
Assert.assertEquals(-17 - 2 * 13 * 2, f.getNumeratorAsInt());
|
||||
|
||||
try {
|
||||
f.add((BigFraction) null);
|
||||
Assert.fail("expecting NullArgumentException");
|
||||
} catch (NullArgumentException ex) {
|
||||
}
|
||||
|
||||
// if this fraction is added naively, it will overflow.
|
||||
// check that it doesn't.
|
||||
f1 = new BigFraction(1, 32768 * 3);
|
||||
f2 = new BigFraction(1, 59049);
|
||||
f = f1.add(f2);
|
||||
Assert.assertEquals(52451, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1934917632, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, 3);
|
||||
f2 = new BigFraction(1, 3);
|
||||
f = f1.add(f2);
|
||||
Assert.assertEquals(Integer.MIN_VALUE + 1, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(3, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MAX_VALUE - 1, 1);
|
||||
f = f1.add(BigInteger.ONE);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f = f.add(BigInteger.ZERO);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MAX_VALUE - 1, 1);
|
||||
f = f1.add(1);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f = f.add(0);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MAX_VALUE - 1, 1);
|
||||
f = f1.add(1l);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f = f.add(0l);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDivide() {
|
||||
BigFraction a = new BigFraction(1, 2);
|
||||
BigFraction b = new BigFraction(2, 3);
|
||||
|
||||
assertFraction(1, 1, a.divide(a));
|
||||
assertFraction(3, 4, a.divide(b));
|
||||
assertFraction(4, 3, b.divide(a));
|
||||
assertFraction(1, 1, b.divide(b));
|
||||
|
||||
BigFraction f1 = new BigFraction(3, 5);
|
||||
BigFraction f2 = BigFraction.ZERO;
|
||||
try {
|
||||
f1.divide(f2);
|
||||
Assert.fail("expecting MathArithmeticException");
|
||||
} catch (MathArithmeticException ex) {
|
||||
}
|
||||
|
||||
f1 = new BigFraction(0, 5);
|
||||
f2 = new BigFraction(2, 7);
|
||||
BigFraction f = f1.divide(f2);
|
||||
Assert.assertSame(BigFraction.ZERO, f);
|
||||
|
||||
f1 = new BigFraction(2, 7);
|
||||
f2 = BigFraction.ONE;
|
||||
f = f1.divide(f2);
|
||||
Assert.assertEquals(2, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(7, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(1, Integer.MAX_VALUE);
|
||||
f = f1.divide(f1);
|
||||
Assert.assertEquals(1, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
f2 = new BigFraction(1, Integer.MAX_VALUE);
|
||||
f = f1.divide(f2);
|
||||
Assert.assertEquals(Integer.MIN_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
try {
|
||||
f.divide((BigFraction) null);
|
||||
Assert.fail("expecting NullArgumentException");
|
||||
} catch (NullArgumentException ex) {
|
||||
}
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
f = f1.divide(BigInteger.valueOf(Integer.MIN_VALUE));
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getDenominatorAsInt());
|
||||
Assert.assertEquals(1, f.getNumeratorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
f = f1.divide(Integer.MIN_VALUE);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getDenominatorAsInt());
|
||||
Assert.assertEquals(1, f.getNumeratorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
f = f1.divide((long) Integer.MIN_VALUE);
|
||||
Assert.assertEquals(Integer.MAX_VALUE, f.getDenominatorAsInt());
|
||||
Assert.assertEquals(1, f.getNumeratorAsInt());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultiply() {
|
||||
BigFraction a = new BigFraction(1, 2);
|
||||
BigFraction b = new BigFraction(2, 3);
|
||||
|
||||
assertFraction(1, 4, a.multiply(a));
|
||||
assertFraction(1, 3, a.multiply(b));
|
||||
assertFraction(1, 3, b.multiply(a));
|
||||
assertFraction(4, 9, b.multiply(b));
|
||||
|
||||
BigFraction f1 = new BigFraction(Integer.MAX_VALUE, 1);
|
||||
BigFraction f2 = new BigFraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
BigFraction f = f1.multiply(f2);
|
||||
Assert.assertEquals(Integer.MIN_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f = f2.multiply(Integer.MAX_VALUE);
|
||||
Assert.assertEquals(Integer.MIN_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
f = f2.multiply((long) Integer.MAX_VALUE);
|
||||
Assert.assertEquals(Integer.MIN_VALUE, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
try {
|
||||
f.multiply((BigFraction) null);
|
||||
Assert.fail("expecting NullArgumentException");
|
||||
} catch (NullArgumentException ex) {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSubtract() {
|
||||
BigFraction a = new BigFraction(1, 2);
|
||||
BigFraction b = new BigFraction(2, 3);
|
||||
|
||||
assertFraction(0, 1, a.subtract(a));
|
||||
assertFraction(-1, 6, a.subtract(b));
|
||||
assertFraction(1, 6, b.subtract(a));
|
||||
assertFraction(0, 1, b.subtract(b));
|
||||
|
||||
BigFraction f = new BigFraction(1, 1);
|
||||
try {
|
||||
f.subtract((BigFraction) null);
|
||||
Assert.fail("expecting NullArgumentException");
|
||||
} catch (NullArgumentException ex) {
|
||||
}
|
||||
|
||||
// if this fraction is subtracted naively, it will overflow.
|
||||
// check that it doesn't.
|
||||
BigFraction f1 = new BigFraction(1, 32768 * 3);
|
||||
BigFraction f2 = new BigFraction(1, 59049);
|
||||
f = f1.subtract(f2);
|
||||
Assert.assertEquals(-13085, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1934917632, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MIN_VALUE, 3);
|
||||
f2 = new BigFraction(1, 3).negate();
|
||||
f = f1.subtract(f2);
|
||||
Assert.assertEquals(Integer.MIN_VALUE + 1, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(3, f.getDenominatorAsInt());
|
||||
|
||||
f1 = new BigFraction(Integer.MAX_VALUE, 1);
|
||||
f2 = BigFraction.ONE;
|
||||
f = f1.subtract(f2);
|
||||
Assert.assertEquals(Integer.MAX_VALUE - 1, f.getNumeratorAsInt());
|
||||
Assert.assertEquals(1, f.getDenominatorAsInt());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBigDecimalValue() {
|
||||
Assert.assertEquals(new BigDecimal(0.5), new BigFraction(1, 2).bigDecimalValue());
|
||||
Assert.assertEquals(new BigDecimal("0.0003"), new BigFraction(3, 10000).bigDecimalValue());
|
||||
Assert.assertEquals(new BigDecimal("0"), new BigFraction(1, 3).bigDecimalValue(BigDecimal.ROUND_DOWN));
|
||||
Assert.assertEquals(new BigDecimal("0.333"), new BigFraction(1, 3).bigDecimalValue(3, BigDecimal.ROUND_DOWN));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEqualsAndHashCode() {
|
||||
BigFraction zero = new BigFraction(0, 1);
|
||||
BigFraction nullFraction = null;
|
||||
Assert.assertTrue(zero.equals(zero));
|
||||
Assert.assertFalse(zero.equals(nullFraction));
|
||||
Assert.assertFalse(zero.equals(Double.valueOf(0)));
|
||||
BigFraction zero2 = new BigFraction(0, 2);
|
||||
Assert.assertTrue(zero.equals(zero2));
|
||||
Assert.assertEquals(zero.hashCode(), zero2.hashCode());
|
||||
BigFraction one = new BigFraction(1, 1);
|
||||
Assert.assertFalse((one.equals(zero) || zero.equals(one)));
|
||||
Assert.assertTrue(one.equals(BigFraction.ONE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetReducedFraction() {
|
||||
BigFraction threeFourths = new BigFraction(3, 4);
|
||||
Assert.assertTrue(threeFourths.equals(BigFraction.getReducedFraction(6, 8)));
|
||||
Assert.assertTrue(BigFraction.ZERO.equals(BigFraction.getReducedFraction(0, -1)));
|
||||
try {
|
||||
BigFraction.getReducedFraction(1, 0);
|
||||
Assert.fail("expecting ZeroException");
|
||||
} catch (ZeroException ex) {
|
||||
// expected
|
||||
}
|
||||
Assert.assertEquals(BigFraction.getReducedFraction(2, Integer.MIN_VALUE).getNumeratorAsInt(), -1);
|
||||
Assert.assertEquals(BigFraction.getReducedFraction(1, -1).getNumeratorAsInt(), -1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPercentage() {
|
||||
Assert.assertEquals(50.0, new BigFraction(1, 2).percentageValue(), 1.0e-15);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPow() {
|
||||
Assert.assertEquals(new BigFraction(8192, 1594323), new BigFraction(2, 3).pow(13));
|
||||
Assert.assertEquals(new BigFraction(8192, 1594323), new BigFraction(2, 3).pow(13l));
|
||||
Assert.assertEquals(new BigFraction(8192, 1594323), new BigFraction(2, 3).pow(BigInteger.valueOf(13l)));
|
||||
Assert.assertEquals(BigFraction.ONE, new BigFraction(2, 3).pow(0));
|
||||
Assert.assertEquals(BigFraction.ONE, new BigFraction(2, 3).pow(0l));
|
||||
Assert.assertEquals(BigFraction.ONE, new BigFraction(2, 3).pow(BigInteger.valueOf(0l)));
|
||||
Assert.assertEquals(new BigFraction(1594323, 8192), new BigFraction(2, 3).pow(-13));
|
||||
Assert.assertEquals(new BigFraction(1594323, 8192), new BigFraction(2, 3).pow(-13l));
|
||||
Assert.assertEquals(new BigFraction(1594323, 8192), new BigFraction(2, 3).pow(BigInteger.valueOf(-13l)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMath340() {
|
||||
BigFraction fractionA = new BigFraction(0.00131);
|
||||
BigFraction fractionB = new BigFraction(.37).reciprocal();
|
||||
BigFraction errorResult = fractionA.multiply(fractionB);
|
||||
BigFraction correctResult = new BigFraction(fractionA.getNumerator().multiply(fractionB.getNumerator()),
|
||||
fractionA.getDenominator().multiply(fractionB.getDenominator()));
|
||||
Assert.assertEquals(correctResult, errorResult);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSerial() throws FractionConversionException {
|
||||
BigFraction[] fractions = {
|
||||
new BigFraction(3, 4), BigFraction.ONE, BigFraction.ZERO,
|
||||
new BigFraction(17), new BigFraction(FastMath.PI, 1000),
|
||||
new BigFraction(-5, 2)
|
||||
};
|
||||
for (BigFraction fraction : fractions) {
|
||||
Assert.assertEquals(fraction, TestUtils.serializeAndRecover(fraction));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -22,7 +22,6 @@ import org.apache.commons.math4.TestUtils;
|
|||
import org.apache.commons.math4.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math4.exception.NotStrictlyPositiveException;
|
||||
import org.apache.commons.math4.exception.NullArgumentException;
|
||||
import org.apache.commons.math4.fraction.BigFraction;
|
||||
import org.apache.commons.math4.dfp.Dfp;
|
||||
import org.apache.commons.math4.dfp.DfpField;
|
||||
import org.apache.commons.math4.linear.Dfp25;
|
||||
|
|
@ -261,19 +260,6 @@ public final class MatrixUtilsTest {
|
|||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBigDfpConverter() {
|
||||
BigFraction[][] bfData = {
|
||||
{ new BigFraction(1), new BigFraction(2), new BigFraction(3) },
|
||||
{ new BigFraction(2), new BigFraction(5), new BigFraction(3) },
|
||||
{ new BigFraction(1), new BigFraction(0), new BigFraction(8) }
|
||||
};
|
||||
FieldMatrix<BigFraction> m = new Array2DRowFieldMatrix<>(bfData, false);
|
||||
RealMatrix converted = MatrixUtils.bigFractionMatrixToRealMatrix(m);
|
||||
RealMatrix reference = new Array2DRowRealMatrix(testData, false);
|
||||
Assert.assertEquals(0.0, converted.subtract(reference).getNorm(), 0.0);
|
||||
}
|
||||
|
||||
public static final Dfp[][] asDfp(double[][] data) {
|
||||
Dfp d[][] = new Dfp[data.length][];
|
||||
for (int i = 0; i < data.length; ++i) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue