diff --git a/pom.xml b/pom.xml
index 8f633af34..da4b69bb5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -327,6 +327,9 @@
Mauro Talevi
+
+ Rob Tompkins
+
Radoslav Tsvetkov
diff --git a/src/test/java/org/apache/commons/math4/analysis/function/BivariateFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/function/BivariateFunctionTest.java
new file mode 100644
index 000000000..c3fb970c8
--- /dev/null
+++ b/src/test/java/org/apache/commons/math4/analysis/function/BivariateFunctionTest.java
@@ -0,0 +1,44 @@
+/*
+ * 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.analysis.function;
+
+import org.apache.commons.math4.util.FastMath;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test for all uncovered classes in org.apache.commons.math4.analysis.function that implement BivariateFunction explicitly.
+ */
+public class BivariateFunctionTest {
+
+ private static final double EPS = Math.ulp(1d);
+
+ @Test
+ public void testAtan2() {
+ Atan2 atan2 = new Atan2();
+ Assert.assertEquals(FastMath.PI/4,atan2.value(1,1), EPS);
+ }
+
+ @Test
+ public void testSubtract() {
+ Subtract subtract = new Subtract();
+ Assert.assertEquals(5, subtract.value(10,5), EPS);
+ Assert.assertEquals(-5, subtract.value(5,10), EPS);
+ }
+
+}
diff --git a/src/test/java/org/apache/commons/math4/analysis/function/UnivariateDifferentiableFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/function/UnivariateDifferentiableFunctionTest.java
new file mode 100644
index 000000000..5adabb7f2
--- /dev/null
+++ b/src/test/java/org/apache/commons/math4/analysis/function/UnivariateDifferentiableFunctionTest.java
@@ -0,0 +1,227 @@
+/*
+ * 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.analysis.function;
+
+import org.apache.commons.math4.analysis.differentiation.DerivativeStructure;
+import org.apache.commons.math4.util.FastMath;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test for all classes in org.apache.commons.math4.analysis.function that implement UnivariateDifferentiableFunction explicitly.
+ */
+public class UnivariateDifferentiableFunctionTest {
+
+ private static final double EPS = Math.ulp(1d);
+
+ @Test
+ public void testAcos() {
+ Acos acos = new Acos();
+ Assert.assertEquals(FastMath.PI/3, acos.value(0.5), EPS);
+ Assert.assertEquals(FastMath.PI/4, acos.value(Double.valueOf(1/FastMath.sqrt(2))), EPS);
+ double a = 0.5;
+ Assert.assertEquals(-1/FastMath.sqrt(1-FastMath.pow(a,2)), acos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testAcosh() {
+ Acosh acosh = new Acosh();
+ Assert.assertEquals(0,acosh.value(1), EPS);
+ double a = 1.2345;
+ Assert.assertEquals(a,acosh.value(FastMath.cosh(a)), EPS);
+ Assert.assertEquals(1/(FastMath.sqrt(a-1)*FastMath.sqrt(a+1)),acosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testAsin() {
+ Asin asin = new Asin();
+ double a = 1.2345;
+ Assert.assertEquals(a, asin.value(FastMath.sin(a)), EPS);
+ Assert.assertEquals(1/FastMath.sqrt(1 - FastMath.pow(a,2)), asin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testAsinh() {
+ Asinh asinh = new Asinh();
+ double a = 1.2345;
+ Assert.assertEquals(a, asinh.value(FastMath.sinh(a)), EPS);
+ Assert.assertEquals(1/FastMath.sqrt(FastMath.pow(a,2.0) + 1), asinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testAtan() {
+ Atan atan = new Atan();
+ double a = 1.2345;
+ Assert.assertEquals(a, atan.value(FastMath.tan(a)), EPS);
+ Assert.assertEquals(1/(FastMath.pow(a,2.0) + 1), atan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testAtanh() {
+ Atanh atanh = new Atanh();
+ double a = 1.2345;
+ Assert.assertEquals(a, atanh.value(FastMath.tanh(a)), EPS);
+ Assert.assertEquals(1/(1 - FastMath.pow(a,2.0)), atanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testCbrt() {
+ Cbrt cbrt = new Cbrt();
+ double a = 1.2345;
+ Assert.assertEquals(a, cbrt.value(FastMath.pow(a,3)), EPS);
+ Assert.assertEquals(1.0/(3.0*FastMath.pow(a, 2.0/3.0)), cbrt.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testConstant() {
+ double a = 123.456;
+ Constant constantNeg1 = new Constant(-1);
+ Constant constant0 = new Constant(0);
+ Constant constant5 = new Constant(5);
+ Assert.assertEquals(-1, constantNeg1.value(a), EPS);
+ Assert.assertEquals(0, constant0.value(a), EPS);
+ Assert.assertEquals(5, constant5.value(a), EPS);
+ Assert.assertEquals(0, constantNeg1.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(0, constant0.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(0, constant5.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testCos() {
+ Cos cos = new Cos();
+ double a = 0.987;
+ Assert.assertEquals(a, cos.value(FastMath.acos(a)), EPS);
+ Assert.assertEquals(-FastMath.sin(a), cos.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testCosh() {
+ Cosh cosh = new Cosh();
+ double a = 1.2345;
+ Assert.assertEquals(a, cosh.value(FastMath.acosh(a)), EPS);
+ Assert.assertEquals(FastMath.sinh(a), cosh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testExp() {
+ Exp exp= new Exp();
+ double a = 1.2345;
+ Assert.assertEquals(a, exp.value(FastMath.log(a)), EPS);
+ Assert.assertEquals(exp.value(a), exp.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testExpm1() {
+ Expm1 expm1 = new Expm1();
+ double a = 1.2345;
+ Assert.assertEquals(a-1, expm1.value(FastMath.log(a)), EPS);
+ Assert.assertEquals(FastMath.exp(a), expm1.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testIdentity() {
+ Identity identity = new Identity();
+ double a = 123.456;
+ Assert.assertEquals(a, identity.value(a), EPS);
+ Assert.assertEquals(1, identity.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testInverse() {
+ Inverse inverse = new Inverse();
+ double a = 123.456;
+ Assert.assertEquals(1/a, inverse.value(a), EPS);
+ Assert.assertEquals(-1/FastMath.pow(a,2), inverse.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testLog() {
+ double a = 123.456;
+ Log log = new Log();
+ Assert.assertEquals(Math.log(a), log.value(a), EPS);
+ Assert.assertEquals(1/a,log.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testLog10() {
+ Log10 log10 = new Log10();
+ double a =1.2345;
+ Assert.assertEquals(a, log10.value(FastMath.pow(10, a)), EPS);
+ Assert.assertEquals(1/(a*FastMath.log(10)), log10.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testLog1p() {
+ Log1p log1p = new Log1p();
+ double a = 1.2345;
+ Assert.assertEquals(a+1,FastMath.exp(log1p.value(a)), EPS);
+ Assert.assertEquals(1/(1+a), log1p.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testMinus() {
+ Minus minus = new Minus();
+ double a = 123.456;
+ Assert.assertEquals(-a, minus.value(a), EPS);
+ Assert.assertEquals(-1, minus.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testPower() {
+ Power squared = new Power(2);
+ Power power2_5 = new Power(2.5);
+ double a = 123.456;
+ Assert.assertEquals(FastMath.pow(a,2), squared.value(a), EPS);
+ Assert.assertEquals(FastMath.pow(a, 2.5), power2_5.value(a), EPS);
+ Assert.assertEquals(2*a, squared.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ Assert.assertEquals(2.5*FastMath.pow(a,1.5), power2_5.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testSin() {
+ Sin sin = new Sin();
+ double a = 0.987;
+ Assert.assertEquals(a, sin.value(FastMath.asin(a)), EPS);
+ Assert.assertEquals(FastMath.cos(a), sin.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testSinh() {
+ Sinh sinh = new Sinh();
+ double a = 1.2345;
+ Assert.assertEquals(a, sinh.value(FastMath.asinh(a)), EPS);
+ Assert.assertEquals(FastMath.cosh(a), sinh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testTan() {
+ Tan tan = new Tan();
+ double a = 0.987;
+ Assert.assertEquals(a, tan.value(FastMath.atan(a)), EPS);
+ Assert.assertEquals(1/(FastMath.pow(FastMath.cos(a),2)), tan.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+ @Test
+ public void testTanh() {
+ Tanh tanh = new Tanh();
+ double a = 0.987;
+ Assert.assertEquals(a, tanh.value(FastMath.atanh(a)), EPS);
+ Assert.assertEquals(1/FastMath.pow(FastMath.cosh(a),2), tanh.value(new DerivativeStructure(1,1,0,a)).getPartialDerivative(1), EPS);
+ }
+
+}
diff --git a/src/test/java/org/apache/commons/math4/analysis/function/UnivariateFunctionTest.java b/src/test/java/org/apache/commons/math4/analysis/function/UnivariateFunctionTest.java
new file mode 100644
index 000000000..e0e59d274
--- /dev/null
+++ b/src/test/java/org/apache/commons/math4/analysis/function/UnivariateFunctionTest.java
@@ -0,0 +1,124 @@
+/*
+ * 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.analysis.function;
+
+import org.apache.commons.math4.analysis.UnivariateFunction;
+import org.apache.commons.math4.util.FastMath;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test for all classes in org.apache.commons.math4.analysis.function that implement UnivariateFunction explicitly.
+ */
+public class UnivariateFunctionTest {
+
+
+ private final double EPS = Math.ulp(1d);
+
+ @Test
+ public void testAbs() {
+ Abs abs = new Abs();
+ Assert.assertEquals(5, abs.value(-5), EPS);
+ Assert.assertEquals(5, abs.value(5), EPS);
+ Assert.assertEquals(5.123, abs.value(-5.123), EPS);
+ Assert.assertEquals(5.123, abs.value(5.123), EPS);
+ Assert.assertEquals(0, abs.value(0), EPS);
+ }
+
+ @Test
+ public void testCeil() {
+ Ceil ceil = new Ceil();
+ Assert.assertEquals(-5, ceil.value(-5), EPS);
+ Assert.assertEquals(-4, ceil.value(-4.999), EPS);
+ Assert.assertEquals(0, ceil.value(0), EPS);
+ Assert.assertEquals(1, ceil.value(1), EPS);
+ Assert.assertEquals(2, ceil.value(1.000000001), EPS);
+ }
+
+ @Test
+ public void testFloor() {
+ Floor floor = new Floor();
+ Assert.assertEquals(-5, floor.value(-5), EPS);
+ Assert.assertEquals(-5, floor.value(-4.999), EPS);
+ Assert.assertEquals(0, floor.value(0), EPS);
+ Assert.assertEquals(1, floor.value(1), EPS);
+ Assert.assertEquals(1, floor.value(1.000000001), EPS);
+ }
+
+ @Test
+ public void testRint() {
+ //Rint function is round half even.
+ Rint rint = new Rint();
+ Assert.assertEquals(-5, rint.value(-5), EPS);
+ Assert.assertEquals(-4, rint.value(-4.5), EPS);
+ Assert.assertEquals(0, rint.value(0), EPS);
+ Assert.assertEquals(1, rint.value(1), EPS);
+ Assert.assertEquals(2, rint.value(1.5), EPS);
+ Assert.assertEquals(2, rint.value(2.5), EPS);
+ Assert.assertEquals(-1, rint.value(-0.99999999), EPS);
+ Assert.assertEquals(11, rint.value(10.99999999), EPS);
+ }
+
+ @Test
+ public void testSignum() {
+ Signum signum = new Signum();
+ Assert.assertEquals(-1, signum.value(-5), EPS);
+ Assert.assertEquals(-1, signum.value(-4.5), EPS);
+ Assert.assertEquals(0, signum.value(0), EPS);
+ Assert.assertEquals(-0, signum.value(-0), EPS);
+ Assert.assertEquals(1, signum.value(1), EPS);
+ Assert.assertEquals(1, signum.value(1.5), EPS);
+ Assert.assertEquals(1, signum.value(2.5), EPS);
+ Assert.assertEquals(-1, signum.value(-0.99999999), EPS);
+ Assert.assertEquals(1, signum.value(10.99999999), EPS);
+ }
+
+ @Test
+ public void testStepFunction() {
+ final double[] x = { -2, -0.5, 0, 1.9, 7.4, 21.3 };
+ final double[] y = { 4, -1, -5.5, 0.4, 5.8, 51.2 };
+
+ final UnivariateFunction f = new StepFunction(x, y);
+
+ Assert.assertEquals(4, f.value(Double.NEGATIVE_INFINITY), EPS);
+ Assert.assertEquals(4, f.value(-10), EPS);
+ Assert.assertEquals(-1, f.value(-0.4), EPS);
+ Assert.assertEquals(-5.5, f.value(0), EPS);
+ Assert.assertEquals(0.4, f.value(2), EPS);
+ Assert.assertEquals(5.8, f.value(10), EPS);
+ Assert.assertEquals(51.2, f.value(30), EPS);
+ Assert.assertEquals(51.2, f.value(Double.POSITIVE_INFINITY), EPS);
+ }
+
+ @Test
+ public void testUlp() {
+ Ulp ulp = new Ulp();
+ Assert.assertEquals(expectedUlp(1),ulp.value(1), EPS);
+ Assert.assertEquals(expectedUlp(1.123456789),ulp.value(1.123456789), EPS);
+ Assert.assertEquals(expectedUlp(-1),ulp.value(-1), EPS);
+ Assert.assertEquals(expectedUlp(-1.123456789),ulp.value(-1.123456789), EPS);
+ Assert.assertEquals(expectedUlp(0),ulp.value(0), EPS);
+ Assert.assertEquals(expectedUlp(500000000),ulp.value(500000000), EPS);
+ Assert.assertEquals(expectedUlp(-500000000),ulp.value(-500000000), EPS);
+ }
+
+ private double expectedUlp(double x) {
+ return FastMath.abs(x - Double.longBitsToDouble(Double.doubleToRawLongBits(x) ^ 1));
+ }
+
+}
diff --git a/src/test/java/org/apache/commons/math4/complex/ComplexFormatAbstractTest.java b/src/test/java/org/apache/commons/math4/complex/ComplexFormatAbstractTest.java
index 608ccf62e..be7768a10 100644
--- a/src/test/java/org/apache/commons/math4/complex/ComplexFormatAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/complex/ComplexFormatAbstractTest.java
@@ -17,10 +17,15 @@
package org.apache.commons.math4.complex;
+import java.text.FieldPosition;
import java.text.NumberFormat;
import java.text.ParsePosition;
+import java.util.Arrays;
import java.util.Locale;
+import org.apache.commons.math4.exception.MathIllegalArgumentException;
+import org.apache.commons.math4.exception.NoDataException;
+import org.apache.commons.math4.exception.NullArgumentException;
import org.junit.Test;
import org.junit.Assert;
import org.apache.commons.math4.complex.Complex;
@@ -280,6 +285,106 @@ public abstract class ComplexFormatAbstractTest {
Assert.assertEquals(nf, cf.getRealFormat());
}
+ @Test
+ public void testConstructorExceptions() {
+ NumberFormat nullFormat = null;
+ NumberFormat format = NumberFormat.getInstance();
+ try {
+ ComplexFormat cf = new ComplexFormat(nullFormat);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof NullArgumentException);
+ }
+ try {
+ ComplexFormat cf = new ComplexFormat(nullFormat, format);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof NullArgumentException);
+ }
+ try {
+ ComplexFormat cf = new ComplexFormat(format, nullFormat);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof NullArgumentException);
+ }
+ }
+
+ @Test
+ public void testConstructorDoubleFormat() {
+ NumberFormat defaultFormat = NumberFormat.getInstance();
+ NumberFormat numberFormat = NumberFormat.getNumberInstance();
+ ComplexFormat cf = new ComplexFormat(defaultFormat, numberFormat);
+ Assert.assertEquals(defaultFormat, cf.getRealFormat());
+ Assert.assertEquals(numberFormat, cf.getImaginaryFormat());
+ }
+
+ @Test
+ public void testStringConstructor() {
+ String nullString = null;
+ String emptyString = "";
+ String oddImaginaryCharacter = "q";
+ try {
+ ComplexFormat cf = new ComplexFormat(nullString);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof NullArgumentException);
+ }
+ try {
+ ComplexFormat cf = new ComplexFormat(emptyString);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof NoDataException);
+ }
+ ComplexFormat cf = new ComplexFormat(oddImaginaryCharacter);
+ Assert.assertEquals(oddImaginaryCharacter, cf.getImaginaryCharacter());
+ }
+
+ @Test
+ public void testGetAvailableLocales() {
+ Assert.assertEquals(Arrays.asList(NumberFormat.getAvailableLocales()),Arrays.asList(ComplexFormat.getAvailableLocales()));
+ }
+
+ @Test
+ public void testGetInstance() {
+ ComplexFormat cf = ComplexFormat.getInstance();
+ Assert.assertNotNull(cf);
+ Assert.assertNotNull(cf.getRealFormat());
+ Assert.assertNotNull(cf.getImaginaryFormat());
+ Assert.assertTrue(cf.getRealFormat() instanceof NumberFormat);
+ Assert.assertTrue(cf.getImaginaryFormat() instanceof NumberFormat);
+ }
+
+ @Test
+ public void testFormatObjectStringBufferFieldPositionWithComplex() {
+ ComplexFormat cf = ComplexFormat.getInstance();
+ String source = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i";
+ Object expected = new Complex(1.23, 1.43);
+ String formatted = cf.format(expected, new StringBuffer(), new FieldPosition(0)).toString();
+ Assert.assertEquals(source, formatted);
+ }
+
+ @Test
+ public void testFormatObjectStringBufferFieldPositionWitNumber() {
+ ComplexFormat cf = ComplexFormat.getInstance();
+ String source = "1" + getDecimalCharacter() + "23";
+ Number expected = new Double(1.23);
+ String formatted = cf.format(expected, new StringBuffer(), new FieldPosition(0)).toString();
+ Assert.assertEquals(source, formatted);
+ }
+
+ @Test
+ public void testFormatObjectStringBufferFieldPositionException() {
+ ComplexFormat cf = ComplexFormat.getInstance();
+ Object expected = "Something that's not a number or Complex";
+ try {
+ String formatted = cf.format(expected, new StringBuffer(), new FieldPosition(0)).toString();
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof MathIllegalArgumentException);
+ }
+
+ }
+
@Test
public void testGetImaginaryFormat() {
NumberFormat nf = NumberFormat.getInstance();
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/NestedLoopsTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/NestedLoopsTest.java
new file mode 100644
index 000000000..e46008aea
--- /dev/null
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/NestedLoopsTest.java
@@ -0,0 +1,67 @@
+/*
+ * 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.geometry.euclidean.twod;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class NestedLoopsTest {
+
+ private static final double EPS = Math.ulp(1d);
+
+ @Test
+ public void testNestedLoops() throws Exception {
+ Vector2D oneOne = new Vector2D(1.0, 1.0);
+ Vector2D oneNegativeOne = new Vector2D(1.0, -1.0);
+ Vector2D negativeOneNegativeOne = new Vector2D(-1.0, -1.0);
+ Vector2D negativeOneOne = new Vector2D(-1.0, 1.0);
+ Vector2D origin = new Vector2D(0, 0);
+
+ Vector2D [] vertices = new Vector2D[]{
+ oneOne,
+ oneNegativeOne,
+ negativeOneNegativeOne,
+ negativeOneOne,
+ origin
+ };
+
+ NestedLoops nestedLoops = new NestedLoops(0.00000001);
+ nestedLoops.add(vertices);
+ nestedLoops.correctOrientation();
+
+ Field surroundedField = nestedLoops.getClass().getDeclaredField("surrounded");
+ Field loopField = nestedLoops.getClass().getDeclaredField("loop");
+ surroundedField.setAccessible(Boolean.TRUE);
+ loopField.setAccessible(Boolean.TRUE);
+ List surrounded = (List) surroundedField.get(nestedLoops);
+ Vector2D[] loop = (Vector2D []) loopField.get(surrounded.get(0));
+ Set vertexSet = new HashSet<>(Arrays.asList(loop));
+ Assert.assertTrue(vertexSet.contains(oneOne));
+ Assert.assertTrue(vertexSet.contains(oneNegativeOne));
+ Assert.assertTrue(vertexSet.contains(negativeOneNegativeOne));
+ Assert.assertTrue(vertexSet.contains(negativeOneOne));
+ Assert.assertTrue(vertexSet.contains(origin));
+ }
+
+}
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
index ef2c0f781..6692ea678 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
@@ -16,26 +16,224 @@
*/
package org.apache.commons.math4.geometry.euclidean.twod;
-import org.apache.commons.math4.geometry.euclidean.twod.Vector2D;
+import org.apache.commons.math4.exception.DimensionMismatchException;
+import org.apache.commons.math4.exception.MathArithmeticException;
+import org.apache.commons.math4.util.FastMath;
import org.junit.Assert;
import org.junit.Test;
+import java.text.FieldPosition;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+
public class Vector2DTest {
+ private static final double EPS = Math.ulp(1d);
+
+ @Test
+ public void testScaledVectorTripleConstructor() {
+ Vector2D oneOne = new Vector2D(1.0,1.0);
+ Vector2D oneTwo = new Vector2D(1.0,2.0);
+ Vector2D oneThree = new Vector2D(1.0,3.0);
+
+ Vector2D tripleCombo = new Vector2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree);
+
+ Assert.assertEquals(3.0 * 1 + 1.0 * 1 + 2.5 * 1,tripleCombo.getX(), EPS);
+ Assert.assertEquals(3.0 * 1 + 1.0 * 2 + 2.5 * 3,tripleCombo.getY(), EPS);
+ }
+
+ @Test
+ public void testScaledVectorQuadrupleConstructor() {
+ Vector2D oneOne = new Vector2D(1.0, 1.0);
+ Vector2D oneTwo = new Vector2D(1.0, 2.0);
+ Vector2D oneThree = new Vector2D(1.0, 3.0);
+ Vector2D oneFour = new Vector2D(1.0, 4.0);
+
+ Vector2D tripleCombo = new Vector2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree, 2.0, oneFour);
+
+ Assert.assertEquals(3.0 * 1.0 + 1.0 * 1.0 + 2.5 * 1.0 + 2.0 * 1.0,tripleCombo.getX(), EPS);
+ Assert.assertEquals(3.0 * 1.0 + 1.0 * 2.0 + 2.5 * 3.0 + 2.0 * 4.0,tripleCombo.getY(), EPS);
+ }
+
+ @Test
+ public void testConstructorExceptions() {
+ double[] v = new double[] {0.0, 1.0, 2.0};
+ try {
+ new Vector2D(v);
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof DimensionMismatchException);
+ }
+ }
+
+ @Test
+ public void testToArray() {
+ Vector2D oneTwo = new Vector2D(1.0, 2.0);
+ double[] array = oneTwo.toArray();
+ Assert.assertEquals(1.0, array[0], EPS);
+ Assert.assertEquals(2.0, array[1], EPS);
+ }
+
+ @Test
+ public void testGetZero() {
+ Vector2D zero = (new Vector2D(1.0, 1.0)).getZero();
+ Assert.assertEquals(0.0, zero.getX(), EPS);
+ Assert.assertEquals(0.0, zero.getY(), EPS);
+ }
+
+ @Test
+ public void testNorm1() {
+ Vector2D oneTwo = new Vector2D(-1.0, 2.0);
+ Assert.assertEquals(3.0, oneTwo.getNorm1(), EPS);
+ }
+
+ @Test
+ public void testNormSq() {
+ Vector2D oneTwo = new Vector2D(-1.0, 2.0);
+ Assert.assertEquals(5.0, oneTwo.getNormSq(), EPS);
+ }
+
+ @Test
+ public void testNormInf() {
+ Vector2D oneTwo = new Vector2D(-1.0, 2.0);
+ Assert.assertEquals(2.0, oneTwo.getNormInf(), EPS);
+ }
+
+ @Test
+ public void testVectorAddition() {
+ Vector2D minusOneTwo = new Vector2D(-1.0,2.0);
+ Vector2D threeFive = new Vector2D(3.0,5.0);
+ Vector2D addition = minusOneTwo.add(threeFive);
+ Assert.assertEquals(2.0, addition.getX(), EPS);
+ Assert.assertEquals(7.0, addition.getY(), EPS);
+ }
+
+ @Test
+ public void testScaledVectorAddition() {
+ Vector2D minusOneTwo = new Vector2D(-1.0,2.0);
+ Vector2D threeFive = new Vector2D(3.0,5.0);
+ Vector2D addition = minusOneTwo.add(2.0, threeFive);
+ Assert.assertEquals(5.0, addition.getX(), EPS);
+ Assert.assertEquals(12.0, addition.getY(), EPS);
+ }
+
+ @Test
+ public void testVectorSubtraction() {
+ Vector2D minusOneTwo = new Vector2D(-1.0,2.0);
+ Vector2D threeFive = new Vector2D(3.0,5.0);
+ Vector2D addition = minusOneTwo.subtract(threeFive);
+ Assert.assertEquals(-4.0, addition.getX(), EPS);
+ Assert.assertEquals(-3.0, addition.getY(), EPS);
+ }
+
+ @Test
+ public void testScaledVectorSubtraction() {
+ Vector2D minusOneTwo = new Vector2D(-1.0,2.0);
+ Vector2D threeFive = new Vector2D(3.0,5.0);
+ Vector2D addition = minusOneTwo.subtract(2.0, threeFive);
+ Assert.assertEquals(-7.0, addition.getX(), EPS);
+ Assert.assertEquals(-8.0, addition.getY(), EPS);
+ }
+
+ @Test
+ public void testNormalize() {
+ Vector2D minusOneTwo = new Vector2D(-1.0,2.0);
+ Vector2D normalizedMinusOneTwo = minusOneTwo.normalize();
+ Assert.assertEquals(-1.0/FastMath.sqrt(5), normalizedMinusOneTwo.getX(), EPS);
+ Assert.assertEquals(2.0/FastMath.sqrt(5), normalizedMinusOneTwo.getY(), EPS);
+ Vector2D zero = minusOneTwo.getZero();
+ try {
+ zero.normalize();
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof MathArithmeticException);
+ }
+ }
+
+ @Test
+ public void testAngle() {
+ Vector2D oneOne = new Vector2D(1.0, 1.0);
+ try {
+ Vector2D.angle(oneOne.getZero(), oneOne.getZero());
+ }
+ catch (Exception e) {
+ Assert.assertTrue(e instanceof MathArithmeticException);
+ }
+ Vector2D oneZero = new Vector2D(1.0,0.0);
+ double angle = Vector2D.angle(oneOne, oneZero);
+ Assert.assertEquals(FastMath.PI/4, angle, EPS);
+ Assert.assertEquals(0.004999958333958323, Vector2D.angle(new Vector2D(20.0,0.0), new Vector2D(20.0,0.1)), EPS);
+ }
+
+ @Test
+ public void testNegate() {
+ Vector2D oneOne = new Vector2D(1.0,1.0);
+ Vector2D negated = oneOne.negate();
+ Assert.assertEquals(-1.0, negated.getX(), EPS);
+ Assert.assertEquals(-1.0, negated.getY(), EPS);
+ }
+
+ @Test
+ public void testIsInfinite() {
+ Vector2D oneOne = new Vector2D(1.0, 1.0);
+ Vector2D infiniteVector = new Vector2D(Double.POSITIVE_INFINITY, 0.0);
+ Assert.assertFalse(oneOne.isInfinite());
+ Assert.assertTrue(infiniteVector.isInfinite());
+ }
+
+ @Test
+ public void testDistance1() {
+ Vector2D oneOne = new Vector2D(1.0,1.0);
+ Vector2D fiveEleven = new Vector2D(5.0,11.0);
+ double distance1 = oneOne.distance1(fiveEleven);
+ Assert.assertEquals(14.0, distance1, EPS);
+ }
+
+ @Test
+ public void testDistanceInf() {
+ Vector2D oneOne = new Vector2D(1.0,1.0);
+ Vector2D fiveEleven = new Vector2D(5.0,11.0);
+ double distanceInf = oneOne.distanceInf(fiveEleven);
+ double staticDistanceInf = Vector2D.distanceInf(oneOne, fiveEleven);
+ Assert.assertEquals(10.0, distanceInf, EPS);
+ Assert.assertEquals(distanceInf, staticDistanceInf, EPS);
+ }
+
+ @Test
+ public void testDistanceSq() {
+ Vector2D oneFive = new Vector2D(1.0, 5.0);
+ Vector2D fourOne = new Vector2D(4.0, 1.0);
+ double distanceSq = oneFive.distanceSq(fourOne);
+ double staticDistanceSq = Vector2D.distanceSq(oneFive, fourOne);
+ Assert.assertEquals(25.0, distanceSq, EPS);
+ Assert.assertEquals(distanceSq, staticDistanceSq, EPS);
+ }
+
+ @Test
+ public void testHashCode() {
+ int hashCode = (new Vector2D(1.0,1.0)).hashCode();
+ Assert.assertEquals(887095296, hashCode);
+ Assert.assertEquals(542, (new Vector2D(Double.NaN, Double.NaN)).hashCode());
+ }
+
+
+ @Test
+ public void testToString() {
+ Assert.assertEquals("{1; 2}", (new Vector2D(1.0,2.0)).toString());
+ }
+
@Test
public void testCrossProduct() {
- final double epsilon = 1e-10;
-
Vector2D p1 = new Vector2D(1, 1);
Vector2D p2 = new Vector2D(2, 2);
Vector2D p3 = new Vector2D(3, 3);
- Assert.assertEquals(0.0, p3.crossProduct(p1, p2), epsilon);
+ Assert.assertEquals(0.0, p3.crossProduct(p1, p2), EPS);
Vector2D p4 = new Vector2D(1, 2);
- Assert.assertEquals(1.0, p4.crossProduct(p1, p2), epsilon);
+ Assert.assertEquals(1.0, p4.crossProduct(p1, p2), EPS);
Vector2D p5 = new Vector2D(2, 1);
- Assert.assertEquals(-1.0, p5.crossProduct(p1, p2), epsilon);
+ Assert.assertEquals(-1.0, p5.crossProduct(p1, p2), EPS);
}
}