Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 855D6200C72 for ; Fri, 12 May 2017 23:32:13 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 83E77160BCF; Fri, 12 May 2017 21:32:13 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id D2CAC160BA8 for ; Fri, 12 May 2017 23:32:11 +0200 (CEST) Received: (qmail 16488 invoked by uid 500); 12 May 2017 21:32:10 -0000 Mailing-List: contact commits-help@commons.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commons.apache.org Delivered-To: mailing list commits@commons.apache.org Received: (qmail 16463 invoked by uid 99); 12 May 2017 21:32:10 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 12 May 2017 21:32:10 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 37911DFAB4; Fri, 12 May 2017 21:32:10 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: raydecampo@apache.org To: commits@commons.apache.org Date: Fri, 12 May 2017 21:32:13 -0000 Message-Id: <3f2eef618d854e6eaeefb94e4c9a1e5e@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [04/31] [math] MATH-1284: Vector no longer extends Point. Replace/rename Vector?D classes with Coordinate?D classes which implement both Vector and Point. When there are multiple implementations of the same method which would confuse the compiler, prefer archived-at: Fri, 12 May 2017 21:32:13 -0000 http://git-wip-us.apache.org/repos/asf/commons-math/blob/b815d2af/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/Vector3DTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/Vector3DTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/Vector3DTest.java index dbf1b3e..296ade8 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/Vector3DTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/Vector3DTest.java @@ -27,7 +27,7 @@ import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathArithmeticException; import org.apache.commons.math4.geometry.Space; import org.apache.commons.math4.geometry.euclidean.threed.Rotation; -import org.apache.commons.math4.geometry.euclidean.threed.Vector3D; +import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; import org.apache.commons.math4.util.FastMath; @@ -39,27 +39,27 @@ public class Vector3DTest { @Test public void testConstructors() throws DimensionMismatchException { double r = FastMath.sqrt(2) /2; - checkVector(new Vector3D(2, new Vector3D(FastMath.PI / 3, -FastMath.PI / 4)), + checkVector(new Coordinates3D(2, new Coordinates3D(FastMath.PI / 3, -FastMath.PI / 4)), r, r * FastMath.sqrt(3), -2 * r); - checkVector(new Vector3D(2, Vector3D.PLUS_I, - -3, Vector3D.MINUS_K), + checkVector(new Coordinates3D(2, Coordinates3D.PLUS_I, + -3, Coordinates3D.MINUS_K), 2, 0, 3); - checkVector(new Vector3D(2, Vector3D.PLUS_I, - 5, Vector3D.PLUS_J, - -3, Vector3D.MINUS_K), + checkVector(new Coordinates3D(2, Coordinates3D.PLUS_I, + 5, Coordinates3D.PLUS_J, + -3, Coordinates3D.MINUS_K), 2, 5, 3); - checkVector(new Vector3D(2, Vector3D.PLUS_I, - 5, Vector3D.PLUS_J, - 5, Vector3D.MINUS_J, - -3, Vector3D.MINUS_K), + checkVector(new Coordinates3D(2, Coordinates3D.PLUS_I, + 5, Coordinates3D.PLUS_J, + 5, Coordinates3D.MINUS_J, + -3, Coordinates3D.MINUS_K), 2, 0, 3); - checkVector(new Vector3D(new double[] { 2, 5, -3 }), + checkVector(new Coordinates3D(new double[] { 2, 5, -3 }), 2, 5, -3); } @Test public void testSpace() { - Space space = new Vector3D(1, 2, 2).getSpace(); + Space space = new Coordinates3D(1, 2, 2).getSpace(); Assert.assertEquals(3, space.getDimension()); Assert.assertEquals(2, space.getSubSpace().getDimension()); Space deserialized = (Space) TestUtils.serializeAndRecover(space); @@ -68,63 +68,63 @@ public class Vector3DTest { @Test public void testZero() { - Assert.assertEquals(0, new Vector3D(1, 2, 2).getZero().getNorm(), 1.0e-15); + Assert.assertEquals(0, new Coordinates3D(1, 2, 2).getZero().getNorm(), 1.0e-15); } @Test public void testEquals() { - Vector3D u1 = new Vector3D(1, 2, 3); - Vector3D u2 = new Vector3D(1, 2, 3); + Coordinates3D u1 = new Coordinates3D(1, 2, 3); + Coordinates3D u2 = new Coordinates3D(1, 2, 3); Assert.assertTrue(u1.equals(u1)); Assert.assertTrue(u1.equals(u2)); Assert.assertFalse(u1.equals(new Rotation(1, 0, 0, 0, false))); - Assert.assertFalse(u1.equals(new Vector3D(1, 2, 3 + 10 * Precision.EPSILON))); - Assert.assertFalse(u1.equals(new Vector3D(1, 2 + 10 * Precision.EPSILON, 3))); - Assert.assertFalse(u1.equals(new Vector3D(1 + 10 * Precision.EPSILON, 2, 3))); - Assert.assertTrue(new Vector3D(0, Double.NaN, 0).equals(new Vector3D(0, 0, Double.NaN))); + Assert.assertFalse(u1.equals(new Coordinates3D(1, 2, 3 + 10 * Precision.EPSILON))); + Assert.assertFalse(u1.equals(new Coordinates3D(1, 2 + 10 * Precision.EPSILON, 3))); + Assert.assertFalse(u1.equals(new Coordinates3D(1 + 10 * Precision.EPSILON, 2, 3))); + Assert.assertTrue(new Coordinates3D(0, Double.NaN, 0).equals(new Coordinates3D(0, 0, Double.NaN))); } @Test public void testHash() { - Assert.assertEquals(new Vector3D(0, Double.NaN, 0).hashCode(), new Vector3D(0, 0, Double.NaN).hashCode()); - Vector3D u = new Vector3D(1, 2, 3); - Vector3D v = new Vector3D(1, 2, 3 + 10 * Precision.EPSILON); + Assert.assertEquals(new Coordinates3D(0, Double.NaN, 0).hashCode(), new Coordinates3D(0, 0, Double.NaN).hashCode()); + Coordinates3D u = new Coordinates3D(1, 2, 3); + Coordinates3D v = new Coordinates3D(1, 2, 3 + 10 * Precision.EPSILON); Assert.assertTrue(u.hashCode() != v.hashCode()); } @Test public void testInfinite() { - Assert.assertTrue(new Vector3D(1, 1, Double.NEGATIVE_INFINITY).isInfinite()); - Assert.assertTrue(new Vector3D(1, Double.NEGATIVE_INFINITY, 1).isInfinite()); - Assert.assertTrue(new Vector3D(Double.NEGATIVE_INFINITY, 1, 1).isInfinite()); - Assert.assertFalse(new Vector3D(1, 1, 2).isInfinite()); - Assert.assertFalse(new Vector3D(1, Double.NaN, Double.NEGATIVE_INFINITY).isInfinite()); + Assert.assertTrue(new Coordinates3D(1, 1, Double.NEGATIVE_INFINITY).isInfinite()); + Assert.assertTrue(new Coordinates3D(1, Double.NEGATIVE_INFINITY, 1).isInfinite()); + Assert.assertTrue(new Coordinates3D(Double.NEGATIVE_INFINITY, 1, 1).isInfinite()); + Assert.assertFalse(new Coordinates3D(1, 1, 2).isInfinite()); + Assert.assertFalse(new Coordinates3D(1, Double.NaN, Double.NEGATIVE_INFINITY).isInfinite()); } @Test public void testNaN() { - Assert.assertTrue(new Vector3D(1, 1, Double.NaN).isNaN()); - Assert.assertTrue(new Vector3D(1, Double.NaN, 1).isNaN()); - Assert.assertTrue(new Vector3D(Double.NaN, 1, 1).isNaN()); - Assert.assertFalse(new Vector3D(1, 1, 2).isNaN()); - Assert.assertFalse(new Vector3D(1, 1, Double.NEGATIVE_INFINITY).isNaN()); + Assert.assertTrue(new Coordinates3D(1, 1, Double.NaN).isNaN()); + Assert.assertTrue(new Coordinates3D(1, Double.NaN, 1).isNaN()); + Assert.assertTrue(new Coordinates3D(Double.NaN, 1, 1).isNaN()); + Assert.assertFalse(new Coordinates3D(1, 1, 2).isNaN()); + Assert.assertFalse(new Coordinates3D(1, 1, Double.NEGATIVE_INFINITY).isNaN()); } @Test public void testToString() { - Assert.assertEquals("{3; 2; 1}", new Vector3D(3, 2, 1).toString()); + Assert.assertEquals("{3; 2; 1}", new Coordinates3D(3, 2, 1).toString()); NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US)); - Assert.assertEquals("{3.000; 2.000; 1.000}", new Vector3D(3, 2, 1).toString(format)); + Assert.assertEquals("{3.000; 2.000; 1.000}", new Coordinates3D(3, 2, 1).toString(format)); } @Test(expected=DimensionMismatchException.class) public void testWrongDimension() throws DimensionMismatchException { - new Vector3D(new double[] { 2, 5 }); + new Coordinates3D(new double[] { 2, 5 }); } @Test public void testCoordinates() { - Vector3D v = new Vector3D(1, 2, 3); + Coordinates3D v = new Coordinates3D(1, 2, 3); Assert.assertTrue(FastMath.abs(v.getX() - 1) < 1.0e-12); Assert.assertTrue(FastMath.abs(v.getY() - 2) < 1.0e-12); Assert.assertTrue(FastMath.abs(v.getZ() - 3) < 1.0e-12); @@ -136,69 +136,69 @@ public class Vector3DTest { @Test public void testNorm1() { - Assert.assertEquals(0.0, Vector3D.ZERO.getNorm1(), 0); - Assert.assertEquals(6.0, new Vector3D(1, -2, 3).getNorm1(), 0); + Assert.assertEquals(0.0, Coordinates3D.ZERO.getNorm1(), 0); + Assert.assertEquals(6.0, new Coordinates3D(1, -2, 3).getNorm1(), 0); } @Test public void testNorm() { - Assert.assertEquals(0.0, Vector3D.ZERO.getNorm(), 0); - Assert.assertEquals(FastMath.sqrt(14), new Vector3D(1, 2, 3).getNorm(), 1.0e-12); + Assert.assertEquals(0.0, Coordinates3D.ZERO.getNorm(), 0); + Assert.assertEquals(FastMath.sqrt(14), new Coordinates3D(1, 2, 3).getNorm(), 1.0e-12); } @Test public void testNormSq() { - Assert.assertEquals(0.0, new Vector3D(0, 0, 0).getNormSq(), 0); - Assert.assertEquals(14, new Vector3D(1, 2, 3).getNormSq(), 1.0e-12); + Assert.assertEquals(0.0, new Coordinates3D(0, 0, 0).getNormSq(), 0); + Assert.assertEquals(14, new Coordinates3D(1, 2, 3).getNormSq(), 1.0e-12); } @Test public void testNormInf() { - Assert.assertEquals(0.0, Vector3D.ZERO.getNormInf(), 0); - Assert.assertEquals(3.0, new Vector3D(1, -2, 3).getNormInf(), 0); + Assert.assertEquals(0.0, Coordinates3D.ZERO.getNormInf(), 0); + Assert.assertEquals(3.0, new Coordinates3D(1, -2, 3).getNormInf(), 0); } @Test public void testDistance1() { - Vector3D v1 = new Vector3D(1, -2, 3); - Vector3D v2 = new Vector3D(-4, 2, 0); - Assert.assertEquals(0.0, Vector3D.distance1(Vector3D.MINUS_I, Vector3D.MINUS_I), 0); - Assert.assertEquals(12.0, Vector3D.distance1(v1, v2), 1.0e-12); - Assert.assertEquals(v1.subtract(v2).getNorm1(), Vector3D.distance1(v1, v2), 1.0e-12); + Coordinates3D v1 = new Coordinates3D(1, -2, 3); + Coordinates3D v2 = new Coordinates3D(-4, 2, 0); + Assert.assertEquals(0.0, Coordinates3D.distance1(Coordinates3D.MINUS_I, Coordinates3D.MINUS_I), 0); + Assert.assertEquals(12.0, Coordinates3D.distance1(v1, v2), 1.0e-12); + Assert.assertEquals(v1.subtract(v2).getNorm1(), Coordinates3D.distance1(v1, v2), 1.0e-12); } @Test public void testDistance() { - Vector3D v1 = new Vector3D(1, -2, 3); - Vector3D v2 = new Vector3D(-4, 2, 0); - Assert.assertEquals(0.0, Vector3D.distance(Vector3D.MINUS_I, Vector3D.MINUS_I), 0); - Assert.assertEquals(FastMath.sqrt(50), Vector3D.distance(v1, v2), 1.0e-12); - Assert.assertEquals(v1.subtract(v2).getNorm(), Vector3D.distance(v1, v2), 1.0e-12); + Coordinates3D v1 = new Coordinates3D(1, -2, 3); + Coordinates3D v2 = new Coordinates3D(-4, 2, 0); + Assert.assertEquals(0.0, Coordinates3D.distance(Coordinates3D.MINUS_I, Coordinates3D.MINUS_I), 0); + Assert.assertEquals(FastMath.sqrt(50), Coordinates3D.distance(v1, v2), 1.0e-12); + Assert.assertEquals(v1.subtract(v2).getNorm(), Coordinates3D.distance(v1, v2), 1.0e-12); } @Test public void testDistanceSq() { - Vector3D v1 = new Vector3D(1, -2, 3); - Vector3D v2 = new Vector3D(-4, 2, 0); - Assert.assertEquals(0.0, Vector3D.distanceSq(Vector3D.MINUS_I, Vector3D.MINUS_I), 0); - Assert.assertEquals(50.0, Vector3D.distanceSq(v1, v2), 1.0e-12); - Assert.assertEquals(Vector3D.distance(v1, v2) * Vector3D.distance(v1, v2), - Vector3D.distanceSq(v1, v2), 1.0e-12); + Coordinates3D v1 = new Coordinates3D(1, -2, 3); + Coordinates3D v2 = new Coordinates3D(-4, 2, 0); + Assert.assertEquals(0.0, Coordinates3D.distanceSq(Coordinates3D.MINUS_I, Coordinates3D.MINUS_I), 0); + Assert.assertEquals(50.0, Coordinates3D.distanceSq(v1, v2), 1.0e-12); + Assert.assertEquals(Coordinates3D.distance(v1, v2) * Coordinates3D.distance(v1, v2), + Coordinates3D.distanceSq(v1, v2), 1.0e-12); } @Test public void testDistanceInf() { - Vector3D v1 = new Vector3D(1, -2, 3); - Vector3D v2 = new Vector3D(-4, 2, 0); - Assert.assertEquals(0.0, Vector3D.distanceInf(Vector3D.MINUS_I, Vector3D.MINUS_I), 0); - Assert.assertEquals(5.0, Vector3D.distanceInf(v1, v2), 1.0e-12); - Assert.assertEquals(v1.subtract(v2).getNormInf(), Vector3D.distanceInf(v1, v2), 1.0e-12); + Coordinates3D v1 = new Coordinates3D(1, -2, 3); + Coordinates3D v2 = new Coordinates3D(-4, 2, 0); + Assert.assertEquals(0.0, Coordinates3D.distanceInf(Coordinates3D.MINUS_I, Coordinates3D.MINUS_I), 0); + Assert.assertEquals(5.0, Coordinates3D.distanceInf(v1, v2), 1.0e-12); + Assert.assertEquals(v1.subtract(v2).getNormInf(), Coordinates3D.distanceInf(v1, v2), 1.0e-12); } @Test public void testSubtract() { - Vector3D v1 = new Vector3D(1, 2, 3); - Vector3D v2 = new Vector3D(-3, -2, -1); + Coordinates3D v1 = new Coordinates3D(1, 2, 3); + Coordinates3D v2 = new Coordinates3D(-3, -2, -1); v1 = v1.subtract(v2); checkVector(v1, 4, 4, 4); @@ -208,8 +208,8 @@ public class Vector3DTest { @Test public void testAdd() { - Vector3D v1 = new Vector3D(1, 2, 3); - Vector3D v2 = new Vector3D(-3, -2, -1); + Coordinates3D v1 = new Coordinates3D(1, 2, 3); + Coordinates3D v2 = new Coordinates3D(-3, -2, -1); v1 = v1.add(v2); checkVector(v1, -2, 0, 2); @@ -219,7 +219,7 @@ public class Vector3DTest { @Test public void testScalarProduct() { - Vector3D v = new Vector3D(1, 2, 3); + Coordinates3D v = new Coordinates3D(1, 2, 3); v = v.scalarMultiply(3); checkVector(v, 3, 6, 9); @@ -228,61 +228,61 @@ public class Vector3DTest { @Test public void testVectorialProducts() { - Vector3D v1 = new Vector3D(2, 1, -4); - Vector3D v2 = new Vector3D(3, 1, -1); + Coordinates3D v1 = new Coordinates3D(2, 1, -4); + Coordinates3D v2 = new Coordinates3D(3, 1, -1); - Assert.assertTrue(FastMath.abs(Vector3D.dotProduct(v1, v2) - 11) < 1.0e-12); + Assert.assertTrue(FastMath.abs(Coordinates3D.dotProduct(v1, v2) - 11) < 1.0e-12); - Vector3D v3 = Vector3D.crossProduct(v1, v2); + Coordinates3D v3 = Coordinates3D.crossProduct(v1, v2); checkVector(v3, 3, -10, -1); - Assert.assertTrue(FastMath.abs(Vector3D.dotProduct(v1, v3)) < 1.0e-12); - Assert.assertTrue(FastMath.abs(Vector3D.dotProduct(v2, v3)) < 1.0e-12); + Assert.assertTrue(FastMath.abs(Coordinates3D.dotProduct(v1, v3)) < 1.0e-12); + Assert.assertTrue(FastMath.abs(Coordinates3D.dotProduct(v2, v3)) < 1.0e-12); } @Test public void testCrossProductCancellation() { - Vector3D v1 = new Vector3D(9070467121.0, 4535233560.0, 1); - Vector3D v2 = new Vector3D(9070467123.0, 4535233561.0, 1); - checkVector(Vector3D.crossProduct(v1, v2), -1, 2, 1); + Coordinates3D v1 = new Coordinates3D(9070467121.0, 4535233560.0, 1); + Coordinates3D v2 = new Coordinates3D(9070467123.0, 4535233561.0, 1); + checkVector(Coordinates3D.crossProduct(v1, v2), -1, 2, 1); double scale = FastMath.scalb(1.0, 100); - Vector3D big1 = new Vector3D(scale, v1); - Vector3D small2 = new Vector3D(1 / scale, v2); - checkVector(Vector3D.crossProduct(big1, small2), -1, 2, 1); + Coordinates3D big1 = new Coordinates3D(scale, v1); + Coordinates3D small2 = new Coordinates3D(1 / scale, v2); + checkVector(Coordinates3D.crossProduct(big1, small2), -1, 2, 1); } @Test public void testAngular() { - Assert.assertEquals(0, Vector3D.PLUS_I.getAlpha(), 1.0e-10); - Assert.assertEquals(0, Vector3D.PLUS_I.getDelta(), 1.0e-10); - Assert.assertEquals(FastMath.PI / 2, Vector3D.PLUS_J.getAlpha(), 1.0e-10); - Assert.assertEquals(0, Vector3D.PLUS_J.getDelta(), 1.0e-10); - Assert.assertEquals(0, Vector3D.PLUS_K.getAlpha(), 1.0e-10); - Assert.assertEquals(FastMath.PI / 2, Vector3D.PLUS_K.getDelta(), 1.0e-10); - - Vector3D u = new Vector3D(-1, 1, -1); + Assert.assertEquals(0, Coordinates3D.PLUS_I.getAlpha(), 1.0e-10); + Assert.assertEquals(0, Coordinates3D.PLUS_I.getDelta(), 1.0e-10); + Assert.assertEquals(FastMath.PI / 2, Coordinates3D.PLUS_J.getAlpha(), 1.0e-10); + Assert.assertEquals(0, Coordinates3D.PLUS_J.getDelta(), 1.0e-10); + Assert.assertEquals(0, Coordinates3D.PLUS_K.getAlpha(), 1.0e-10); + Assert.assertEquals(FastMath.PI / 2, Coordinates3D.PLUS_K.getDelta(), 1.0e-10); + + Coordinates3D u = new Coordinates3D(-1, 1, -1); Assert.assertEquals(3 * FastMath.PI /4, u.getAlpha(), 1.0e-10); Assert.assertEquals(-1.0 / FastMath.sqrt(3), FastMath.sin(u.getDelta()), 1.0e-10); } @Test public void testAngularSeparation() throws MathArithmeticException { - Vector3D v1 = new Vector3D(2, -1, 4); + Coordinates3D v1 = new Coordinates3D(2, -1, 4); - Vector3D k = v1.normalize(); - Vector3D i = k.orthogonal(); - Vector3D v2 = k.scalarMultiply(FastMath.cos(1.2)).add(i.scalarMultiply(FastMath.sin(1.2))); + Coordinates3D k = v1.normalize(); + Coordinates3D i = k.orthogonal(); + Coordinates3D v2 = k.scalarMultiply(FastMath.cos(1.2)).add(i.scalarMultiply(FastMath.sin(1.2))); - Assert.assertTrue(FastMath.abs(Vector3D.angle(v1, v2) - 1.2) < 1.0e-12); + Assert.assertTrue(FastMath.abs(Coordinates3D.angle(v1, v2) - 1.2) < 1.0e-12); } @Test public void testNormalize() throws MathArithmeticException { - Assert.assertEquals(1.0, new Vector3D(5, -4, 2).normalize().getNorm(), 1.0e-12); + Assert.assertEquals(1.0, new Coordinates3D(5, -4, 2).normalize().getNorm(), 1.0e-12); try { - Vector3D.ZERO.normalize(); + Coordinates3D.ZERO.normalize(); Assert.fail("an exception should have been thrown"); } catch (MathArithmeticException ae) { // expected behavior @@ -291,21 +291,21 @@ public class Vector3DTest { @Test public void testNegate() { - checkVector(new Vector3D(0.1, 2.5, 1.3).negate(), -0.1, -2.5, -1.3); + checkVector(new Coordinates3D(0.1, 2.5, 1.3).negate(), -0.1, -2.5, -1.3); } @Test public void testOrthogonal() throws MathArithmeticException { - Vector3D v1 = new Vector3D(0.1, 2.5, 1.3); - Assert.assertEquals(0.0, Vector3D.dotProduct(v1, v1.orthogonal()), 1.0e-12); - Vector3D v2 = new Vector3D(2.3, -0.003, 7.6); - Assert.assertEquals(0.0, Vector3D.dotProduct(v2, v2.orthogonal()), 1.0e-12); - Vector3D v3 = new Vector3D(-1.7, 1.4, 0.2); - Assert.assertEquals(0.0, Vector3D.dotProduct(v3, v3.orthogonal()), 1.0e-12); - Vector3D v4 = new Vector3D(4.2, 0.1, -1.8); - Assert.assertEquals(0.0, Vector3D.dotProduct(v4, v4.orthogonal()), 1.0e-12); + Coordinates3D v1 = new Coordinates3D(0.1, 2.5, 1.3); + Assert.assertEquals(0.0, Coordinates3D.dotProduct(v1, v1.orthogonal()), 1.0e-12); + Coordinates3D v2 = new Coordinates3D(2.3, -0.003, 7.6); + Assert.assertEquals(0.0, Coordinates3D.dotProduct(v2, v2.orthogonal()), 1.0e-12); + Coordinates3D v3 = new Coordinates3D(-1.7, 1.4, 0.2); + Assert.assertEquals(0.0, Coordinates3D.dotProduct(v3, v3.orthogonal()), 1.0e-12); + Coordinates3D v4 = new Coordinates3D(4.2, 0.1, -1.8); + Assert.assertEquals(0.0, Coordinates3D.dotProduct(v4, v4.orthogonal()), 1.0e-12); try { - new Vector3D(0, 0, 0).orthogonal(); + new Coordinates3D(0, 0, 0).orthogonal(); Assert.fail("an exception should have been thrown"); } catch (MathArithmeticException ae) { // expected behavior @@ -314,16 +314,16 @@ public class Vector3DTest { @Test public void testAngle() throws MathArithmeticException { Assert.assertEquals(0.22572612855273393616, - Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(4, 5, 6)), + Coordinates3D.angle(new Coordinates3D(1, 2, 3), new Coordinates3D(4, 5, 6)), 1.0e-12); Assert.assertEquals(7.98595620686106654517199e-8, - Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(2, 4, 6.000001)), + Coordinates3D.angle(new Coordinates3D(1, 2, 3), new Coordinates3D(2, 4, 6.000001)), 1.0e-12); Assert.assertEquals(3.14159257373023116985197793156, - Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(-2, -4, -6.000001)), + Coordinates3D.angle(new Coordinates3D(1, 2, 3), new Coordinates3D(-2, -4, -6.000001)), 1.0e-12); try { - Vector3D.angle(Vector3D.ZERO, Vector3D.PLUS_I); + Coordinates3D.angle(Coordinates3D.ZERO, Coordinates3D.PLUS_I); Assert.fail("an exception should have been thrown"); } catch (MathArithmeticException ae) { // expected behavior @@ -335,10 +335,10 @@ public class Vector3DTest { // the following two vectors are nearly but not exactly orthogonal // naive dot product (i.e. computing u1.x * u2.x + u1.y * u2.y + u1.z * u2.z // leads to a result of 0.0, instead of the correct -1.855129... - Vector3D u1 = new Vector3D(-1321008684645961.0 / 268435456.0, + Coordinates3D u1 = new Coordinates3D(-1321008684645961.0 / 268435456.0, -5774608829631843.0 / 268435456.0, -7645843051051357.0 / 8589934592.0); - Vector3D u2 = new Vector3D(-5712344449280879.0 / 2097152.0, + Coordinates3D u2 = new Coordinates3D(-5712344449280879.0 / 2097152.0, -4550117129121957.0 / 2097152.0, 8846951984510141.0 / 131072.0); double sNaive = u1.getX() * u2.getX() + u1.getY() * u2.getY() + u1.getZ() * u2.getZ(); @@ -360,7 +360,7 @@ public class Vector3DTest { double vy = 10000 * random.nextDouble(); double vz = 10000 * random.nextDouble(); double sNaive = ux * vx + uy * vy + uz * vz; - double sAccurate = new Vector3D(ux, uy, uz).dotProduct(new Vector3D(vx, vy, vz)); + double sAccurate = new Coordinates3D(ux, uy, uz).dotProduct(new Coordinates3D(vx, vy, vz)); Assert.assertEquals(sNaive, sAccurate, 2.5e-16 * sAccurate); } } @@ -372,19 +372,19 @@ public class Vector3DTest { // computing u1.x * u2.x + u1.y * u2.y + u1.z * u2.z // leads to a result of [0.0009765, -0.0001220, -0.0039062], // instead of the correct [0.0006913, -0.0001254, -0.0007909] - final Vector3D u1 = new Vector3D(-1321008684645961.0 / 268435456.0, + final Coordinates3D u1 = new Coordinates3D(-1321008684645961.0 / 268435456.0, -5774608829631843.0 / 268435456.0, -7645843051051357.0 / 8589934592.0); - final Vector3D u2 = new Vector3D( 1796571811118507.0 / 2147483648.0, + final Coordinates3D u2 = new Coordinates3D( 1796571811118507.0 / 2147483648.0, 7853468008299307.0 / 2147483648.0, 2599586637357461.0 / 17179869184.0); - final Vector3D u3 = new Vector3D(12753243807587107.0 / 18446744073709551616.0, + final Coordinates3D u3 = new Coordinates3D(12753243807587107.0 / 18446744073709551616.0, -2313766922703915.0 / 18446744073709551616.0, -227970081415313.0 / 288230376151711744.0); - Vector3D cNaive = new Vector3D(u1.getY() * u2.getZ() - u1.getZ() * u2.getY(), + Coordinates3D cNaive = new Coordinates3D(u1.getY() * u2.getZ() - u1.getZ() * u2.getY(), u1.getZ() * u2.getX() - u1.getX() * u2.getZ(), u1.getX() * u2.getY() - u1.getY() * u2.getX()); - Vector3D cAccurate = u1.crossProduct(u2); + Coordinates3D cAccurate = u1.crossProduct(u2); Assert.assertTrue(u3.distance(cNaive) > 2.9 * u3.getNorm()); Assert.assertEquals(0.0, u3.distance(cAccurate), 1.0e-30 * cAccurate.getNorm()); } @@ -401,13 +401,13 @@ public class Vector3DTest { double vx = 10000 * random.nextDouble(); double vy = 10000 * random.nextDouble(); double vz = 10000 * random.nextDouble(); - Vector3D cNaive = new Vector3D(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx); - Vector3D cAccurate = new Vector3D(ux, uy, uz).crossProduct(new Vector3D(vx, vy, vz)); + Coordinates3D cNaive = new Coordinates3D(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx); + Coordinates3D cAccurate = new Coordinates3D(ux, uy, uz).crossProduct(new Coordinates3D(vx, vy, vz)); Assert.assertEquals(0.0, cAccurate.distance(cNaive), 6.0e-15 * cAccurate.getNorm()); } } - private void checkVector(Vector3D v, double x, double y, double z) { + private void checkVector(Coordinates3D v, double x, double y, double z) { Assert.assertEquals(x, v.getX(), 1.0e-12); Assert.assertEquals(y, v.getY(), 1.0e-12); Assert.assertEquals(z, v.getZ(), 1.0e-12); http://git-wip-us.apache.org/repos/asf/commons-math/blob/b815d2af/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/DiskGeneratorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/DiskGeneratorTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/DiskGeneratorTest.java index 4f15610..841a87c 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/DiskGeneratorTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/DiskGeneratorTest.java @@ -23,7 +23,7 @@ import java.util.List; import org.apache.commons.math4.geometry.enclosing.EnclosingBall; import org.apache.commons.math4.geometry.euclidean.twod.DiskGenerator; import org.apache.commons.math4.geometry.euclidean.twod.Euclidean2D; -import org.apache.commons.math4.geometry.euclidean.twod.Vector2D; +import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; import org.apache.commons.math4.random.UnitSphereRandomVectorGenerator; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; @@ -35,8 +35,8 @@ public class DiskGeneratorTest { @Test public void testSupport0Point() { - List support = Arrays.asList(new Vector2D[0]); - EnclosingBall disk = new DiskGenerator().ballOnSupport(support); + List support = Arrays.asList(new Coordinates2D[0]); + EnclosingBall disk = new DiskGenerator().ballOnSupport(support); Assert.assertTrue(disk.getRadius() < 0); Assert.assertEquals(0, disk.getSupportSize()); Assert.assertEquals(0, disk.getSupport().length); @@ -44,15 +44,15 @@ public class DiskGeneratorTest { @Test public void testSupport1Point() { - List support = Arrays.asList(new Vector2D(1, 2)); - EnclosingBall disk = new DiskGenerator().ballOnSupport(support); + List support = Arrays.asList(new Coordinates2D(1, 2)); + EnclosingBall disk = new DiskGenerator().ballOnSupport(support); Assert.assertEquals(0.0, disk.getRadius(), 1.0e-10); Assert.assertTrue(disk.contains(support.get(0))); Assert.assertTrue(disk.contains(support.get(0), 0.5)); - Assert.assertFalse(disk.contains(new Vector2D(support.get(0).getX() + 0.1, + Assert.assertFalse(disk.contains(new Coordinates2D(support.get(0).getX() + 0.1, support.get(0).getY() - 0.1), 0.001)); - Assert.assertTrue(disk.contains(new Vector2D(support.get(0).getX() + 0.1, + Assert.assertTrue(disk.contains(new Coordinates2D(support.get(0).getX() + 0.1, support.get(0).getY() - 0.1), 0.5)); Assert.assertEquals(0, support.get(0).distance(disk.getCenter()), 1.0e-10); @@ -62,41 +62,41 @@ public class DiskGeneratorTest { @Test public void testSupport2Points() { - List support = Arrays.asList(new Vector2D(1, 0), - new Vector2D(3, 0)); - EnclosingBall disk = new DiskGenerator().ballOnSupport(support); + List support = Arrays.asList(new Coordinates2D(1, 0), + new Coordinates2D(3, 0)); + EnclosingBall disk = new DiskGenerator().ballOnSupport(support); Assert.assertEquals(1.0, disk.getRadius(), 1.0e-10); int i = 0; - for (Vector2D v : support) { + for (Coordinates2D v : support) { Assert.assertTrue(disk.contains(v)); Assert.assertEquals(1.0, v.distance(disk.getCenter()), 1.0e-10); Assert.assertTrue(v == disk.getSupport()[i++]); } - Assert.assertTrue(disk.contains(new Vector2D(2, 0.9))); - Assert.assertFalse(disk.contains(Vector2D.ZERO)); - Assert.assertEquals(0.0, new Vector2D(2, 0).distance(disk.getCenter()), 1.0e-10); + Assert.assertTrue(disk.contains(new Coordinates2D(2, 0.9))); + Assert.assertFalse(disk.contains(Coordinates2D.ZERO)); + Assert.assertEquals(0.0, new Coordinates2D(2, 0).distance(disk.getCenter()), 1.0e-10); Assert.assertEquals(2, disk.getSupportSize()); } @Test public void testSupport3Points() { - List support = Arrays.asList(new Vector2D(1, 0), - new Vector2D(3, 0), - new Vector2D(2, 2)); - EnclosingBall disk = new DiskGenerator().ballOnSupport(support); + List support = Arrays.asList(new Coordinates2D(1, 0), + new Coordinates2D(3, 0), + new Coordinates2D(2, 2)); + EnclosingBall disk = new DiskGenerator().ballOnSupport(support); Assert.assertEquals(5.0 / 4.0, disk.getRadius(), 1.0e-10); int i = 0; - for (Vector2D v : support) { + for (Coordinates2D v : support) { Assert.assertTrue(disk.contains(v)); Assert.assertEquals(5.0 / 4.0, v.distance(disk.getCenter()), 1.0e-10); Assert.assertTrue(v == disk.getSupport()[i++]); } - Assert.assertTrue(disk.contains(new Vector2D(2, 0.9))); - Assert.assertFalse(disk.contains(new Vector2D(0.9, 0))); - Assert.assertFalse(disk.contains(new Vector2D(3.1, 0))); - Assert.assertTrue(disk.contains(new Vector2D(2.0, -0.499))); - Assert.assertFalse(disk.contains(new Vector2D(2.0, -0.501))); - Assert.assertEquals(0.0, new Vector2D(2.0, 3.0 / 4.0).distance(disk.getCenter()), 1.0e-10); + Assert.assertTrue(disk.contains(new Coordinates2D(2, 0.9))); + Assert.assertFalse(disk.contains(new Coordinates2D(0.9, 0))); + Assert.assertFalse(disk.contains(new Coordinates2D(3.1, 0))); + Assert.assertTrue(disk.contains(new Coordinates2D(2.0, -0.499))); + Assert.assertFalse(disk.contains(new Coordinates2D(2.0, -0.501))); + Assert.assertEquals(0.0, new Coordinates2D(2.0, 3.0 / 4.0).distance(disk.getCenter()), 1.0e-10); Assert.assertEquals(3, disk.getSupportSize()); } @@ -108,12 +108,12 @@ public class DiskGeneratorTest { for (int i = 0; i < 500; ++i) { double d = 25 * random.nextDouble(); double refRadius = 10 * random.nextDouble(); - Vector2D refCenter = new Vector2D(d, new Vector2D(sr.nextVector())); - List support = new ArrayList<>(); + Coordinates2D refCenter = new Coordinates2D(d, new Coordinates2D(sr.nextVector())); + List support = new ArrayList<>(); for (int j = 0; j < 3; ++j) { - support.add(new Vector2D(1.0, refCenter, refRadius, new Vector2D(sr.nextVector()))); + support.add(new Coordinates2D(1.0, refCenter, refRadius, new Coordinates2D(sr.nextVector()))); } - EnclosingBall disk = new DiskGenerator().ballOnSupport(support); + EnclosingBall disk = new DiskGenerator().ballOnSupport(support); Assert.assertEquals(0.0, refCenter.distance(disk.getCenter()), 3e-9 * refRadius); Assert.assertEquals(refRadius, disk.getRadius(), 7e-10 * refRadius); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/b815d2af/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/LineTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/LineTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/LineTest.java index a7810e7..79e9fa4 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/LineTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/LineTest.java @@ -19,10 +19,10 @@ package org.apache.commons.math4.geometry.euclidean.twod; import org.apache.commons.math4.exception.MathIllegalArgumentException; import org.apache.commons.math4.geometry.Point; import org.apache.commons.math4.geometry.euclidean.oned.Euclidean1D; -import org.apache.commons.math4.geometry.euclidean.oned.Vector1D; +import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D; import org.apache.commons.math4.geometry.euclidean.twod.Euclidean2D; import org.apache.commons.math4.geometry.euclidean.twod.Line; -import org.apache.commons.math4.geometry.euclidean.twod.Vector2D; +import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; import org.apache.commons.math4.geometry.partitioning.Transform; import org.apache.commons.math4.util.FastMath; import org.junit.Assert; @@ -32,54 +32,54 @@ public class LineTest { @Test public void testContains() { - Line l = new Line(new Vector2D(0, 1), new Vector2D(1, 2), 1.0e-10); - Assert.assertTrue(l.contains(new Vector2D(0, 1))); - Assert.assertTrue(l.contains(new Vector2D(1, 2))); - Assert.assertTrue(l.contains(new Vector2D(7, 8))); - Assert.assertTrue(! l.contains(new Vector2D(8, 7))); + Line l = new Line(new Coordinates2D(0, 1), new Coordinates2D(1, 2), 1.0e-10); + Assert.assertTrue(l.contains(new Coordinates2D(0, 1))); + Assert.assertTrue(l.contains(new Coordinates2D(1, 2))); + Assert.assertTrue(l.contains(new Coordinates2D(7, 8))); + Assert.assertTrue(! l.contains(new Coordinates2D(8, 7))); } @Test public void testAbscissa() { - Line l = new Line(new Vector2D(2, 1), new Vector2D(-2, -2), 1.0e-10); + Line l = new Line(new Coordinates2D(2, 1), new Coordinates2D(-2, -2), 1.0e-10); Assert.assertEquals(0.0, - (l.toSubSpace(new Vector2D(-3, 4))).getX(), + (l.toSubSpace(new Coordinates2D(-3, 4))).getX(), 1.0e-10); Assert.assertEquals(0.0, - (l.toSubSpace(new Vector2D( 3, -4))).getX(), + (l.toSubSpace(new Coordinates2D( 3, -4))).getX(), 1.0e-10); Assert.assertEquals(-5.0, - (l.toSubSpace(new Vector2D( 7, -1))).getX(), + (l.toSubSpace(new Coordinates2D( 7, -1))).getX(), 1.0e-10); - Assert.assertEquals( 5.0, - (l.toSubSpace(new Vector2D(-1, -7))).getX(), + Assert.assertEquals(5.0, + (l.toSubSpace(new Coordinates2D(-1, -7))).getX(), 1.0e-10); } @Test public void testOffset() { - Line l = new Line(new Vector2D(2, 1), new Vector2D(-2, -2), 1.0e-10); - Assert.assertEquals(-5.0, l.getOffset(new Vector2D(5, -3)), 1.0e-10); - Assert.assertEquals(+5.0, l.getOffset(new Vector2D(-5, 2)), 1.0e-10); + Line l = new Line(new Coordinates2D(2, 1), new Coordinates2D(-2, -2), 1.0e-10); + Assert.assertEquals(-5.0, l.getOffset(new Coordinates2D(5, -3)), 1.0e-10); + Assert.assertEquals(+5.0, l.getOffset(new Coordinates2D(-5, 2)), 1.0e-10); } @Test public void testDistance() { - Line l = new Line(new Vector2D(2, 1), new Vector2D(-2, -2), 1.0e-10); - Assert.assertEquals(+5.0, l.distance(new Vector2D(5, -3)), 1.0e-10); - Assert.assertEquals(+5.0, l.distance(new Vector2D(-5, 2)), 1.0e-10); + Line l = new Line(new Coordinates2D(2, 1), new Coordinates2D(-2, -2), 1.0e-10); + Assert.assertEquals(+5.0, l.distance(new Coordinates2D(5, -3)), 1.0e-10); + Assert.assertEquals(+5.0, l.distance(new Coordinates2D(-5, 2)), 1.0e-10); } @Test public void testPointAt() { - Line l = new Line(new Vector2D(2, 1), new Vector2D(-2, -2), 1.0e-10); + Line l = new Line(new Coordinates2D(2, 1), new Coordinates2D(-2, -2), 1.0e-10); for (double a = -2.0; a < 2.0; a += 0.2) { - Point pA = new Vector1D(a); + Point pA = new Coordinates1D(a); Point point = l.toSpace(pA); Assert.assertEquals(a, (l.toSubSpace(point)).getX(), 1.0e-10); Assert.assertEquals(0.0, l.getOffset(point), 1.0e-10); for (double o = -2.0; o < 2.0; o += 0.2) { - point = l.getPointAt((Vector1D) pA, o); + point = l.getPointAt((Coordinates1D) pA, o); Assert.assertEquals(a, (l.toSubSpace(point)).getX(), 1.0e-10); Assert.assertEquals(o, l.getOffset(point), 1.0e-10); } @@ -88,34 +88,34 @@ public class LineTest { @Test public void testOriginOffset() { - Line l1 = new Line(new Vector2D(0, 1), new Vector2D(1, 2), 1.0e-10); + Line l1 = new Line(new Coordinates2D(0, 1), new Coordinates2D(1, 2), 1.0e-10); Assert.assertEquals(FastMath.sqrt(0.5), l1.getOriginOffset(), 1.0e-10); - Line l2 = new Line(new Vector2D(1, 2), new Vector2D(0, 1), 1.0e-10); + Line l2 = new Line(new Coordinates2D(1, 2), new Coordinates2D(0, 1), 1.0e-10); Assert.assertEquals(-FastMath.sqrt(0.5), l2.getOriginOffset(), 1.0e-10); } @Test public void testParallel() { - Line l1 = new Line(new Vector2D(0, 1), new Vector2D(1, 2), 1.0e-10); - Line l2 = new Line(new Vector2D(2, 2), new Vector2D(3, 3), 1.0e-10); + Line l1 = new Line(new Coordinates2D(0, 1), new Coordinates2D(1, 2), 1.0e-10); + Line l2 = new Line(new Coordinates2D(2, 2), new Coordinates2D(3, 3), 1.0e-10); Assert.assertTrue(l1.isParallelTo(l2)); - Line l3 = new Line(new Vector2D(1, 0), new Vector2D(0.5, -0.5), 1.0e-10); + Line l3 = new Line(new Coordinates2D(1, 0), new Coordinates2D(0.5, -0.5), 1.0e-10); Assert.assertTrue(l1.isParallelTo(l3)); - Line l4 = new Line(new Vector2D(1, 0), new Vector2D(0.5, -0.51), 1.0e-10); + Line l4 = new Line(new Coordinates2D(1, 0), new Coordinates2D(0.5, -0.51), 1.0e-10); Assert.assertTrue(! l1.isParallelTo(l4)); } @Test public void testTransform() throws MathIllegalArgumentException { - Line l1 = new Line(new Vector2D(1.0 ,1.0), new Vector2D(4.0 ,1.0), 1.0e-10); + Line l1 = new Line(new Coordinates2D(1.0 ,1.0), new Coordinates2D(4.0 ,1.0), 1.0e-10); Transform t1 = Line.getTransform(0.0, 0.5, -1.0, 0.0, 1.0, 1.5); Assert.assertEquals(0.5 * FastMath.PI, ((Line) t1.apply(l1)).getAngle(), 1.0e-10); - Line l2 = new Line(new Vector2D(0.0, 0.0), new Vector2D(1.0, 1.0), 1.0e-10); + Line l2 = new Line(new Coordinates2D(0.0, 0.0), new Coordinates2D(1.0, 1.0), 1.0e-10); Transform t2 = Line.getTransform(0.0, 0.5, -1.0, 0.0, 1.0, 1.5); Assert.assertEquals(FastMath.atan2(1.0, -2.0), @@ -126,9 +126,9 @@ public class LineTest { @Test public void testIntersection() { - Line l1 = new Line(new Vector2D( 0, 1), new Vector2D(1, 2), 1.0e-10); - Line l2 = new Line(new Vector2D(-1, 2), new Vector2D(2, 1), 1.0e-10); - Vector2D p = l1.intersection(l2); + Line l1 = new Line(new Coordinates2D( 0, 1), new Coordinates2D(1, 2), 1.0e-10); + Line l2 = new Line(new Coordinates2D(-1, 2), new Coordinates2D(2, 1), 1.0e-10); + Coordinates2D p = l1.intersection(l2); Assert.assertEquals(0.5, p.getX(), 1.0e-10); Assert.assertEquals(1.5, p.getY(), 1.0e-10); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/b815d2af/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/NestedLoopsTest.java ---------------------------------------------------------------------- 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 index e46008a..822cea7 100644 --- 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 @@ -32,13 +32,13 @@ public class NestedLoopsTest { @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); + Coordinates2D oneOne = new Coordinates2D(1.0, 1.0); + Coordinates2D oneNegativeOne = new Coordinates2D(1.0, -1.0); + Coordinates2D negativeOneNegativeOne = new Coordinates2D(-1.0, -1.0); + Coordinates2D negativeOneOne = new Coordinates2D(-1.0, 1.0); + Coordinates2D origin = new Coordinates2D(0, 0); - Vector2D [] vertices = new Vector2D[]{ + Coordinates2D [] vertices = new Coordinates2D[]{ oneOne, oneNegativeOne, negativeOneNegativeOne, @@ -55,8 +55,8 @@ public class NestedLoopsTest { 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)); + Coordinates2D[] loop = (Coordinates2D []) 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));