NUMBERS-53: Fixes to test classes. Waiting on decision about TestComplex
class.
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
index 861da5a..e7a595e 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
@@ -18,9 +18,7 @@
package org.apache.commons.numbers.complex;
import org.apache.commons.numbers.complex.Complex;
-import org.apache.commons.numbers.complex.ComplexUtils;
import org.junit.Assert;
-import org.junit.Ignore;
import org.junit.Test;
public class CStandardTest {
@@ -28,49 +26,44 @@
private static final double inf = Double.POSITIVE_INFINITY;
private static final double negInf = Double.NEGATIVE_INFINITY;
private static final double nan = Double.NaN;
- private static final double pi = Math.PI;
private static final double piOverFour = Math.PI / 4.0;
private static final double piOverTwo = Math.PI / 2.0;
private static final double threePiOverFour = 3.0*Math.PI/4.0;
- private static final Complex oneOne = new Complex(1, 1);
- private static final Complex oneZero = new Complex(1, 0);
- private static final Complex oneInf = new Complex(1, inf);
- private static final Complex oneNegInf = new Complex(1, negInf);
- private static final Complex oneNaN = new Complex(1, nan);
- private static final Complex zeroInf = new Complex(0, inf);
- private static final Complex zeroNegInf = new Complex(0,negInf);
- private static final Complex zeroNaN = new Complex(0, nan);
- private static final Complex zeroPiTwo = new Complex(0.0, piOverTwo);
- private static final Complex negZeroZero = new Complex(-0.0, 0);
- private static final Complex negZeroNan = new Complex(-0.0, nan);
- private static final Complex negI = new Complex(0.0, -1.0);
- private static final Complex infOne = new Complex(inf, 1);
- private static final Complex infZero = new Complex(inf, 0);
- private static final Complex infNaN = new Complex(inf, nan);
- private static final Complex infNegInf = new Complex(inf, negInf);
- private static final Complex infInf = new Complex(inf, inf);
- private static final Complex infPiTwo = new Complex(inf, piOverTwo);
- private static final Complex infPiFour = new Complex(inf, piOverFour);
- private static final Complex infPi = new Complex(inf, Math.PI);
- private static final Complex negInfInf = new Complex(negInf, inf);
- private static final Complex negInfZero = new Complex(negInf, 0);
- private static final Complex negInfOne = new Complex(negInf, 1);
- private static final Complex negInfNaN = new Complex(negInf, nan);
- private static final Complex negInfNegInf = new Complex(negInf, negInf);
- private static final Complex negInfPosInf = new Complex(negInf, inf);
- private static final Complex negInfPi = new Complex(negInf, Math.PI);
- private static final Complex nanInf = new Complex(nan, inf);
- private static final Complex nanNegInf = new Complex(nan, negInf);
- private static final Complex nanZero = new Complex(nan, 0);
- private static final Complex nanOne = new Complex(nan, 1);
- private static final Complex piTwoNaN = new Complex(piOverTwo, nan);
- private static final Complex piNegInf = new Complex(Math.PI, negInf);
- private static final Complex piTwoNegInf = new Complex(piOverTwo, negInf);
- private static final Complex piTwoNegZero = new Complex(piOverTwo, -0.0);
- private static final Complex threePiFourNegInf = new Complex(threePiOverFour,negInf);
- private static final Complex piFourNegInf = new Complex(piOverFour, negInf);
- private static final Complex NAN = new Complex(nan, nan);
-
+ private static final Complex oneOne = Complex.ofCartesian(1, 1);
+ private static final Complex oneZero = Complex.ofCartesian(1, 0);
+ private static final Complex oneInf = Complex.ofCartesian(1, inf);
+ private static final Complex oneNaN = Complex.ofCartesian(1, nan);
+ private static final Complex zeroInf = Complex.ofCartesian(0, inf);
+ private static final Complex zeroNegInf = Complex.ofCartesian(0,negInf);
+ private static final Complex zeroNaN = Complex.ofCartesian(0, nan);
+ private static final Complex zeroPiTwo = Complex.ofCartesian(0.0, piOverTwo);
+ private static final Complex negZeroZero = Complex.ofCartesian(-0.0, 0);
+ private static final Complex negI = Complex.ofCartesian(0.0, -1.0);
+ private static final Complex infOne = Complex.ofCartesian(inf, 1);
+ private static final Complex infZero = Complex.ofCartesian(inf, 0);
+ private static final Complex infNaN = Complex.ofCartesian(inf, nan);
+ private static final Complex infInf = Complex.ofCartesian(inf, inf);
+ private static final Complex infPiTwo = Complex.ofCartesian(inf, piOverTwo);
+ private static final Complex infPiFour = Complex.ofCartesian(inf, piOverFour);
+ private static final Complex infPi = Complex.ofCartesian(inf, Math.PI);
+ private static final Complex negInfInf = Complex.ofCartesian(negInf, inf);
+ private static final Complex negInfZero = Complex.ofCartesian(negInf, 0);
+ private static final Complex negInfOne = Complex.ofCartesian(negInf, 1);
+ private static final Complex negInfNaN = Complex.ofCartesian(negInf, nan);
+ private static final Complex negInfPosInf = Complex.ofCartesian(negInf, inf);
+ private static final Complex negInfPi = Complex.ofCartesian(negInf, Math.PI);
+ private static final Complex nanInf = Complex.ofCartesian(nan, inf);
+ private static final Complex nanNegInf = Complex.ofCartesian(nan, negInf);
+ private static final Complex nanZero = Complex.ofCartesian(nan, 0);
+ private static final Complex nanOne = Complex.ofCartesian(nan, 1);
+ private static final Complex piTwoNaN = Complex.ofCartesian(piOverTwo, nan);
+ private static final Complex piNegInf = Complex.ofCartesian(Math.PI, negInf);
+ private static final Complex piTwoNegInf = Complex.ofCartesian(piOverTwo, negInf);
+ private static final Complex piTwoNegZero = Complex.ofCartesian(piOverTwo, -0.0);
+ private static final Complex threePiFourNegInf = Complex.ofCartesian(threePiOverFour,negInf);
+ private static final Complex piFourNegInf = Complex.ofCartesian(piOverFour, negInf);
+ private static final Complex NAN = Complex.ofCartesian(nan, nan);
+
public void assertComplex(Complex c1, Complex c2, double realTol, double imagTol) {
Assert.assertEquals(c1.getReal(), c2.getReal(), realTol);
Assert.assertEquals(c1.getImaginary(), c2.getImaginary(), imagTol);
@@ -87,18 +80,18 @@
*/
@Test
public void testSqrt1() {
- Complex z1 = new Complex(-2.0, 0.0);
- Complex z2 = new Complex(0.0, Math.sqrt(2));
+ Complex z1 = Complex.ofCartesian(-2.0, 0.0);
+ Complex z2 = Complex.ofCartesian(0.0, Math.sqrt(2));
assertComplex(z1.sqrt(), z2);
- z1 = new Complex(-2.0, -0.0);
- z2 = new Complex(0.0, -Math.sqrt(2));
+ z1 = Complex.ofCartesian(-2.0, -0.0);
+ z2 = Complex.ofCartesian(0.0, -Math.sqrt(2));
assertComplex(z1.sqrt(), z2);
}
@Test
public void testImplicitTrig() {
- Complex z1 = new Complex(3.0);
- Complex z2 = new Complex(0.0, 3.0);
+ Complex z1 = Complex.ofCartesian(3.0);
+ Complex z2 = Complex.ofCartesian(0.0, 3.0);
assertComplex(z1.asin(), negI.multiply(z2.asinh()));
assertComplex(z1.atan(), negI.multiply(z2.atanh()), Math.ulp(1), Math.ulp(1));
assertComplex(z1.cos(), z2.cosh());
@@ -252,7 +245,7 @@
@Test
public void testLog() {
assertComplex(oneOne.log().conj(), oneOne.conj().log());
- assertComplex(negZeroZero.log(), negInfPi);
+ assertComplex(negZeroZero.log(), negInfPi);
assertComplex(Complex.ZERO.log(), negInfZero);
assertComplex(oneInf.log(), infPiTwo);
assertComplex(oneNaN.log(), NAN);
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
index 80b433d..e147fe0 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
@@ -34,62 +34,62 @@
private static final double neginf = Double.NEGATIVE_INFINITY;
private static final double nan = Double.NaN;
private static final double pi = Math.PI;
- private static final Complex oneInf = new Complex(1, inf);
- private static final Complex oneNegInf = new Complex(1, neginf);
- private static final Complex infOne = new Complex(inf, 1);
- private static final Complex infZero = new Complex(inf, 0);
- private static final Complex infNaN = new Complex(inf, nan);
- private static final Complex infNegInf = new Complex(inf, neginf);
- private static final Complex infInf = new Complex(inf, inf);
- private static final Complex negInfInf = new Complex(neginf, inf);
- private static final Complex negInfZero = new Complex(neginf, 0);
- private static final Complex negInfOne = new Complex(neginf, 1);
- private static final Complex negInfNaN = new Complex(neginf, nan);
- private static final Complex negInfNegInf = new Complex(neginf, neginf);
- private static final Complex oneNaN = new Complex(1, nan);
- private static final Complex zeroInf = new Complex(0, inf);
- private static final Complex zeroNaN = new Complex(0, nan);
- private static final Complex nanInf = new Complex(nan, inf);
- private static final Complex nanNegInf = new Complex(nan, neginf);
- private static final Complex nanZero = new Complex(nan, 0);
- private static final Complex NAN = new Complex(nan, nan);
+ private static final Complex oneInf = Complex.ofCartesian(1, inf);
+ private static final Complex oneNegInf = Complex.ofCartesian(1, neginf);
+ private static final Complex infOne = Complex.ofCartesian(inf, 1);
+ private static final Complex infZero = Complex.ofCartesian(inf, 0);
+ private static final Complex infNaN = Complex.ofCartesian(inf, nan);
+ private static final Complex infNegInf = Complex.ofCartesian(inf, neginf);
+ private static final Complex infInf = Complex.ofCartesian(inf, inf);
+ private static final Complex negInfInf = Complex.ofCartesian(neginf, inf);
+ private static final Complex negInfZero = Complex.ofCartesian(neginf, 0);
+ private static final Complex negInfOne = Complex.ofCartesian(neginf, 1);
+ private static final Complex negInfNaN = Complex.ofCartesian(neginf, nan);
+ private static final Complex negInfNegInf = Complex.ofCartesian(neginf, neginf);
+ private static final Complex oneNaN = Complex.ofCartesian(1, nan);
+ private static final Complex zeroInf = Complex.ofCartesian(0, inf);
+ private static final Complex zeroNaN = Complex.ofCartesian(0, nan);
+ private static final Complex nanInf = Complex.ofCartesian(nan, inf);
+ private static final Complex nanNegInf = Complex.ofCartesian(nan, neginf);
+ private static final Complex nanZero = Complex.ofCartesian(nan, 0);
+ private static final Complex NAN = Complex.ofCartesian(nan, nan);
@Test
public void testConstructor() {
- Complex z = new Complex(3.0, 4.0);
+ Complex z = Complex.ofCartesian(3.0, 4.0);
Assert.assertEquals(3.0, z.getReal(), 1.0e-5);
Assert.assertEquals(4.0, z.getImaginary(), 1.0e-5);
}
@Test
public void testConstructorNaN() {
- Complex z = new Complex(3.0, Double.NaN);
+ Complex z = Complex.ofCartesian(3.0, Double.NaN);
Assert.assertTrue(z.isNaN());
- z = new Complex(nan, 4.0);
+ z = Complex.ofCartesian(nan, 4.0);
Assert.assertTrue(z.isNaN());
- z = new Complex(3.0, 4.0);
+ z = Complex.ofCartesian(3.0, 4.0);
Assert.assertFalse(z.isNaN());
}
@Test
public void testAbs() {
- Complex z = new Complex(3.0, 4.0);
+ Complex z = Complex.ofCartesian(3.0, 4.0);
Assert.assertEquals(5.0, z.abs(), 1.0e-5);
}
@Test
public void testAbsNaN() {
Assert.assertTrue(Double.isNaN(NAN.abs()));
- Complex z = new Complex(inf, nan);
+ Complex z = Complex.ofCartesian(inf, nan);
Assert.assertTrue(Double.isNaN(z.abs()));
}
@Test
public void testAdd() {
- Complex x = new Complex(3.0, 4.0);
- Complex y = new Complex(5.0, 6.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
+ Complex y = Complex.ofCartesian(5.0, 6.0);
Complex z = x.add(y);
Assert.assertEquals(8.0, z.getReal(), 1.0e-5);
Assert.assertEquals(10.0, z.getImaginary(), 1.0e-5);
@@ -97,48 +97,48 @@
@Test
public void testAddInf() {
- Complex x = new Complex(1, 1);
- Complex z = new Complex(inf, 0);
+ Complex x = Complex.ofCartesian(1, 1);
+ Complex z = Complex.ofCartesian(inf, 0);
Complex w = x.add(z);
Assert.assertEquals(w.getImaginary(), 1, 0);
Assert.assertEquals(inf, w.getReal(), 0);
- x = new Complex(neginf, 0);
+ x = Complex.ofCartesian(neginf, 0);
Assert.assertTrue(Double.isNaN(x.add(z).getReal()));
}
@Test
public void testScalarAdd() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = 2.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.add(yComplex), x.add(yDouble));
}
@Test
public void testScalarAddNaN() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = Double.NaN;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.add(yComplex), x.add(yDouble));
}
@Test
public void testScalarAddInf() {
- Complex x = new Complex(1, 1);
+ Complex x = Complex.ofCartesian(1, 1);
double yDouble = Double.POSITIVE_INFINITY;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.add(yComplex), x.add(yDouble));
- x = new Complex(neginf, 0);
+ x = Complex.ofCartesian(neginf, 0);
Assert.assertEquals(x.add(yComplex), x.add(yDouble));
}
@Test
public void testConjugate() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Complex z = x.conjugate();
Assert.assertEquals(3.0, z.getReal(), 1.0e-5);
Assert.assertEquals(-4.0, z.getImaginary(), 1.0e-5);
@@ -152,16 +152,16 @@
@Test
public void testConjugateInfiinite() {
- Complex z = new Complex(0, inf);
+ Complex z = Complex.ofCartesian(0, inf);
Assert.assertEquals(neginf, z.conjugate().getImaginary(), 0);
- z = new Complex(0, neginf);
+ z = Complex.ofCartesian(0, neginf);
Assert.assertEquals(inf, z.conjugate().getImaginary(), 0);
}
@Test
public void testDivide() {
- Complex x = new Complex(3.0, 4.0);
- Complex y = new Complex(5.0, 6.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
+ Complex y = Complex.ofCartesian(5.0, 6.0);
Complex z = x.divide(y);
Assert.assertEquals(39.0 / 61.0, z.getReal(), 1.0e-5);
Assert.assertEquals(2.0 / 61.0, z.getImaginary(), 1.0e-5);
@@ -169,22 +169,22 @@
@Test
public void testDivideReal() {
- Complex x = new Complex(2d, 3d);
- Complex y = new Complex(2d, 0d);
- Assert.assertEquals(new Complex(1d, 1.5), x.divide(y));
+ Complex x = Complex.ofCartesian(2d, 3d);
+ Complex y = Complex.ofCartesian(2d, 0d);
+ Assert.assertEquals(Complex.ofCartesian(1d, 1.5), x.divide(y));
}
@Test
public void testDivideImaginary() {
- Complex x = new Complex(2d, 3d);
- Complex y = new Complex(0d, 2d);
- Assert.assertEquals(new Complex(1.5d, -1d), x.divide(y));
+ Complex x = Complex.ofCartesian(2d, 3d);
+ Complex y = Complex.ofCartesian(0d, 2d);
+ Assert.assertEquals(Complex.ofCartesian(1.5d, -1d), x.divide(y));
}
@Test
public void testDivideZero() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Complex z = x.divide(Complex.ZERO);
// Assert.assertEquals(z, Complex.INF); // See MATH-657
Assert.assertEquals(z, NAN);
@@ -192,14 +192,14 @@
@Test
public void testDivideZeroZero() {
- Complex x = new Complex(0.0, 0.0);
+ Complex x = Complex.ofCartesian(0.0, 0.0);
Complex z = x.divide(Complex.ZERO);
Assert.assertEquals(z, NAN);
}
@Test
public void testDivideNaN() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Complex z = x.divide(NAN);
Assert.assertTrue(z.isNaN());
}
@@ -221,29 +221,29 @@
@Test
public void testScalarDivide() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = 2.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.divide(yComplex), x.divide(yDouble));
}
@Test
public void testScalarDivideNaN() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = Double.NaN;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.divide(yComplex), x.divide(yDouble));
}
@Test
public void testScalarDivideZero() {
- Complex x = new Complex(1,1);
+ Complex x = Complex.ofCartesian(1,1);
TestUtils.assertEquals(x.divide(Complex.ZERO), x.divide(0), 0);
}
@Test
public void testReciprocal() {
- Complex z = new Complex(5.0, 6.0);
+ Complex z = Complex.ofCartesian(5.0, 6.0);
Complex act = z.reciprocal();
double expRe = 5.0 / 61.0;
double expIm = -6.0 / 61.0;
@@ -253,7 +253,7 @@
@Test
public void testReciprocalReciprocal() {
- Complex z = new Complex(5.0, 6.0);
+ Complex z = Complex.ofCartesian(5.0, 6.0);
Complex zRR = z.reciprocal().reciprocal();
final double tol = 1e-14;
Assert.assertEquals(zRR.getReal(), z.getReal(), tol);
@@ -262,14 +262,14 @@
@Test
public void testReciprocalReal() {
- Complex z = new Complex(-2.0, 0.0);
- Assert.assertTrue(Complex.equals(new Complex(-0.5, 0.0), z.reciprocal()));
+ Complex z = Complex.ofCartesian(-2.0, 0.0);
+ Assert.assertTrue(Complex.equals(Complex.ofCartesian(-0.5, 0.0), z.reciprocal()));
}
@Test
public void testReciprocalImaginary() {
- Complex z = new Complex(0.0, -2.0);
- Assert.assertEquals(new Complex(0.0, 0.5), z.reciprocal());
+ Complex z = Complex.ofCartesian(0.0, -2.0);
+ Assert.assertEquals(Complex.ofCartesian(0.0, 0.5), z.reciprocal());
}
@Test
@@ -279,8 +279,8 @@
@Test
public void testMultiply() {
- Complex x = new Complex(3.0, 4.0);
- Complex y = new Complex(5.0, 6.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
+ Complex y = Complex.ofCartesian(5.0, 6.0);
Complex z = x.multiply(y);
Assert.assertEquals(-9.0, z.getReal(), 1.0e-5);
Assert.assertEquals(38.0, z.getImaginary(), 1.0e-5);
@@ -294,38 +294,38 @@
@Test
public void testScalarMultiply() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = 2.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.multiply(yComplex), x.multiply(yDouble));
int zInt = -5;
- Complex zComplex = new Complex(zInt);
+ Complex zComplex = Complex.ofCartesian(zInt);
Assert.assertEquals(x.multiply(zComplex), x.multiply(zInt));
}
@Test
public void testScalarMultiplyNaN() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = Double.NaN;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.multiply(yComplex), x.multiply(yDouble));
}
@Test
public void testScalarMultiplyInf() {
- Complex x = new Complex(1, 1);
+ Complex x = Complex.ofCartesian(1, 1);
double yDouble = Double.POSITIVE_INFINITY;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.multiply(yComplex), x.multiply(yDouble));
yDouble = Double.NEGATIVE_INFINITY;
- yComplex = new Complex(yDouble);
+ yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.multiply(yComplex), x.multiply(yDouble));
}
@Test
public void testNegate() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Complex z = x.negate();
Assert.assertEquals(-3.0, z.getReal(), 1.0e-5);
Assert.assertEquals(-4.0, z.getImaginary(), 1.0e-5);
@@ -339,8 +339,8 @@
@Test
public void testSubtract() {
- Complex x = new Complex(3.0, 4.0);
- Complex y = new Complex(5.0, 6.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
+ Complex y = Complex.ofCartesian(5.0, 6.0);
Complex z = x.subtract(y);
Assert.assertEquals(-2.0, z.getReal(), 1.0e-5);
Assert.assertEquals(-2.0, z.getImaginary(), 1.0e-5);
@@ -348,68 +348,68 @@
@Test
public void testSubtractInf() {
- Complex x = new Complex(1, 1);
- Complex z = new Complex(neginf, 0);
+ Complex x = Complex.ofCartesian(1, 1);
+ Complex z = Complex.ofCartesian(neginf, 0);
Complex w = x.subtract(z);
Assert.assertEquals(w.getImaginary(), 1, 0);
Assert.assertEquals(inf, w.getReal(), 0);
- x = new Complex(neginf, 0);
+ x = Complex.ofCartesian(neginf, 0);
Assert.assertTrue(Double.isNaN(x.subtract(z).getReal()));
}
@Test
public void testScalarSubtract() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = 2.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.subtract(yComplex), x.subtract(yDouble));
}
@Test
public void testScalarSubtractNaN() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
double yDouble = Double.NaN;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.subtract(yComplex), x.subtract(yDouble));
}
@Test
public void testScalarSubtractInf() {
- Complex x = new Complex(1, 1);
+ Complex x = Complex.ofCartesian(1, 1);
double yDouble = Double.POSITIVE_INFINITY;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.subtract(yComplex), x.subtract(yDouble));
- x = new Complex(neginf, 0);
+ x = Complex.ofCartesian(neginf, 0);
Assert.assertEquals(x.subtract(yComplex), x.subtract(yDouble));
}
@Test
public void testEqualsNull() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Assert.assertFalse(x.equals(null));
}
@Test(expected=NullPointerException.class)
public void testFloatingPointEqualsPrecondition1() {
- Complex.equals(new Complex(3.0, 4.0), null, 3);
+ Complex.equals(Complex.ofCartesian(3.0, 4.0), null, 3);
}
@Test(expected=NullPointerException.class)
public void testFloatingPointEqualsPrecondition2() {
- Complex.equals(null, new Complex(3.0, 4.0), 3);
+ Complex.equals(null, Complex.ofCartesian(3.0, 4.0), 3);
}
@Test
public void testEqualsClass() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Assert.assertFalse(x.equals(this));
}
@Test
public void testEqualsSame() {
- Complex x = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
Assert.assertTrue(x.equals(x));
}
@@ -418,8 +418,8 @@
double re = -3.21;
double im = 456789e10;
- final Complex x = new Complex(re, im);
- Complex y = new Complex(re, im);
+ final Complex x = Complex.ofCartesian(re, im);
+ Complex y = Complex.ofCartesian(re, im);
Assert.assertTrue(x.equals(y));
Assert.assertTrue(Complex.equals(x, y));
@@ -429,21 +429,21 @@
re = Math.nextUp(re);
im = Math.nextUp(im);
}
- y = new Complex(re, im);
+ y = Complex.ofCartesian(re, im);
Assert.assertTrue(Complex.equals(x, y, maxUlps));
re = Math.nextUp(re);
im = Math.nextUp(im);
- y = new Complex(re, im);
+ y = Complex.ofCartesian(re, im);
Assert.assertFalse(Complex.equals(x, y, maxUlps));
}
@Test
public void testFloatingPointEqualsNaN() {
- Complex c = new Complex(Double.NaN, 1);
+ Complex c = Complex.ofCartesian(Double.NaN, 1);
Assert.assertFalse(Complex.equals(c, c));
- c = new Complex(1, Double.NaN);
+ c = Complex.ofCartesian(1, Double.NaN);
Assert.assertFalse(Complex.equals(c, c));
}
@@ -452,8 +452,8 @@
final double re = 153.0000;
final double im = 152.9375;
final double tol1 = 0.0625;
- final Complex x = new Complex(re, im);
- final Complex y = new Complex(re + tol1, im + tol1);
+ final Complex x = Complex.ofCartesian(re, im);
+ final Complex y = Complex.ofCartesian(re + tol1, im + tol1);
Assert.assertTrue(Complex.equals(x, y, tol1));
final double tol2 = 0.0624;
@@ -462,8 +462,8 @@
@Test
public void testFloatingPointEqualsWithAllowedDeltaNaN() {
- final Complex x = new Complex(0, Double.NaN);
- final Complex y = new Complex(Double.NaN, 0);
+ final Complex x = Complex.ofCartesian(0, Double.NaN);
+ final Complex y = Complex.ofCartesian(Double.NaN, 0);
Assert.assertFalse(Complex.equals(x, Complex.ZERO, 0.1));
Assert.assertFalse(Complex.equals(x, x, 0.1));
Assert.assertFalse(Complex.equals(x, y, 0.1));
@@ -476,15 +476,15 @@
final double im = 1e10;
final double f = 1 + tol;
- final Complex x = new Complex(re, im);
- final Complex y = new Complex(re * f, im * f);
+ final Complex x = Complex.ofCartesian(re, im);
+ final Complex y = Complex.ofCartesian(re * f, im * f);
Assert.assertTrue(Complex.equalsWithRelativeTolerance(x, y, tol));
}
@Test
public void testFloatingPointEqualsWithRelativeToleranceNaN() {
- final Complex x = new Complex(0, Double.NaN);
- final Complex y = new Complex(Double.NaN, 0);
+ final Complex x = Complex.ofCartesian(0, Double.NaN);
+ final Complex y = Complex.ofCartesian(Double.NaN, 0);
Assert.assertFalse(Complex.equalsWithRelativeTolerance(x, Complex.ZERO, 0.1));
Assert.assertFalse(Complex.equalsWithRelativeTolerance(x, x, 0.1));
Assert.assertFalse(Complex.equalsWithRelativeTolerance(x, y, 0.1));
@@ -492,34 +492,34 @@
@Test
public void testEqualsTrue() {
- Complex x = new Complex(3.0, 4.0);
- Complex y = new Complex(3.0, 4.0);
+ Complex x = Complex.ofCartesian(3.0, 4.0);
+ Complex y = Complex.ofCartesian(3.0, 4.0);
Assert.assertTrue(x.equals(y));
}
@Test
public void testEqualsRealDifference() {
- Complex x = new Complex(0.0, 0.0);
- Complex y = new Complex(0.0 + Double.MIN_VALUE, 0.0);
+ Complex x = Complex.ofCartesian(0.0, 0.0);
+ Complex y = Complex.ofCartesian(0.0 + Double.MIN_VALUE, 0.0);
Assert.assertFalse(x.equals(y));
}
@Test
public void testEqualsImaginaryDifference() {
- Complex x = new Complex(0.0, 0.0);
- Complex y = new Complex(0.0, 0.0 + Double.MIN_VALUE);
+ Complex x = Complex.ofCartesian(0.0, 0.0);
+ Complex y = Complex.ofCartesian(0.0, 0.0 + Double.MIN_VALUE);
Assert.assertFalse(x.equals(y));
}
@Test
public void testHashCode() {
- Complex x = new Complex(0.0, 0.0);
- Complex y = new Complex(0.0, 0.0 + Double.MIN_VALUE);
+ Complex x = Complex.ofCartesian(0.0, 0.0);
+ Complex y = Complex.ofCartesian(0.0, 0.0 + Double.MIN_VALUE);
Assert.assertFalse(x.hashCode()==y.hashCode());
- y = new Complex(0.0 + Double.MIN_VALUE, 0.0);
+ y = Complex.ofCartesian(0.0 + Double.MIN_VALUE, 0.0);
Assert.assertFalse(x.hashCode()==y.hashCode());
- Complex realNaN = new Complex(Double.NaN, 0.0);
- Complex imaginaryNaN = new Complex(0.0, Double.NaN);
+ Complex realNaN = Complex.ofCartesian(Double.NaN, 0.0);
+ Complex imaginaryNaN = Complex.ofCartesian(0.0, Double.NaN);
Assert.assertEquals(realNaN.hashCode(), imaginaryNaN.hashCode());
Assert.assertEquals(imaginaryNaN.hashCode(), NAN.hashCode());
@@ -528,13 +528,13 @@
// different hash codes, "equals" must return false.
final String msg = "'equals' not compatible with 'hashCode'";
- x = new Complex(0.0, 0.0);
- y = new Complex(0.0, -0.0);
+ x = Complex.ofCartesian(0.0, 0.0);
+ y = Complex.ofCartesian(0.0, -0.0);
Assert.assertTrue(x.hashCode() != y.hashCode());
Assert.assertFalse(msg, x.equals(y));
- x = new Complex(0.0, 0.0);
- y = new Complex(-0.0, 0.0);
+ x = Complex.ofCartesian(0.0, 0.0);
+ y = Complex.ofCartesian(-0.0, 0.0);
Assert.assertTrue(x.hashCode() != y.hashCode());
Assert.assertFalse(msg, x.equals(y));
}
@@ -570,9 +570,9 @@
@Test
public void testScalarPow() {
- Complex x = new Complex(3, 4);
+ Complex x = Complex.ofCartesian(3, 4);
double yDouble = 5.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.pow(yComplex), x.pow(yDouble));
}
@@ -580,15 +580,15 @@
public void testScalarPowNaNBase() {
Complex x = NAN;
double yDouble = 5.0;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.pow(yComplex), x.pow(yDouble));
}
@Test
public void testScalarPowNaNExponent() {
- Complex x = new Complex(3, 4);
+ Complex x = Complex.ofCartesian(3, 4);
double yDouble = Double.NaN;
- Complex yComplex = new Complex(yDouble);
+ Complex yComplex = Complex.ofCartesian(yDouble);
Assert.assertEquals(x.pow(yComplex), x.pow(yDouble));
}
@Test
@@ -609,8 +609,8 @@
@Test
public void testSqrt1z() {
- Complex z = new Complex(3, 4);
- Complex expected = new Complex(4.08033, -2.94094);
+ Complex z = Complex.ofCartesian(3, 4);
+ Complex expected = Complex.ofCartesian(4.08033, -2.94094);
TestUtils.assertEquals(expected, z.sqrt1z(), 1.0e-5);
}
@@ -633,7 +633,7 @@
@Test
public void testNthRoot_normal_thirdRoot() {
// The complex number we want to compute all third-roots for.
- Complex z = new Complex(-2,2);
+ Complex z = Complex.ofCartesian(-2,2);
// The List holding all third roots
Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
// Returned Collection must not be empty!
@@ -665,7 +665,7 @@
@Test
public void testNthRoot_normal_fourthRoot() {
// The complex number we want to compute all third-roots for.
- Complex z = new Complex(5,-2);
+ Complex z = Complex.ofCartesian(5,-2);
// The List holding all fourth roots
Complex[] fourthRootsOfZ = z.nthRoot(4).toArray(new Complex[0]);
// Returned Collection must not be empty!
@@ -699,7 +699,7 @@
public void testNthRoot_cornercase_thirdRoot_imaginaryPartEmpty() {
// The number 8 has three third roots. One we all already know is the number 2.
// But there are two more complex roots.
- Complex z = new Complex(8,0);
+ Complex z = Complex.ofCartesian(8,0);
// The List holding all third roots
Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
// Returned Collection must not be empty!
@@ -730,7 +730,7 @@
@Test
public void testNthRoot_cornercase_thirdRoot_realPartZero() {
// complex number with only imaginary part
- Complex z = new Complex(0,2);
+ Complex z = Complex.ofCartesian(0,2);
// The List holding all third roots
Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
// Returned Collection must not be empty!
@@ -751,28 +751,28 @@
*/
@Test
public void testGetArgument() {
- Complex z = new Complex(1, 0);
+ Complex z = Complex.ofCartesian(1, 0);
Assert.assertEquals(0.0, z.getArgument(), 1.0e-12);
- z = new Complex(1, 1);
+ z = Complex.ofCartesian(1, 1);
Assert.assertEquals(Math.PI/4, z.getArgument(), 1.0e-12);
- z = new Complex(0, 1);
+ z = Complex.ofCartesian(0, 1);
Assert.assertEquals(Math.PI/2, z.getArgument(), 1.0e-12);
- z = new Complex(-1, 1);
+ z = Complex.ofCartesian(-1, 1);
Assert.assertEquals(3 * Math.PI/4, z.getArgument(), 1.0e-12);
- z = new Complex(-1, 0);
+ z = Complex.ofCartesian(-1, 0);
Assert.assertEquals(Math.PI, z.getArgument(), 1.0e-12);
- z = new Complex(-1, -1);
+ z = Complex.ofCartesian(-1, -1);
Assert.assertEquals(-3 * Math.PI/4, z.getArgument(), 1.0e-12);
- z = new Complex(0, -1);
+ z = Complex.ofCartesian(0, -1);
Assert.assertEquals(-Math.PI/2, z.getArgument(), 1.0e-12);
- z = new Complex(1, -1);
+ z = Complex.ofCartesian(1, -1);
Assert.assertEquals(-Math.PI/4, z.getArgument(), 1.0e-12);
}
@@ -805,7 +805,7 @@
/*
@Test
public void testSerial() {
- Complex z = new Complex(3.0, 4.0);
+ Complex z = Complex.ofCartesian(3.0, 4.0);
Assert.assertEquals(z, TestUtils.serializeAndRecover(z));
Complex ncmplx = (Complex)TestUtils.serializeAndRecover(oneNaN); Assert.assertEquals(nanZero, ncmplx); Assert.assertTrue(ncmplx.isNaN());
Complex infcmplx = (Complex)TestUtils.serializeAndRecover(infInf);
@@ -840,10 +840,5 @@
this(other.getReal(), other.getImaginary());
}
- @Override
- protected TestComplex createComplex(double real, double imaginary){
- return new TestComplex(real, imaginary);
- }
-
}
}
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
index 8ca143a..b57a6b1 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexUtilsTest.java
@@ -31,12 +31,12 @@
private static final double nan = Double.NaN;
private static final double pi = Math.PI;
- private static final Complex negInfInf = new Complex(negInf, inf);
- private static final Complex infNegInf = new Complex(inf, negInf);
- private static final Complex infInf = new Complex(inf, inf);
- private static final Complex negInfNegInf = new Complex(negInf, negInf);
- private static final Complex infNaN = new Complex(inf, nan);
- private static final Complex NAN = new Complex(nan, nan);
+ private static final Complex negInfInf = Complex.ofCartesian(negInf, inf);
+ private static final Complex infNegInf = Complex.ofCartesian(inf, negInf);
+ private static final Complex infInf = Complex.ofCartesian(inf, inf);
+ private static final Complex negInfNegInf = Complex.ofCartesian(negInf, negInf);
+ private static final Complex infNaN = Complex.ofCartesian(inf, nan);
+ private static final Complex NAN = Complex.ofCartesian(nan, nan);
private static Complex c[]; // complex array with real values even and imag
// values odd
@@ -109,9 +109,9 @@
di[i + 1] = i + 1;
fi[i] = i;
fi[i + 1] = i + 1;
- c[i / 2] = new Complex(i, i + 1);
- cr[i / 2] = new Complex(i / 2);
- ci[i / 2] = new Complex(0, i / 2);
+ c[i / 2] = Complex.ofCartesian(i, i + 1);
+ cr[i / 2] = Complex.ofCartesian(i / 2);
+ ci[i / 2] = Complex.ofCartesian(0, i / 2);
sr[i / 2] = i;
si[i / 2] = i + 1;
sfr[i / 2] = i;
@@ -129,9 +129,9 @@
di2d[i][j + 1] = 10 * i + j + 1;
fi2d[i][j] = 10 * i + j;
fi2d[i][j + 1] = 10 * i + j + 1;
- c2d[i][j / 2] = new Complex(10 * i + j, 10 * i + j + 1);
- cr2d[i][j / 2] = new Complex(10 * i + j / 2);
- ci2d[i][j / 2] = new Complex(0, 10 * i + j / 2);
+ c2d[i][j / 2] = Complex.ofCartesian(10 * i + j, 10 * i + j + 1);
+ cr2d[i][j / 2] = Complex.ofCartesian(10 * i + j / 2);
+ ci2d[i][j / 2] = Complex.ofCartesian(0, 10 * i + j / 2);
}
}
for (int i = 0; i < 10; i++) {
@@ -147,20 +147,20 @@
di3d[i][j][k + 1] = 100 * i + 10 * j + k + 1;
fi3d[i][j][k] = 100 * i + 10 * j + k;
fi3d[i][j][k + 1] = 100 * i + 10 * j + k + 1;
- c3d[i][j][k / 2] = new Complex(100 * i + 10 * j + k, 100 * i + 10 * j + k + 1);
- cr3d[i][j][k / 2] = new Complex(100 * i + 10 * j + k / 2);
- ci3d[i][j][k / 2] = new Complex(0, 100 * i + 10 * j + k / 2);
+ c3d[i][j][k / 2] = Complex.ofCartesian(100 * i + 10 * j + k, 100 * i + 10 * j + k + 1);
+ cr3d[i][j][k / 2] = Complex.ofCartesian(100 * i + 10 * j + k / 2);
+ ci3d[i][j][k / 2] = Complex.ofCartesian(0, 100 * i + 10 * j + k / 2);
}
}
}
- ansArrayc1r = new Complex[] { new Complex(3), new Complex(4), new Complex(5), new Complex(6), new Complex(7) };
- ansArrayc2r = new Complex[] { new Complex(3), new Complex(5), new Complex(7) };
- ansArrayc1i = new Complex[] { new Complex(0, 3), new Complex(0, 4), new Complex(0, 5), new Complex(0, 6),
- new Complex(0, 7) };
- ansArrayc2i = new Complex[] { new Complex(0, 3), new Complex(0, 5), new Complex(0, 7) };
- ansArrayc3 = new Complex[] { new Complex(6, 7), new Complex(8, 9), new Complex(10, 11), new Complex(12, 13),
- new Complex(14, 15) };
- ansArrayc4 = new Complex[] { new Complex(6, 7), new Complex(10, 11), new Complex(14, 15) };
+ ansArrayc1r = new Complex[] { Complex.ofCartesian(3), Complex.ofCartesian(4), Complex.ofCartesian(5), Complex.ofCartesian(6), Complex.ofCartesian(7) };
+ ansArrayc2r = new Complex[] { Complex.ofCartesian(3), Complex.ofCartesian(5), Complex.ofCartesian(7) };
+ ansArrayc1i = new Complex[] { Complex.ofCartesian(0, 3), Complex.ofCartesian(0, 4), Complex.ofCartesian(0, 5), Complex.ofCartesian(0, 6),
+ Complex.ofCartesian(0, 7) };
+ ansArrayc2i = new Complex[] { Complex.ofCartesian(0, 3), Complex.ofCartesian(0, 5), Complex.ofCartesian(0, 7) };
+ ansArrayc3 = new Complex[] { Complex.ofCartesian(6, 7), Complex.ofCartesian(8, 9), Complex.ofCartesian(10, 11), Complex.ofCartesian(12, 13),
+ Complex.ofCartesian(14, 15) };
+ ansArrayc4 = new Complex[] { Complex.ofCartesian(6, 7), Complex.ofCartesian(10, 11), Complex.ofCartesian(14, 15) };
ansArrayd1r = new double[] { 6, 8, 10, 12, 14 };
ansArrayd1i = new double[] { 7, 9, 11, 13, 15 };
ansArrayd2r = new double[] { 6, 10, 14 };
@@ -200,7 +200,7 @@
}
protected Complex altPolar(double r, double theta) {
- return Complex.I.multiply(new Complex(theta, 0)).exp().multiply(new Complex(r, 0));
+ return Complex.I.multiply(Complex.ofCartesian(theta, 0)).exp().multiply(Complex.ofCartesian(r, 0));
}
@Test(expected = IllegalArgumentException.class)
@@ -244,17 +244,17 @@
public void testExtractionMethods() {
setArrays();
// Extract complex from real double array, index 3
- TestUtils.assertSame(new Complex(3), ComplexUtils.extractComplexFromRealArray(d, 3));
+ TestUtils.assertSame(Complex.ofCartesian(3), ComplexUtils.extractComplexFromRealArray(d, 3));
// Extract complex from real float array, index 3
- TestUtils.assertSame(new Complex(3), ComplexUtils.extractComplexFromRealArray(f, 3));
+ TestUtils.assertSame(Complex.ofCartesian(3), ComplexUtils.extractComplexFromRealArray(f, 3));
// Extract real double from complex array, index 3
TestUtils.assertSame(6, ComplexUtils.extractRealFromComplexArray(c, 3));
// Extract real float from complex array, index 3
TestUtils.assertSame(6, ComplexUtils.extractRealFloatFromComplexArray(c, 3));
// Extract complex from interleaved double array, index 3
- TestUtils.assertSame(new Complex(6, 7), ComplexUtils.extractComplexFromInterleavedArray(d, 3));
+ TestUtils.assertSame(Complex.ofCartesian(6, 7), ComplexUtils.extractComplexFromInterleavedArray(d, 3));
// Extract complex from interleaved float array, index 3
- TestUtils.assertSame(new Complex(6, 7), ComplexUtils.extractComplexFromInterleavedArray(f, 3));
+ TestUtils.assertSame(Complex.ofCartesian(6, 7), ComplexUtils.extractComplexFromInterleavedArray(f, 3));
// Extract interleaved double from complex array, index 3
TestUtils.assertEquals(msg, new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c, 3),
Math.ulp(1));
@@ -470,7 +470,7 @@
Complex[] c = new Complex[10];
ComplexUtils.initialize(c);
for (Complex cc : c) {
- TestUtils.assertEquals(new Complex(0, 0), cc, Math.ulp(0));
+ TestUtils.assertEquals(Complex.ofCartesian(0, 0), cc, Math.ulp(0));
}
}
}
