From commits-return-70640-apmail-commons-commits-archive=commons.apache.org@commons.apache.org Sat Nov 30 03:31:03 2019 Return-Path: X-Original-To: apmail-commons-commits-archive@minotaur.apache.org Delivered-To: apmail-commons-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [207.244.88.153]) by minotaur.apache.org (Postfix) with SMTP id 3AB7519F43 for ; Sat, 30 Nov 2019 03:31:02 +0000 (UTC) Received: (qmail 74724 invoked by uid 500); 30 Nov 2019 03:31:00 -0000 Delivered-To: apmail-commons-commits-archive@commons.apache.org Received: (qmail 74636 invoked by uid 500); 30 Nov 2019 03:30:59 -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 74611 invoked by uid 99); 30 Nov 2019 03:30:58 -0000 Received: from ec2-52-202-80-70.compute-1.amazonaws.com (HELO gitbox.apache.org) (52.202.80.70) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 30 Nov 2019 03:30:58 +0000 Received: by gitbox.apache.org (ASF Mail Server at gitbox.apache.org, from userid 33) id 4CAC38B687; Sat, 30 Nov 2019 03:30:58 +0000 (UTC) Date: Sat, 30 Nov 2019 03:30:59 +0000 To: "commits@commons.apache.org" Subject: [commons-geometry] 02/02: Removed usage of constants prefixed with "MINUS". MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit From: erans@apache.org In-Reply-To: <157508465791.23637.7194794624673889742@gitbox.apache.org> References: <157508465791.23637.7194794624673889742@gitbox.apache.org> X-Git-Host: gitbox.apache.org X-Git-Repo: commons-geometry X-Git-Refname: refs/heads/master X-Git-Reftype: branch X-Git-Rev: 6cb76ba054509d046e9ee417e09f871946c8db3d X-Git-NotificationType: diff X-Git-Multimail-Version: 1.5.dev Auto-Submitted: auto-generated Message-Id: <20191130033058.4CAC38B687@gitbox.apache.org> This is an automated email from the ASF dual-hosted git repository. erans pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/commons-geometry.git commit 6cb76ba054509d046e9ee417e09f871946c8db3d Author: Gilles Sadowski AuthorDate: Sat Nov 30 04:28:42 2019 +0100 Removed usage of constants prefixed with "MINUS". --- .../threed/rotation/QuaternionRotation.java | 2 +- .../euclidean/threed/SphericalCoordinatesTest.java | 16 ++--- .../threed/rotation/QuaternionRotationTest.java | 68 +++++++++++----------- .../twod/AbstractSegmentConnectorTest.java | 6 +- .../twod/AffineTransformMatrix2DTest.java | 6 +- .../geometry/euclidean/twod/ConvexAreaTest.java | 2 +- .../commons/geometry/euclidean/twod/LineTest.java | 2 +- .../euclidean/twod/PolarCoordinatesTest.java | 10 ++-- .../euclidean/twod/RegionBSPTree2DTest.java | 2 +- .../spherical/oned/AngularIntervalTest.java | 30 +++++----- .../geometry/spherical/oned/CutAngleTest.java | 46 +++++++-------- .../geometry/spherical/oned/Point1STest.java | 8 +-- .../spherical/oned/RegionBSPTree1STest.java | 54 ++++++++--------- .../geometry/spherical/oned/Transform1STest.java | 2 +- .../twod/AbstractGreatArcPathConnectorTest.java | 4 +- .../geometry/spherical/twod/ConvexArea2STest.java | 2 +- .../geometry/spherical/twod/GreatArcTest.java | 2 +- .../geometry/spherical/twod/GreatCircleTest.java | 24 ++++---- .../spherical/twod/RegionBSPTree2STest.java | 4 +- .../spherical/twod/SubGreatCircleTest.java | 2 +- 20 files changed, 146 insertions(+), 146 deletions(-) diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotation.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotation.java index 1b203b7..16f4a0f 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotation.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotation.java @@ -403,7 +403,7 @@ public final class QuaternionRotation implements Rotation3D { final double angle2 = angle2Sin > AXIS_ANGLE_SINGULARITY_THRESHOLD ? PlaneAngleRadians.PI_OVER_TWO : - PlaneAngleRadians.MINUS_PI_OVER_TWO; + -PlaneAngleRadians.PI_OVER_TWO; return new double[] { Math.atan2(angle1TanY, angle1TanX), diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/SphericalCoordinatesTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/SphericalCoordinatesTest.java index 555dd1f..2acd8d2 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/SphericalCoordinatesTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/SphericalCoordinatesTest.java @@ -39,7 +39,7 @@ public class SphericalCoordinatesTest { checkSpherical(SphericalCoordinates.of(1, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI), 1, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI); - checkSpherical(SphericalCoordinates.of(1, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), + checkSpherical(SphericalCoordinates.of(1, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), 1, PlaneAngleRadians.THREE_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); } @@ -61,13 +61,13 @@ public class SphericalCoordinatesTest { checkSpherical(SphericalCoordinates.of(1, 0, MINUS_QUARTER_PI), 1, 0, QUARTER_PI); checkSpherical(SphericalCoordinates.of(1, 0, PlaneAngleRadians.PI_OVER_TWO), 1, 0, PlaneAngleRadians.PI_OVER_TWO); - checkSpherical(SphericalCoordinates.of(1, 0, PlaneAngleRadians.MINUS_PI_OVER_TWO), 1, 0, PlaneAngleRadians.PI_OVER_TWO); + checkSpherical(SphericalCoordinates.of(1, 0, -PlaneAngleRadians.PI_OVER_TWO), 1, 0, PlaneAngleRadians.PI_OVER_TWO); checkSpherical(SphericalCoordinates.of(1, 0, THREE_QUARTER_PI), 1, 0, THREE_QUARTER_PI); checkSpherical(SphericalCoordinates.of(1, 0, MINUS_THREE_QUARTER_PI), 1, 0, THREE_QUARTER_PI); checkSpherical(SphericalCoordinates.of(1, 0, PlaneAngleRadians.TWO_PI), 1, 0, 0); - checkSpherical(SphericalCoordinates.of(1, 0, PlaneAngleRadians.MINUS_TWO_PI), 1, 0, 0); + checkSpherical(SphericalCoordinates.of(1, 0, -PlaneAngleRadians.TWO_PI), 1, 0, 0); } @Test @@ -95,7 +95,7 @@ public class SphericalCoordinatesTest { checkSpherical(SphericalCoordinates.of(-2, PlaneAngleRadians.PI, PlaneAngleRadians.PI), 2, 0, 0); checkSpherical(SphericalCoordinates.of(-3, PlaneAngleRadians.PI_OVER_TWO, QUARTER_PI), 3, PlaneAngleRadians.THREE_PI_OVER_TWO, THREE_QUARTER_PI); - checkSpherical(SphericalCoordinates.of(-3, PlaneAngleRadians.MINUS_PI_OVER_TWO, THREE_QUARTER_PI), 3, PlaneAngleRadians.PI_OVER_TWO, QUARTER_PI); + checkSpherical(SphericalCoordinates.of(-3, -PlaneAngleRadians.PI_OVER_TWO, THREE_QUARTER_PI), 3, PlaneAngleRadians.PI_OVER_TWO, QUARTER_PI); checkSpherical(SphericalCoordinates.of(-4, QUARTER_PI, PlaneAngleRadians.PI_OVER_TWO), 4, PlaneAngleRadians.PI + QUARTER_PI, PlaneAngleRadians.PI_OVER_TWO); checkSpherical(SphericalCoordinates.of(-4, MINUS_THREE_QUARTER_PI, PlaneAngleRadians.PI_OVER_TWO), 4, QUARTER_PI, PlaneAngleRadians.PI_OVER_TWO); @@ -166,7 +166,7 @@ public class SphericalCoordinatesTest { checkVector(SphericalCoordinates.of(1, PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO).toVector(), -1, 0, 0); checkVector(SphericalCoordinates.of(2, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO).toVector(), 0, 2, 0); - checkVector(SphericalCoordinates.of(2, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO).toVector(), 0, -2, 0); + checkVector(SphericalCoordinates.of(2, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO).toVector(), 0, -2, 0); checkVector(SphericalCoordinates.of(3, 0, 0).toVector(), 0, 0, 3); checkVector(SphericalCoordinates.of(3, 0, PlaneAngleRadians.PI).toVector(), 0, 0, -3); @@ -187,7 +187,7 @@ public class SphericalCoordinatesTest { checkVector(SphericalCoordinates.toCartesian(1, PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO), -1, 0, 0); checkVector(SphericalCoordinates.toCartesian(2, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), 0, 2, 0); - checkVector(SphericalCoordinates.toCartesian(2, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), 0, -2, 0); + checkVector(SphericalCoordinates.toCartesian(2, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), 0, -2, 0); checkVector(SphericalCoordinates.toCartesian(3, 0, 0), 0, 0, 3); checkVector(SphericalCoordinates.toCartesian(3, 0, PlaneAngleRadians.PI), 0, 0, -3); @@ -358,7 +358,7 @@ public class SphericalCoordinatesTest { Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, SphericalCoordinates.normalizeAzimuth(PlaneAngleRadians.THREE_PI_OVER_TWO), EPS); Assert.assertEquals(0.0, SphericalCoordinates.normalizeAzimuth(PlaneAngleRadians.TWO_PI), EPS); - Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, SphericalCoordinates.normalizeAzimuth(PlaneAngleRadians.MINUS_PI_OVER_TWO), EPS); + Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, SphericalCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(PlaneAngleRadians.PI, SphericalCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI), EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, SphericalCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI - PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(0.0, SphericalCoordinates.normalizeAzimuth(-PlaneAngleRadians.TWO_PI), EPS); @@ -382,7 +382,7 @@ public class SphericalCoordinatesTest { Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, SphericalCoordinates.normalizePolar(PlaneAngleRadians.PI + PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(0.0, SphericalCoordinates.normalizePolar(PlaneAngleRadians.TWO_PI), EPS); - Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, SphericalCoordinates.normalizePolar(PlaneAngleRadians.MINUS_PI_OVER_TWO), EPS); + Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, SphericalCoordinates.normalizePolar(-PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(PlaneAngleRadians.PI, SphericalCoordinates.normalizePolar(-PlaneAngleRadians.PI), EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, SphericalCoordinates.normalizePolar(-PlaneAngleRadians.PI - PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(0.0, SphericalCoordinates.normalizePolar(-PlaneAngleRadians.TWO_PI), EPS); diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotationTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotationTest.java index a1eff71..cb61ef0 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotationTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/rotation/QuaternionRotationTest.java @@ -165,7 +165,7 @@ public class QuaternionRotationTest { // negative angle results in the axis being the negated normalized input axis EuclideanTestUtils.assertCoordinatesEqual(norm, - QuaternionRotation.fromAxisAngle(vec.negate(), PlaneAngleRadians.MINUS_PI_OVER_TWO).getAxis(), EPS); + QuaternionRotation.fromAxisAngle(vec.negate(), -PlaneAngleRadians.PI_OVER_TWO).getAxis(), EPS); }); } @@ -215,10 +215,10 @@ public class QuaternionRotationTest { assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, 0.0)); assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI)); assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.PI)); @@ -227,10 +227,10 @@ public class QuaternionRotationTest { assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, 0.0)); assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI)); assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.PI)); @@ -239,10 +239,10 @@ public class QuaternionRotationTest { assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, 0.0)); assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO)); - assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO)); + assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO)); assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI)); assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.PI)); @@ -313,10 +313,10 @@ public class QuaternionRotationTest { // --- x axes assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, 0.0).inverse()); - assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); - assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI).inverse()); @@ -325,10 +325,10 @@ public class QuaternionRotationTest { // --- y axes assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, 0.0).inverse()); - assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); - assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI).inverse()); @@ -337,10 +337,10 @@ public class QuaternionRotationTest { // --- z axes assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, 0.0).inverse()); - assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); - assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).inverse()); + assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO).inverse()); assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI).inverse()); @@ -715,10 +715,10 @@ public class QuaternionRotationTest { assertTransformEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, 0.0).toMatrix()); assertTransformEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, PlaneAngleRadians.PI).toMatrix()); assertTransformEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, PlaneAngleRadians.PI).toMatrix()); @@ -727,10 +727,10 @@ public class QuaternionRotationTest { assertTransformEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, 0.0).toMatrix()); assertTransformEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, PlaneAngleRadians.PI).toMatrix()); assertTransformEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, PlaneAngleRadians.PI).toMatrix()); @@ -739,10 +739,10 @@ public class QuaternionRotationTest { assertTransformEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, 0.0).toMatrix()); assertTransformEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.PI_OVER_TWO).toMatrix()); - assertTransformEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.MINUS_PI_OVER_TWO).toMatrix()); + assertTransformEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, -PlaneAngleRadians.PI_OVER_TWO).toMatrix()); assertTransformEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, PlaneAngleRadians.PI).toMatrix()); assertTransformEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, PlaneAngleRadians.PI).toMatrix()); @@ -773,7 +773,7 @@ public class QuaternionRotationTest { private void checkAxisAngleSequenceToQuaternionRoundtrip(AxisReferenceFrame frame, AxisSequence axes) { double step = 0.3; - double angle2Start = axes.getType() == AxisSequenceType.EULER ? 0.0 + 0.1 : PlaneAngleRadians.MINUS_PI_OVER_TWO + 0.1; + double angle2Start = axes.getType() == AxisSequenceType.EULER ? 0.0 + 0.1 : -PlaneAngleRadians.PI_OVER_TWO + 0.1; double angle2Stop = angle2Start + PlaneAngleRadians.PI; for (double angle1 = 0.0; angle1 <= PlaneAngleRadians.TWO_PI; angle1 += step) { @@ -896,7 +896,7 @@ public class QuaternionRotationTest { public void testAxisAngleSequenceConversion_relative_taitBryanSingularities() { // arrange double[] taitBryanSingularities = { - PlaneAngleRadians.MINUS_PI_OVER_TWO, + -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO }; @@ -933,7 +933,7 @@ public class QuaternionRotationTest { public void testAxisAngleSequenceConversion_absolute_taitBryanSingularities() { // arrange double[] taitBryanSingularities = { - PlaneAngleRadians.MINUS_PI_OVER_TWO, + -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO }; @@ -1434,35 +1434,35 @@ public class QuaternionRotationTest { // XYX checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XYX, 0, PlaneAngleRadians.PI_OVER_TWO, 0); - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); // XZX checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.XZX, PlaneAngleRadians.PI_OVER_TWO, 0, 0); - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XZX, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XZX, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XZX, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.XZX, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); // YXY checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YXY, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.YXY, PlaneAngleRadians.PI_OVER_TWO, 0, 0); - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YXY, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YXY, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.YXY, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); // YZY - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YZY, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YZY, -PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.YZY, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YZY, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.YZY, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); // ZXZ checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZXZ, 0, PlaneAngleRadians.PI_OVER_TWO, 0); - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZXZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZXZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.ZXZ, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.ZXZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); // ZYZ - checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZYZ, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceRelative(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.ZYZ, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); @@ -1526,35 +1526,35 @@ public class QuaternionRotationTest { // XYX checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XYX, 0, PlaneAngleRadians.PI_OVER_TWO, 0); - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XYX, PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.XYX, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); // XZX checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.XZX, PlaneAngleRadians.PI_OVER_TWO, 0, 0); - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XZX, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.XZX, -PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.XZX, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.XZX, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); // YXY checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YXY, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.YXY, PlaneAngleRadians.PI_OVER_TWO, 0, 0); - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YXY, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YXY, -PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.YXY, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); // YZY - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YZY, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.YZY, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.YZY, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.YZY, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.YZY, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); // ZXZ checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZXZ, 0, PlaneAngleRadians.PI_OVER_TWO, 0); - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZXZ, PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZXZ, -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.ZXZ, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.ZXZ, 0, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); // ZYZ - checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_X_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Y_HALF_PI, AxisSequence.ZYZ, 0, PlaneAngleRadians.PI_OVER_TWO, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_Z_HALF_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, 0, 0); checkFromAxisAngleSequenceAbsolute(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, AxisSequence.ZYZ, PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, 0); diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AbstractSegmentConnectorTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AbstractSegmentConnectorTest.java index 8d3f9df..8113ba2 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AbstractSegmentConnectorTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AbstractSegmentConnectorTest.java @@ -268,7 +268,7 @@ public class AbstractSegmentConnectorTest { .append(Line.fromPointAndAngle(p1, -0.25 * PlaneAngleRadians.PI, TEST_PRECISION).segment(almostP1, almostP1)) .append(p2) .append(p0) - .append(Line.fromPointAndAngle(Vector2D.ZERO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION) + .append(Line.fromPointAndAngle(Vector2D.ZERO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION) .segment(almostP0, almostP0)) .build(); @@ -293,7 +293,7 @@ public class AbstractSegmentConnectorTest { Segment seg0 = Segment.fromPoints(p0, p1, TEST_PRECISION); Segment seg1 = Segment.fromPoints(p1, p0, TEST_PRECISION); Segment seg2 = Line.fromPointAndAngle(p1, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).segment(p1, p1); - Segment seg3 = Line.fromPointAndAngle(p0, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION).segment(p0, p0); + Segment seg3 = Line.fromPointAndAngle(p0, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).segment(p0, p0); List segments = new ArrayList<>(Arrays.asList(seg0, seg1, seg2, seg3)); shuffle(segments); @@ -319,7 +319,7 @@ public class AbstractSegmentConnectorTest { Segment seg0 = Line.fromPointAndAngle(p0, 0.0, TEST_PRECISION).segment(p0, p0); Segment seg1 = Line.fromPointAndAngle(p0, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).segment(p0, p0); Segment seg2 = Line.fromPointAndAngle(p0, PlaneAngleRadians.PI, TEST_PRECISION).segment(p0, p0); - Segment seg3 = Line.fromPointAndAngle(p0, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION).segment(p0, p0); + Segment seg3 = Line.fromPointAndAngle(p0, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).segment(p0, p0); List segments = new ArrayList<>(Arrays.asList(seg0, seg1, seg2, seg3)); shuffle(segments); diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2DTest.java index 2121e15..e855811 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2DTest.java @@ -386,7 +386,7 @@ public class AffineTransformMatrix2DTest { public void testApply_rotate() { // arrange AffineTransformMatrix2D transform = AffineTransformMatrix2D.identity() - .rotate(PlaneAngleRadians.MINUS_PI_OVER_TWO); + .rotate(-PlaneAngleRadians.PI_OVER_TWO); // act/assert runWithCoordinates((x, y) -> { @@ -403,7 +403,7 @@ public class AffineTransformMatrix2DTest { // arrange Vector2D center = Vector2D.of(1, 2); AffineTransformMatrix2D transform = AffineTransformMatrix2D.identity() - .rotate(center, PlaneAngleRadians.MINUS_PI_OVER_TWO); + .rotate(center, -PlaneAngleRadians.PI_OVER_TWO); // act/assert runWithCoordinates((x, y) -> { @@ -470,7 +470,7 @@ public class AffineTransformMatrix2DTest { AffineTransformMatrix2D transform = AffineTransformMatrix2D.identity() .scale(scale) .translate(translation) - .rotate(PlaneAngleRadians.MINUS_PI_OVER_TWO); + .rotate(-PlaneAngleRadians.PI_OVER_TWO); // act/assert runWithCoordinates((x, y) -> { diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/ConvexAreaTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/ConvexAreaTest.java index d1c5dad..8c8cc44 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/ConvexAreaTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/ConvexAreaTest.java @@ -61,7 +61,7 @@ public class ConvexAreaTest { Line.fromPointAndAngle(Vector2D.ZERO, 0.0, TEST_PRECISION), Line.fromPointAndAngle(Vector2D.of(1, 0), PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION), Line.fromPointAndAngle(Vector2D.of(1, 1), PlaneAngleRadians.PI, TEST_PRECISION), - Line.fromPointAndAngle(Vector2D.of(0, 1), PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION) + Line.fromPointAndAngle(Vector2D.of(0, 1), -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION) ); // act diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java index 275064b..798ce03 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/LineTest.java @@ -98,7 +98,7 @@ public class LineTest { Vector2D.of(1, 0), Vector2D.Unit.PLUS_Y); checkLine(Line.fromPointAndAngle(Vector2D.of(-1, -1), PlaneAngleRadians.PI, TEST_PRECISION), Vector2D.of(0, -1), Vector2D.Unit.MINUS_X); - checkLine(Line.fromPointAndAngle(Vector2D.of(1, -1), PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION), + checkLine(Line.fromPointAndAngle(Vector2D.of(1, -1), -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION), Vector2D.of(1, 0), Vector2D.Unit.MINUS_Y); checkLine(Line.fromPointAndAngle(Vector2D.of(-1, 1), PlaneAngleRadians.TWO_PI, TEST_PRECISION), Vector2D.of(0, 1), Vector2D.Unit.PLUS_X); diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/PolarCoordinatesTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/PolarCoordinatesTest.java index d88e33b..4dc08c0 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/PolarCoordinatesTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/PolarCoordinatesTest.java @@ -34,7 +34,7 @@ public class PolarCoordinatesTest { checkPolar(PolarCoordinates.of(2, 0), 2, 0); checkPolar(PolarCoordinates.of(2, PlaneAngleRadians.PI_OVER_TWO), 2, PlaneAngleRadians.PI_OVER_TWO); checkPolar(PolarCoordinates.of(2, PlaneAngleRadians.PI), 2, PlaneAngleRadians.PI); - checkPolar(PolarCoordinates.of(2, PlaneAngleRadians.MINUS_PI_OVER_TWO), 2, PlaneAngleRadians.THREE_PI_OVER_TWO); + checkPolar(PolarCoordinates.of(2, -PlaneAngleRadians.PI_OVER_TWO), 2, PlaneAngleRadians.THREE_PI_OVER_TWO); } @Test @@ -79,7 +79,7 @@ public class PolarCoordinatesTest { checkPolar(PolarCoordinates.of(-1, 0), 1, PlaneAngleRadians.PI); checkPolar(PolarCoordinates.of(-1e-6, PlaneAngleRadians.PI_OVER_TWO), 1e-6, PlaneAngleRadians.THREE_PI_OVER_TWO); checkPolar(PolarCoordinates.of(-2, PlaneAngleRadians.PI), 2, 0); - checkPolar(PolarCoordinates.of(-3, PlaneAngleRadians.MINUS_PI_OVER_TWO), 3, PlaneAngleRadians.PI_OVER_TWO); + checkPolar(PolarCoordinates.of(-3, -PlaneAngleRadians.PI_OVER_TWO), 3, PlaneAngleRadians.PI_OVER_TWO); } @Test @@ -269,7 +269,7 @@ public class PolarCoordinatesTest { checkVector(PolarCoordinates.of(1, PlaneAngleRadians.PI).toCartesian(), -1, 0); checkVector(PolarCoordinates.of(sqrt2, -0.75 * PlaneAngleRadians.PI).toCartesian(), -1, -1); - checkVector(PolarCoordinates.of(1, PlaneAngleRadians.MINUS_PI_OVER_TWO).toCartesian(), 0, -1); + checkVector(PolarCoordinates.of(1, -PlaneAngleRadians.PI_OVER_TWO).toCartesian(), 0, -1); checkVector(PolarCoordinates.of(sqrt2, -0.25 * PlaneAngleRadians.PI).toCartesian(), 1, -1); } @@ -289,7 +289,7 @@ public class PolarCoordinatesTest { checkPoint(PolarCoordinates.toCartesian(1, PlaneAngleRadians.PI), -1, 0); checkPoint(PolarCoordinates.toCartesian(sqrt2, -0.75 * PlaneAngleRadians.PI), -1, -1); - checkPoint(PolarCoordinates.toCartesian(1, PlaneAngleRadians.MINUS_PI_OVER_TWO), 0, -1); + checkPoint(PolarCoordinates.toCartesian(1, -PlaneAngleRadians.PI_OVER_TWO), 0, -1); checkPoint(PolarCoordinates.toCartesian(sqrt2, -0.25 * PlaneAngleRadians.PI), 1, -1); } @@ -346,7 +346,7 @@ public class PolarCoordinatesTest { Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, PolarCoordinates.normalizeAzimuth(PlaneAngleRadians.THREE_PI_OVER_TWO), EPS); Assert.assertEquals(0.0, PolarCoordinates.normalizeAzimuth(PlaneAngleRadians.TWO_PI), EPS); - Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, PolarCoordinates.normalizeAzimuth(PlaneAngleRadians.MINUS_PI_OVER_TWO), EPS); + Assert.assertEquals(PlaneAngleRadians.THREE_PI_OVER_TWO, PolarCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(PlaneAngleRadians.PI, PolarCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI), EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, PolarCoordinates.normalizeAzimuth(-PlaneAngleRadians.PI - PlaneAngleRadians.PI_OVER_TWO), EPS); Assert.assertEquals(0.0, PolarCoordinates.normalizeAzimuth(-PlaneAngleRadians.TWO_PI), EPS); diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java index 206209b..c480be1 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/RegionBSPTree2DTest.java @@ -960,7 +960,7 @@ public class RegionBSPTree2DTest { @Test public void testBuilder_mixedArguments() { // arrange - Line minusYAxis = Line.fromPointAndAngle(Vector2D.ZERO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + Line minusYAxis = Line.fromPointAndAngle(Vector2D.ZERO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); Polyline path = Polyline.builder(TEST_PRECISION) .append(Vector2D.Unit.PLUS_X) diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/AngularIntervalTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/AngularIntervalTest.java index 48c32ad..585bd79 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/AngularIntervalTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/AngularIntervalTest.java @@ -219,15 +219,15 @@ public class AngularIntervalTest { @Test public void testClassify_halfPi() { // arrange - AngularInterval interval = AngularInterval.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval interval = AngularInterval.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); // act/assert checkClassify(interval, RegionLocation.OUTSIDE, - Point1S.ZERO, Point1S.of(PlaneAngleRadians.PI_OVER_TWO - 0.1), Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO + 0.1)); + Point1S.ZERO, Point1S.of(PlaneAngleRadians.PI_OVER_TWO - 0.1), Point1S.of(-PlaneAngleRadians.PI_OVER_TWO + 0.1)); checkClassify(interval, RegionLocation.BOUNDARY, Point1S.of(PlaneAngleRadians.PI_OVER_TWO), Point1S.of(1.5 * PlaneAngleRadians.PI)); checkClassify(interval, RegionLocation.INSIDE, - Point1S.PI, Point1S.of(PlaneAngleRadians.PI_OVER_TWO + 0.1), Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO - 0.1)); + Point1S.PI, Point1S.of(PlaneAngleRadians.PI_OVER_TWO + 0.1), Point1S.of(-PlaneAngleRadians.PI_OVER_TWO - 0.1)); } @Test @@ -328,7 +328,7 @@ public class AngularIntervalTest { checkClassify(tree, RegionLocation.INSIDE, Point1S.ZERO, Point1S.of(PlaneAngleRadians.PI_OVER_TWO), - Point1S.PI, Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO)); + Point1S.PI, Point1S.of(-PlaneAngleRadians.PI_OVER_TWO)); } @Test @@ -472,7 +472,7 @@ public class AngularIntervalTest { RegionBSPTree1S minus = split.getMinus(); checkClassify(minus, RegionLocation.BOUNDARY, Point1S.of(PlaneAngleRadians.PI_OVER_TWO)); checkClassify(minus, RegionLocation.INSIDE, - Point1S.PI, Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), Point1S.of(-0.25 * PlaneAngleRadians.PI)); + Point1S.PI, Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), Point1S.of(-0.25 * PlaneAngleRadians.PI)); checkClassify(minus, RegionLocation.OUTSIDE, Point1S.ZERO, Point1S.of(0.25 * PlaneAngleRadians.PI)); @@ -481,7 +481,7 @@ public class AngularIntervalTest { checkClassify(plus, RegionLocation.INSIDE, Point1S.ZERO, Point1S.of(0.25 * PlaneAngleRadians.PI)); checkClassify(plus, RegionLocation.OUTSIDE, - Point1S.PI, Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), Point1S.of(-0.25 * PlaneAngleRadians.PI)); + Point1S.PI, Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), Point1S.of(-0.25 * PlaneAngleRadians.PI)); } @Test @@ -500,14 +500,14 @@ public class AngularIntervalTest { checkClassify(minus, RegionLocation.BOUNDARY, Point1S.of(PlaneAngleRadians.PI), cut.getPoint()); checkClassify(minus, RegionLocation.INSIDE, Point1S.of(0.8 * PlaneAngleRadians.PI)); checkClassify(minus, RegionLocation.OUTSIDE, - Point1S.ZERO, Point1S.of(PlaneAngleRadians.TWO_PI), Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), + Point1S.ZERO, Point1S.of(PlaneAngleRadians.TWO_PI), Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), Point1S.of(0.7 * PlaneAngleRadians.PI)); RegionBSPTree1S plus = split.getPlus(); checkClassify(plus, RegionLocation.BOUNDARY, Point1S.of(PlaneAngleRadians.PI_OVER_TWO), cut.getPoint()); checkClassify(plus, RegionLocation.INSIDE, Point1S.of(0.6 * PlaneAngleRadians.PI)); checkClassify(plus, RegionLocation.OUTSIDE, - Point1S.ZERO, Point1S.of(PlaneAngleRadians.TWO_PI), Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), + Point1S.ZERO, Point1S.of(PlaneAngleRadians.TWO_PI), Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), Point1S.of(0.8 * PlaneAngleRadians.PI)); } @@ -551,7 +551,7 @@ public class AngularIntervalTest { }, GeometryException.class); GeometryTestUtils.assertThrows(() -> { - AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO + 1, TEST_PRECISION); + AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO + 1, TEST_PRECISION); }, GeometryException.class); GeometryTestUtils.assertThrows(() -> { @@ -589,7 +589,7 @@ public class AngularIntervalTest { GeometryTestUtils.assertThrows(() -> { AngularInterval.Convex.of(Point1S.of(PlaneAngleRadians.PI_OVER_TWO), - Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO + 1), TEST_PRECISION); + Point1S.of(-PlaneAngleRadians.PI_OVER_TWO + 1), TEST_PRECISION); }, GeometryException.class); GeometryTestUtils.assertThrows(() -> { @@ -734,7 +734,7 @@ public class AngularIntervalTest { @Test public void testSplitDiameter_both_negativeFacingSplitter() { // arrange - AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); CutAngle splitter = CutAngle.createNegativeFacing(Point1S.of(PlaneAngleRadians.PI), TEST_PRECISION); // act @@ -750,7 +750,7 @@ public class AngularIntervalTest { @Test public void testSplitDiameter_both_positiveFacingSplitter() { // arrange - AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); CutAngle splitter = CutAngle.createPositiveFacing(Point1S.of(PlaneAngleRadians.PI), TEST_PRECISION); // act @@ -766,7 +766,7 @@ public class AngularIntervalTest { @Test public void testSplitDiameter_both_antipodal_negativeFacingSplitter() { // arrange - AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); CutAngle splitter = CutAngle.createNegativeFacing(Point1S.ZERO, TEST_PRECISION); // act @@ -782,7 +782,7 @@ public class AngularIntervalTest { @Test public void testSplitDiameter_both_antipodal_positiveFacingSplitter() { // arrange - AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); CutAngle splitter = CutAngle.createPositiveFacing(Point1S.ZERO, TEST_PRECISION); // act @@ -798,7 +798,7 @@ public class AngularIntervalTest { @Test public void testSplitDiameter_splitOnBoundary_negativeFacing() { // arrange - AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval.Convex interval = AngularInterval.Convex.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); CutAngle splitter = CutAngle.createNegativeFacing(Point1S.of(PlaneAngleRadians.PI_OVER_TWO), TEST_PRECISION); // act diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java index 115436a..3b99fc2 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/CutAngleTest.java @@ -48,21 +48,21 @@ public class CutAngleTest { 0.0, true); checkCutAngle(CutAngle.fromAzimuthAndDirection(PlaneAngleRadians.PI, true, TEST_PRECISION), PlaneAngleRadians.PI, true); - checkCutAngle(CutAngle.fromAzimuthAndDirection(PlaneAngleRadians.MINUS_PI_OVER_TWO, true, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, true); + checkCutAngle(CutAngle.fromAzimuthAndDirection(-PlaneAngleRadians.PI_OVER_TWO, true, TEST_PRECISION), + -PlaneAngleRadians.PI_OVER_TWO, true); checkCutAngle(CutAngle.fromAzimuthAndDirection(0.0, false, TEST_PRECISION), 0.0, false); checkCutAngle(CutAngle.fromAzimuthAndDirection(PlaneAngleRadians.PI, false, TEST_PRECISION), PlaneAngleRadians.PI, false); - checkCutAngle(CutAngle.fromAzimuthAndDirection(PlaneAngleRadians.MINUS_PI_OVER_TWO, false, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, false); + checkCutAngle(CutAngle.fromAzimuthAndDirection(-PlaneAngleRadians.PI_OVER_TWO, false, TEST_PRECISION), + -PlaneAngleRadians.PI_OVER_TWO, false); } @Test public void testFromPointAndDirection() { // arrange - Point1S pt = Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO); + Point1S pt = Point1S.of(-PlaneAngleRadians.PI_OVER_TWO); // act/assert checkCutAngle(CutAngle.fromPointAndDirection(Point1S.ZERO, true, TEST_PRECISION), @@ -70,14 +70,14 @@ public class CutAngleTest { checkCutAngle(CutAngle.fromPointAndDirection(Point1S.PI, true, TEST_PRECISION), PlaneAngleRadians.PI, true); checkCutAngle(CutAngle.fromPointAndDirection(pt, true, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, true); + -PlaneAngleRadians.PI_OVER_TWO, true); checkCutAngle(CutAngle.fromPointAndDirection(Point1S.ZERO, false, TEST_PRECISION), 0.0, false); checkCutAngle(CutAngle.fromPointAndDirection(Point1S.PI, false, TEST_PRECISION), PlaneAngleRadians.PI, false); checkCutAngle(CutAngle.fromPointAndDirection(pt, false, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, false); + -PlaneAngleRadians.PI_OVER_TWO, false); } @Test @@ -87,8 +87,8 @@ public class CutAngleTest { 0.0, true); checkCutAngle(CutAngle.createPositiveFacing(Point1S.PI, TEST_PRECISION), PlaneAngleRadians.PI, true); - checkCutAngle(CutAngle.createPositiveFacing(PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, true); + checkCutAngle(CutAngle.createPositiveFacing(-PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION), + -PlaneAngleRadians.PI_OVER_TWO, true); } @Test @@ -98,8 +98,8 @@ public class CutAngleTest { 0.0, false); checkCutAngle(CutAngle.createNegativeFacing(Point1S.PI, TEST_PRECISION), PlaneAngleRadians.PI, false); - checkCutAngle(CutAngle.createNegativeFacing(PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION), - PlaneAngleRadians.MINUS_PI_OVER_TWO, false); + checkCutAngle(CutAngle.createNegativeFacing(-PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION), + -PlaneAngleRadians.PI_OVER_TWO, false); } @Test @@ -121,13 +121,13 @@ public class CutAngleTest { checkOffset(zeroNeg, 0, 0); checkOffset(zeroNeg, PlaneAngleRadians.TWO_PI, 0); - checkOffset(zeroNeg, 2.5 * PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkOffset(zeroNeg, 2.5 * PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO); checkOffset(zeroNeg, PlaneAngleRadians.PI, -PlaneAngleRadians.PI); checkOffset(zeroNeg, 3.5 * PlaneAngleRadians.PI, -1.5 * PlaneAngleRadians.PI); checkOffset(negPiPos, 0, -PlaneAngleRadians.PI); checkOffset(negPiPos, PlaneAngleRadians.TWO_PI, -PlaneAngleRadians.PI); - checkOffset(negPiPos, 2.5 * PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkOffset(negPiPos, 2.5 * PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO); checkOffset(negPiPos, PlaneAngleRadians.PI, 0); checkOffset(negPiPos, 3.5 * PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO); @@ -135,10 +135,10 @@ public class CutAngleTest { checkOffset(piNeg, PlaneAngleRadians.TWO_PI, PlaneAngleRadians.PI); checkOffset(piNeg, 2.5 * PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO); checkOffset(piNeg, PlaneAngleRadians.PI, 0); - checkOffset(piNeg, 3.5 * PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkOffset(piNeg, 3.5 * PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO); - checkOffset(twoAndAHalfPiPos, 0, PlaneAngleRadians.MINUS_PI_OVER_TWO); - checkOffset(twoAndAHalfPiPos, PlaneAngleRadians.TWO_PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkOffset(twoAndAHalfPiPos, 0, -PlaneAngleRadians.PI_OVER_TWO); + checkOffset(twoAndAHalfPiPos, PlaneAngleRadians.TWO_PI, -PlaneAngleRadians.PI_OVER_TWO); checkOffset(twoAndAHalfPiPos, 2.5 * PlaneAngleRadians.PI, 0); checkOffset(twoAndAHalfPiPos, PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO); checkOffset(twoAndAHalfPiPos, 3.5 * PlaneAngleRadians.PI, PlaneAngleRadians.PI); @@ -157,19 +157,19 @@ public class CutAngleTest { PlaneAngleRadians.TWO_PI - 1e-11, PlaneAngleRadians.TWO_PI + 1e-11); checkClassify(zeroPos, HyperplaneLocation.PLUS, 0.5, 2.5 * PlaneAngleRadians.PI, - -0.5, PlaneAngleRadians.MINUS_PI_OVER_TWO); + -0.5, -PlaneAngleRadians.PI_OVER_TWO); checkClassify(zeroNeg, HyperplaneLocation.ON, 0, 1e-16, -1e-16, PlaneAngleRadians.TWO_PI - 1e-11, PlaneAngleRadians.TWO_PI + 1e-11); checkClassify(zeroNeg, HyperplaneLocation.MINUS, 0.5, 2.5 * PlaneAngleRadians.PI, - -0.5, PlaneAngleRadians.MINUS_PI_OVER_TWO); + -0.5, -PlaneAngleRadians.PI_OVER_TWO); checkClassify(negPiPos, HyperplaneLocation.ON, PlaneAngleRadians.PI, PlaneAngleRadians.PI + 1e-11); checkClassify(negPiPos, HyperplaneLocation.MINUS, 0.5, 2.5 * PlaneAngleRadians.PI, 0, 1e-11, PlaneAngleRadians.TWO_PI, PlaneAngleRadians.TWO_PI - 1e-11); - checkClassify(negPiPos, HyperplaneLocation.PLUS, -0.5, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkClassify(negPiPos, HyperplaneLocation.PLUS, -0.5, -PlaneAngleRadians.PI_OVER_TWO); } @Test @@ -222,7 +222,7 @@ public class CutAngleTest { // arrange CutAngle a = CutAngle.createPositiveFacing(0.0, TEST_PRECISION); CutAngle b = CutAngle.createNegativeFacing(0.0, TEST_PRECISION); - CutAngle c = CutAngle.createPositiveFacing(PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + CutAngle c = CutAngle.createPositiveFacing(-PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); // act/assert Assert.assertTrue(a.similarOrientation(a)); @@ -243,7 +243,7 @@ public class CutAngleTest { checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(1.5 * PlaneAngleRadians.PI), true, TEST_PRECISION).transform(transform), PlaneAngleRadians.TWO_PI, true); - checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), false, TEST_PRECISION).transform(transform), + checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), false, TEST_PRECISION).transform(transform), 0.0, false); } @@ -260,7 +260,7 @@ public class CutAngleTest { checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(1.5 * PlaneAngleRadians.PI), true, TEST_PRECISION).transform(transform), -1.5 * PlaneAngleRadians.PI, false); - checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), false, TEST_PRECISION).transform(transform), + checkCutAngle(CutAngle.fromPointAndDirection(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), false, TEST_PRECISION).transform(transform), PlaneAngleRadians.PI_OVER_TWO, true); } @@ -462,7 +462,7 @@ public class CutAngleTest { Assert.assertEquals(expected, sub.closest(Point1S.ZERO)); Assert.assertEquals(expected, sub.closest(Point1S.of(PlaneAngleRadians.PI_OVER_TWO))); Assert.assertEquals(expected, sub.closest(Point1S.PI)); - Assert.assertEquals(expected, sub.closest(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO))); + Assert.assertEquals(expected, sub.closest(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO))); Assert.assertEquals(expected, sub.closest(Point1S.of(PlaneAngleRadians.TWO_PI))); } diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Point1STest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Point1STest.java index 3db21eb..067fc3e 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Point1STest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Point1STest.java @@ -66,7 +66,7 @@ public class Point1STest { checkPoint(Point1S.of(PlaneAngle.ofDegrees(90)), PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); checkPoint(Point1S.of(PlaneAngle.ofTurns(0.5)), PlaneAngleRadians.PI, PlaneAngleRadians.PI); - checkPoint(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO), PlaneAngleRadians.MINUS_PI_OVER_TWO, 1.5 * PlaneAngleRadians.PI); + checkPoint(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO), -PlaneAngleRadians.PI_OVER_TWO, 1.5 * PlaneAngleRadians.PI); double base = PlaneAngleRadians.PI_OVER_TWO; for (int k = -3; k <= 3; ++k) { @@ -90,7 +90,7 @@ public class Point1STest { checkPoint(Point1S.from(PolarCoordinates.of(100, 0)), 0.0); checkPoint(Point1S.from(PolarCoordinates.of(1, PlaneAngleRadians.PI_OVER_TWO)), PlaneAngleRadians.PI_OVER_TWO); checkPoint(Point1S.from(PolarCoordinates.of(0.5, PlaneAngleRadians.PI)), PlaneAngleRadians.PI); - checkPoint(Point1S.from(PolarCoordinates.of(1e-4, PlaneAngleRadians.MINUS_PI_OVER_TWO)), 1.5 * PlaneAngleRadians.PI); + checkPoint(Point1S.from(PolarCoordinates.of(1e-4, -PlaneAngleRadians.PI_OVER_TWO)), 1.5 * PlaneAngleRadians.PI); } @Test @@ -410,13 +410,13 @@ public class Point1STest { checkPoint(p1.below(p1), -PlaneAngleRadians.TWO_PI); checkPoint(p2.below(p1), -1.5 * PlaneAngleRadians.PI); checkPoint(p3.below(p1), -PlaneAngleRadians.PI); - checkPoint(p4.below(p1), PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkPoint(p4.below(p1), -PlaneAngleRadians.PI_OVER_TWO); checkPoint(p5.below(p1), -PlaneAngleRadians.TWO_PI); checkPoint(p1.below(p3), 0.0); checkPoint(p2.below(p3), PlaneAngleRadians.PI_OVER_TWO); checkPoint(p3.below(p3), -PlaneAngleRadians.PI); - checkPoint(p4.below(p3), PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkPoint(p4.below(p3), -PlaneAngleRadians.PI_OVER_TWO); checkPoint(p5.below(p3), 0.0); } diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/RegionBSPTree1STest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/RegionBSPTree1STest.java index c42f8a6..4ef7ff7 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/RegionBSPTree1STest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/RegionBSPTree1STest.java @@ -180,12 +180,12 @@ public class RegionBSPTree1STest { public void testClassify() { // arrange RegionBSPTree1S tree = RegionBSPTree1S.fromInterval( - AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); + AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); // act/assert checkClassify(tree, RegionLocation.BOUNDARY, - PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, - PlaneAngleRadians.MINUS_PI_OVER_TWO - PlaneAngleRadians.TWO_PI, PlaneAngleRadians.PI_OVER_TWO + PlaneAngleRadians.TWO_PI); + -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, + -PlaneAngleRadians.PI_OVER_TWO - PlaneAngleRadians.TWO_PI, PlaneAngleRadians.PI_OVER_TWO + PlaneAngleRadians.TWO_PI); checkClassify(tree, RegionLocation.INSIDE, 0.0, 0.5, -0.5, PlaneAngleRadians.TWO_PI, 0.5 + PlaneAngleRadians.TWO_PI, -0.5 - PlaneAngleRadians.TWO_PI); @@ -277,7 +277,7 @@ public class RegionBSPTree1STest { public void testToIntervals_multipleIntervals() { // arrange RegionBSPTree1S tree = RegionBSPTree1S.empty(); - tree.add(AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); + tree.add(AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); tree.add(AngularInterval.of(PlaneAngleRadians.PI - 0.5, PlaneAngleRadians.PI, TEST_PRECISION)); tree.add(AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.PI + 0.5, TEST_PRECISION)); @@ -288,14 +288,14 @@ public class RegionBSPTree1STest { Assert.assertEquals(2, intervals.size()); checkInterval(intervals.get(0), PlaneAngleRadians.PI - 0.5, PlaneAngleRadians.PI + 0.5); - checkInterval(intervals.get(1), PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkInterval(intervals.get(1), -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); } @Test public void testToIntervals_multipleIntervals_complement() { // arrange RegionBSPTree1S tree = RegionBSPTree1S.empty(); - tree.add(AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); + tree.add(AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); tree.add(AngularInterval.of(PlaneAngleRadians.PI - 0.5, PlaneAngleRadians.PI, TEST_PRECISION)); tree.add(AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.PI + 0.5, TEST_PRECISION)); @@ -308,7 +308,7 @@ public class RegionBSPTree1STest { Assert.assertEquals(2, intervals.size()); checkInterval(intervals.get(0), PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI - 0.5); - checkInterval(intervals.get(1), PlaneAngleRadians.PI + 0.5, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkInterval(intervals.get(1), PlaneAngleRadians.PI + 0.5, -PlaneAngleRadians.PI_OVER_TWO); } @Test @@ -324,7 +324,7 @@ public class RegionBSPTree1STest { Assert.assertEquals(SplitLocation.NEITHER, tree.split(CutAngle.createPositiveFacing(PlaneAngleRadians.PI, TEST_PRECISION)).getLocation()); Assert.assertEquals(SplitLocation.NEITHER, - tree.split(CutAngle.createNegativeFacing(PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION)).getLocation()); + tree.split(CutAngle.createNegativeFacing(-PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)).getLocation()); Assert.assertEquals(SplitLocation.NEITHER, tree.split(CutAngle.createPositiveFacing(PlaneAngleRadians.TWO_PI, TEST_PRECISION)).getLocation()); } @@ -351,9 +351,9 @@ public class RegionBSPTree1STest { AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.TWO_PI, TEST_PRECISION) ); checkSimpleSplit( - tree.split(CutAngle.createNegativeFacing(PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION)), - AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.TWO_PI, TEST_PRECISION), - AngularInterval.of(0, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION) + tree.split(CutAngle.createNegativeFacing(-PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)), + AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.TWO_PI, TEST_PRECISION), + AngularInterval.of(0, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION) ); checkSimpleSplit( tree.split(CutAngle.createPositiveFacing(PlaneAngleRadians.TWO_PI - 1e-6, TEST_PRECISION)), @@ -396,7 +396,7 @@ public class RegionBSPTree1STest { @Test public void testSplit_singleInterval() { // arrange - AngularInterval interval = AngularInterval.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION); + AngularInterval interval = AngularInterval.of(PlaneAngleRadians.PI_OVER_TWO, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION); RegionBSPTree1S tree = interval.toTree(); // act @@ -424,7 +424,7 @@ public class RegionBSPTree1STest { checkSimpleSplit( tree.split(CutAngle.createNegativeFacing(PlaneAngleRadians.PI, TEST_PRECISION)), - AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION), + AngularInterval.of(PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION), AngularInterval.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI, TEST_PRECISION) ); } @@ -432,7 +432,7 @@ public class RegionBSPTree1STest { @Test public void testSplit_singleIntervalSplitIntoTwoIntervalsOnSameSide() { // arrange - RegionBSPTree1S tree = AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).toTree(); + RegionBSPTree1S tree = AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION).toTree(); CutAngle cut = CutAngle.createPositiveFacing(0, TEST_PRECISION); @@ -448,7 +448,7 @@ public class RegionBSPTree1STest { RegionBSPTree1S plus = split.getPlus(); List plusIntervals = plus.toIntervals(); Assert.assertEquals(1, plusIntervals.size()); - checkInterval(plusIntervals.get(0), PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); + checkInterval(plusIntervals.get(0), -PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO); } @Test @@ -456,7 +456,7 @@ public class RegionBSPTree1STest { // arrange RegionBSPTree1S tree = RegionBSPTree1S.empty(); tree.add(AngularInterval.of(PlaneAngleRadians.TWO_PI - 1, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); - tree.add(AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION)); + tree.add(AngularInterval.of(PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); CutAngle cut = CutAngle.createNegativeFacing(1, TEST_PRECISION); @@ -470,7 +470,7 @@ public class RegionBSPTree1STest { List minusIntervals = minus.toIntervals(); Assert.assertEquals(3, minusIntervals.size()); checkInterval(minusIntervals.get(0), 1, PlaneAngleRadians.PI_OVER_TWO); - checkInterval(minusIntervals.get(1), PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + checkInterval(minusIntervals.get(1), PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO); checkInterval(minusIntervals.get(2), PlaneAngleRadians.TWO_PI - 1, 0); RegionBSPTree1S plus = split.getPlus(); @@ -670,7 +670,7 @@ public class RegionBSPTree1STest { @Test public void testRegionProperties_singleInterval_wrapsZero() { // arrange - RegionBSPTree1S tree = AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI, + RegionBSPTree1S tree = AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI, TEST_PRECISION).toTree(); // act/assert @@ -793,18 +793,18 @@ public class RegionBSPTree1STest { public void testProject_withIntervals() { // arrange RegionBSPTree1S tree = RegionBSPTree1S.empty(); - tree.add(AngularInterval.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); + tree.add(AngularInterval.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); tree.add(AngularInterval.of(PlaneAngleRadians.PI - 1, PlaneAngleRadians.PI + 1, TEST_PRECISION)); // act/assert - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, - tree.project(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO - 0.1)).getAzimuth(), TEST_EPS); - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, - tree.project(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO)).getAzimuth(), TEST_EPS); - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, - tree.project(Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO + 0.1)).getAzimuth(), TEST_EPS); - - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, tree.project(Point1S.of(-0.1)).getAzimuth(), TEST_EPS); + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, + tree.project(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO - 0.1)).getAzimuth(), TEST_EPS); + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, + tree.project(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO)).getAzimuth(), TEST_EPS); + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, + tree.project(Point1S.of(-PlaneAngleRadians.PI_OVER_TWO + 0.1)).getAzimuth(), TEST_EPS); + + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, tree.project(Point1S.of(-0.1)).getAzimuth(), TEST_EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, tree.project(Point1S.ZERO).getAzimuth(), TEST_EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, tree.project(Point1S.of(0.1)).getAzimuth(), TEST_EPS); diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Transform1STest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Transform1STest.java index e969dca..f5a6122 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Transform1STest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/oned/Transform1STest.java @@ -32,7 +32,7 @@ public class Transform1STest { private static final Point1S PI = Point1S.of(PlaneAngleRadians.PI); - private static final Point1S MINUS_HALF_PI = Point1S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO); + private static final Point1S MINUS_HALF_PI = Point1S.of(-PlaneAngleRadians.PI_OVER_TWO); @Test public void testIdentity() { diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/AbstractGreatArcPathConnectorTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/AbstractGreatArcPathConnectorTest.java index 1e42015..89f8d55 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/AbstractGreatArcPathConnectorTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/AbstractGreatArcPathConnectorTest.java @@ -171,8 +171,8 @@ public class AbstractGreatArcPathConnectorTest { .arc(0, PlaneAngleRadians.PI); GreatArc separateArc = GreatArc.fromPoints( - Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, 0.7 * PlaneAngleRadians.PI), - Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, 0.8 * PlaneAngleRadians.PI), + Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, 0.7 * PlaneAngleRadians.PI), + Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, 0.8 * PlaneAngleRadians.PI), TEST_PRECISION); // act diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/ConvexArea2STest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/ConvexArea2STest.java index 7560311..65b4018 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/ConvexArea2STest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/ConvexArea2STest.java @@ -604,7 +604,7 @@ public class ConvexArea2STest { SphericalTestUtils.checkClassify(area, RegionLocation.BOUNDARY, Point2S.PLUS_I, Point2S.MINUS_J, Point2S.PLUS_K, - Point2S.of(0, 0.25 * PlaneAngleRadians.PI), Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, 0.304 * PlaneAngleRadians.PI), + Point2S.of(0, 0.25 * PlaneAngleRadians.PI), Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, 0.304 * PlaneAngleRadians.PI), Point2S.of(-0.25 * PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO)); SphericalTestUtils.checkClassify(area, RegionLocation.OUTSIDE, diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatArcTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatArcTest.java index 6160a9c..07d5d09 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatArcTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatArcTest.java @@ -213,7 +213,7 @@ public class GreatArcTest { public void testTransform() { // arrange GreatArc arc = GreatCircle.fromPoints(Point2S.PLUS_K, Point2S.MINUS_I, TEST_PRECISION) - .arc(PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO); + .arc(PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO); Transform2S t = Transform2S.createRotation(Point2S.PLUS_I, PlaneAngleRadians.PI_OVER_TWO) .reflect(Point2S.of(-0.25 * PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO)); diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java index f9c0200..4db3bbb 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/GreatCircleTest.java @@ -134,17 +134,17 @@ public class GreatCircleTest { // --- act/assert // on circle - for (double polar = PlaneAngleRadians.MINUS_PI_OVER_TWO; polar <= PlaneAngleRadians.PI_OVER_TWO; polar += 0.1) { + for (double polar = -PlaneAngleRadians.PI_OVER_TWO; polar <= PlaneAngleRadians.PI_OVER_TWO; polar += 0.1) { Assert.assertEquals(0, circle.offset(Point2S.of(PlaneAngleRadians.PI_OVER_TWO, polar)), TEST_EPS); - Assert.assertEquals(0, circle.offset(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, polar)), TEST_EPS); + Assert.assertEquals(0, circle.offset(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, polar)), TEST_EPS); } // +1/-1 Assert.assertEquals(-1, circle.offset(Point2S.of(PlaneAngleRadians.PI_OVER_TWO + 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); - Assert.assertEquals(1, circle.offset(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO + 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); + Assert.assertEquals(1, circle.offset(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO + 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); // poles - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, circle.offset(Point2S.of(PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, circle.offset(Point2S.of(PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, circle.offset(Point2S.of(0.0, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); } @@ -174,7 +174,7 @@ public class GreatCircleTest { Assert.assertEquals(0.25 * PlaneAngleRadians.PI, circle.offset(Vector3D.of(1, 0, -1)), TEST_EPS); // poles - Assert.assertEquals(PlaneAngleRadians.MINUS_PI_OVER_TWO, circle.offset(Vector3D.Unit.MINUS_X), TEST_EPS); + Assert.assertEquals(-PlaneAngleRadians.PI_OVER_TWO, circle.offset(Vector3D.Unit.MINUS_X), TEST_EPS); Assert.assertEquals(PlaneAngleRadians.PI_OVER_TWO, circle.offset(Vector3D.Unit.PLUS_X), TEST_EPS); } @@ -248,7 +248,7 @@ public class GreatCircleTest { SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.PLUS_Z, circle.vectorAt(0.0), TEST_EPS); SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.PLUS_Y, circle.vectorAt(PlaneAngleRadians.PI_OVER_TWO), TEST_EPS); SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.MINUS_Z, circle.vectorAt(PlaneAngleRadians.PI), TEST_EPS); - SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.MINUS_Y, circle.vectorAt(PlaneAngleRadians.MINUS_PI_OVER_TWO), TEST_EPS); + SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.MINUS_Y, circle.vectorAt(-PlaneAngleRadians.PI_OVER_TWO), TEST_EPS); SphericalTestUtils.assertVectorsEqual(Vector3D.Unit.PLUS_Z, circle.vectorAt(PlaneAngleRadians.TWO_PI), TEST_EPS); } @@ -266,12 +266,12 @@ public class GreatCircleTest { SphericalTestUtils.assertPointsEqual(Point2S.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), circle.project(Point2S.of(PlaneAngleRadians.PI_OVER_TWO - 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); - SphericalTestUtils.assertPointsEqual(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), - circle.project(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); - SphericalTestUtils.assertPointsEqual(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), - circle.project(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO + 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); - SphericalTestUtils.assertPointsEqual(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), - circle.project(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO - 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); + SphericalTestUtils.assertPointsEqual(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), + circle.project(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); + SphericalTestUtils.assertPointsEqual(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), + circle.project(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO + 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); + SphericalTestUtils.assertPointsEqual(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), + circle.project(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO - 1, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); } @Test diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/RegionBSPTree2STest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/RegionBSPTree2STest.java index b52d99d..9dfcd66 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/RegionBSPTree2STest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/RegionBSPTree2STest.java @@ -290,7 +290,7 @@ public class RegionBSPTree2STest { SphericalTestUtils.assertPointsEq(Point2S.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO), tree.project(Point2S.of(PlaneAngleRadians.PI_OVER_TWO, PlaneAngleRadians.PI_OVER_TWO + 0.2)), TEST_EPS); SphericalTestUtils.assertPointsEq(Point2S.PLUS_K, - tree.project(Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, 0.2)), TEST_EPS); + tree.project(Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, 0.2)), TEST_EPS); SphericalTestUtils.assertPointsEq(Point2S.PLUS_I, tree.project(Point2S.of(-0.5, PlaneAngleRadians.PI_OVER_TWO)), TEST_EPS); @@ -564,7 +564,7 @@ public class RegionBSPTree2STest { SphericalTestUtils.checkClassify(tree, RegionLocation.BOUNDARY, Point2S.PLUS_I, Point2S.MINUS_J, Point2S.PLUS_K, - Point2S.of(0, 0.25 * PlaneAngleRadians.PI), Point2S.of(PlaneAngleRadians.MINUS_PI_OVER_TWO, 0.304 * PlaneAngleRadians.PI), + Point2S.of(0, 0.25 * PlaneAngleRadians.PI), Point2S.of(-PlaneAngleRadians.PI_OVER_TWO, 0.304 * PlaneAngleRadians.PI), Point2S.of(-0.25 * PlaneAngleRadians.PI, PlaneAngleRadians.PI_OVER_TWO)); SphericalTestUtils.checkClassify(tree, RegionLocation.OUTSIDE, diff --git a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/SubGreatCircleTest.java b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/SubGreatCircleTest.java index 3b431b5..9aa57d7 100644 --- a/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/SubGreatCircleTest.java +++ b/commons-geometry-spherical/src/test/java/org/apache/commons/geometry/spherical/twod/SubGreatCircleTest.java @@ -141,7 +141,7 @@ public class SubGreatCircleTest { // arrange GreatCircle circle = GreatCircle.fromPoints(Point2S.PLUS_K, Point2S.MINUS_I, TEST_PRECISION); RegionBSPTree1S region = RegionBSPTree1S.empty(); - region.add(AngularInterval.of(PlaneAngleRadians.PI, PlaneAngleRadians.MINUS_PI_OVER_TWO, TEST_PRECISION)); + region.add(AngularInterval.of(PlaneAngleRadians.PI, -PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); region.add(AngularInterval.of(0, PlaneAngleRadians.PI_OVER_TWO, TEST_PRECISION)); Transform2S t = Transform2S.createRotation(Point2S.PLUS_I, PlaneAngleRadians.PI_OVER_TWO)