[prev in list] [next in list] [prev in thread] [next in thread]
List: jakarta-commons-dev
Subject: [commons-geometry] 02/02: Removed usage of constants prefixed with "MINUS".
From: erans () apache ! org
Date: 2019-11-30 3:30:59
Message-ID: 20191130033058.4CAC38B687 () gitbox ! apache ! org
[Download RAW message or body]
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 <gilles@harfang.homelinux.org>
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<Segment> 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<Segment> 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<AngularInterval> 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<AngularInterval> 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)
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic