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 c0e9ef1215af5459e9efd348f85287bceab02ec8 Author: Matt Juntunen <[email protected]> AuthorDate: Thu Dec 20 21:42:24 2018 -0500 GEOMETRY-31: standardizing method names with commons-numbers --- .../org/apache/commons/geometry/core/Vector.java | 10 +-- .../geometry/euclidean/internal/Vectors.java | 2 +- .../euclidean/oned/AffineTransformMatrix1D.java | 2 +- .../commons/geometry/euclidean/oned/Vector1D.java | 10 +-- .../euclidean/threed/AffineTransformMatrix3D.java | 2 +- .../commons/geometry/euclidean/threed/Line.java | 6 +- .../commons/geometry/euclidean/threed/Plane.java | 2 +- .../geometry/euclidean/threed/Vector3D.java | 16 ++-- .../threed/rotation/QuaternionRotation.java | 6 +- .../euclidean/threed/rotation/Rotation3D.java | 2 +- .../euclidean/twod/AffineTransformMatrix2D.java | 2 +- .../commons/geometry/euclidean/twod/Vector2D.java | 12 +-- .../oned/AffineTransformMatrix1DTest.java | 40 +++++----- .../geometry/euclidean/oned/Vector1DTest.java | 24 +++--- .../threed/AffineTransformMatrix3DTest.java | 46 +++++------ .../euclidean/threed/PolyhedronsSetTest.java | 6 +- .../geometry/euclidean/threed/Vector3DTest.java | 52 ++++++------ .../threed/rotation/QuaternionRotationTest.java | 92 +++++++++++----------- .../twod/AffineTransformMatrix2DTest.java | 48 +++++------ .../geometry/euclidean/twod/Vector2DTest.java | 38 ++++----- .../hull/ConvexHullGenerator2DAbstractTest.java | 4 +- .../spherical/twod/PropertiesComputer.java | 2 +- .../spherical/twod/SphericalPolygonsSet.java | 2 +- 23 files changed, 213 insertions(+), 213 deletions(-) diff --git a/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Vector.java b/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Vector.java index 87b8b82..1b7aea0 100644 --- a/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Vector.java +++ b/commons-geometry-core/src/main/java/org/apache/commons/geometry/core/Vector.java @@ -45,14 +45,14 @@ public interface Vector<V extends Vector<V>> extends Spatial { * @see <a href="http://mathworld.wolfram.com/L2-Norm.html";>L2 Norm</a> * @return L<sub>2</sub> norm for the vector */ - double getNorm(); + double norm(); /** Get the square of the L<sub>2</sub> norm (also known as the Euclidean norm) * for the vector. This is equal to the sum of the squares of all vector components. - * @see #getNorm() + * @see #norm() * @return square of the L<sub>2</sub> norm for the vector */ - double getNormSq(); + double normSq(); /** Returns a vector with the same direction but with the given * norm. This is equivalent to calling {@code vec.normalize().scalarMultiply(mag)} @@ -104,7 +104,7 @@ public interface Vector<V extends Vector<V>> extends Spatial { * @param a scalar * @return a new vector */ - V scalarMultiply(double a); + V multiply(double a); /** Compute the distance between the instance and another vector. * @param v second vector @@ -116,7 +116,7 @@ public interface Vector<V extends Vector<V>> extends Spatial { * <p>Calling this method is equivalent to calling: * <code>q.subtract(p).getNormSq()</code> except that no intermediate * vector is built</p> - * @see #getNormSq() + * @see #normSq() * @param v second vector * @return the square of the distance between the instance and p */ diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/internal/Vectors.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/internal/Vectors.java index ddf5883..fa5cc8f 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/internal/Vectors.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/internal/Vectors.java @@ -60,7 +60,7 @@ public final class Vectors { * or zero */ public static double checkedNorm(final Vector<?> vec) { - return checkedNorm(vec.getNorm()); + return checkedNorm(vec.norm()); } /** Get the L<sub>2</sub> norm (commonly known as the Euclidean norm) for the vector diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1D.java index 761ebad..1a6aaf9 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1D.java @@ -201,7 +201,7 @@ public final class AffineTransformMatrix1D implements AffineTransformMatrix<Vect * @return inverse transform * @throws NonInvertibleTransformException if the transform matrix cannot be inverted */ - public AffineTransformMatrix1D getInverse() { + public AffineTransformMatrix1D inverse() { final double det = this.m00; diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java index dc3b741..9d59e6b 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/oned/Vector1D.java @@ -115,13 +115,13 @@ public class Vector1D extends EuclideanVector<Vector1D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return Vectors.norm(x); } /** {@inheritDoc} */ @Override - public double getNormSq() { + public double normSq() { return Vectors.normSq(x); } @@ -170,7 +170,7 @@ public class Vector1D extends EuclideanVector<Vector1D> { /** {@inheritDoc} */ @Override - public Vector1D scalarMultiply(double a) { + public Vector1D multiply(double a) { return new Vector1D(a * x); } @@ -396,7 +396,7 @@ public class Vector1D extends EuclideanVector<Vector1D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return 1; } @@ -409,7 +409,7 @@ public class Vector1D extends EuclideanVector<Vector1D> { /** {@inheritDoc} */ @Override public Vector1D withNorm(final double mag) { - return scalarMultiply(mag); + return multiply(mag); } } } diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3D.java index 0103e8a..cd25f7b 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3D.java @@ -316,7 +316,7 @@ public final class AffineTransformMatrix3D implements AffineTransformMatrix<Vect * @return inverse transform * @throws NonInvertibleTransformException if the transform matrix cannot be inverted */ - public AffineTransformMatrix3D getInverse() { + public AffineTransformMatrix3D inverse() { // Our full matrix is 4x4 but we can significantly reduce the amount of computations // needed here since we know that our last row is [0 0 0 1]. diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line.java index 87dba2b..f650215 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Line.java @@ -71,7 +71,7 @@ public class Line implements Embedding<Vector3D, Vector1D> { */ public void reset(final Vector3D p1, final Vector3D p2) { final Vector3D delta = p2.subtract(p1); - final double norm2 = delta.getNormSq(); + final double norm2 = delta.normSq(); if (norm2 == 0.0) { throw new IllegalArgumentException("Points are equal"); } @@ -175,7 +175,7 @@ public class Line implements Embedding<Vector3D, Vector1D> { public double distance(final Vector3D p) { final Vector3D d = p.subtract(zero); final Vector3D n = Vector3D.linearCombination(1.0, d, -d.dotProduct(direction), direction); - return n.getNorm(); + return n.norm(); } /** Compute the shortest distance between the instance and another line. @@ -185,7 +185,7 @@ public class Line implements Embedding<Vector3D, Vector1D> { public double distance(final Line line) { final Vector3D normal = direction.crossProduct(line.direction); - final double n = normal.getNorm(); + final double n = normal.norm(); if (n < Precision.SAFE_MIN) { // lines are parallel return distance(line.zero); diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java index 8e97a64..963b76d 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Plane.java @@ -339,7 +339,7 @@ public class Plane implements Hyperplane<Vector3D>, Embedding<Vector3D, Vector2D */ public Line intersection(final Plane other) { final Vector3D direction = w.crossProduct(other.w); - if (direction.getNorm() < tolerance) { + if (direction.norm() < tolerance) { return null; } final Vector3D point = intersection(this, other, new Plane(direction, tolerance)); diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java index 2add39c..4ff6dff 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/Vector3D.java @@ -162,13 +162,13 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return Vectors.norm(x, y, z); } /** {@inheritDoc} */ @Override - public double getNormSq() { + public double normSq() { return Vectors.normSq(x, y, z); } @@ -238,7 +238,7 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { /** {@inheritDoc} */ @Override - public Vector3D scalarMultiply(double a) { + public Vector3D multiply(double a) { return new Vector3D(a * x, a * y, a * z); } @@ -292,9 +292,9 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { // the vectors are almost aligned, compute using the sine Vector3D cross = crossProduct(v); if (dot >= 0) { - return Math.asin(cross.getNorm() / normProduct); + return Math.asin(cross.norm() / normProduct); } - return Math.PI - Math.asin(cross.getNorm() / normProduct); + return Math.PI - Math.asin(cross.norm() / normProduct); } // the vectors are sufficiently separated to use the cosine @@ -447,7 +447,7 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { // directly. This will produce the same error result as checking the actual norm since // Math.sqrt(0.0) == 0.0, Math.sqrt(Double.NaN) == Double.NaN and // Math.sqrt(Double.POSITIVE_INFINITY) == Double.POSITIVE_INFINITY. - final double baseMagSq = Vectors.checkedNorm(base.getNormSq()); + final double baseMagSq = Vectors.checkedNorm(base.normSq()); final double scale = aDotB / baseMagSq; @@ -607,7 +607,7 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return 1; } @@ -620,7 +620,7 @@ public class Vector3D extends MultiDimensionalEuclideanVector<Vector3D> { /** {@inheritDoc} */ @Override public Vector3D withNorm(final double mag) { - return scalarMultiply(mag); + return multiply(mag); } } } 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 b1c86ce..f9f51c2 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 @@ -118,7 +118,7 @@ public final class QuaternionRotation implements Rotation3D, Serializable { * @return the negation (inverse) of the rotation */ @Override - public QuaternionRotation getInverse() { + public QuaternionRotation inverse() { return new QuaternionRotation(quat.conjugate()); } @@ -382,7 +382,7 @@ public final class QuaternionRotation implements Rotation3D, Serializable { // if it were the first rotation in the inverse (which it would be). final Vector3D vec3 = apply(axis3); - final Vector3D invVec1 = getInverse().apply(axis1); + final Vector3D invVec1 = inverse().apply(axis1); final double angle2Sin = vec3.dotProduct(axis2.crossProduct(axis3)); @@ -448,7 +448,7 @@ public final class QuaternionRotation implements Rotation3D, Serializable { final Vector3D crossAxis = axis1.crossProduct(axis2); final Vector3D vec1 = apply(axis1); - final Vector3D invVec1 = getInverse().apply(axis1); + final Vector3D invVec1 = inverse().apply(axis1); final double angle2Cos = vec1.dotProduct(axis1); diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/Rotation3D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/Rotation3D.java index 40a75b2..9b96ee8 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/Rotation3D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/threed/rotation/Rotation3D.java @@ -60,7 +60,7 @@ public interface Rotation3D extends Transform<Vector3D, Vector2D> { /** Get the inverse rotation. * @return the inverse rotation. */ - Rotation3D getInverse(); + Rotation3D inverse(); /** {@inheritDoc} * This operation is not supported. See GEOMETRY-24. diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2D.java index 421e7dd..0f7e416 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/AffineTransformMatrix2D.java @@ -276,7 +276,7 @@ public final class AffineTransformMatrix2D implements AffineTransformMatrix<Vect * @return inverse transform * @throws NonInvertibleTransformException if the transform matrix cannot be inverted */ - public AffineTransformMatrix2D getInverse() { + public AffineTransformMatrix2D inverse() { // Our full matrix is 3x3 but we can significantly reduce the amount of computations // needed here since we know that our last row is [0 0 1]. diff --git a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java index 2fa8784..4949335 100644 --- a/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java +++ b/commons-geometry-euclidean/src/main/java/org/apache/commons/geometry/euclidean/twod/Vector2D.java @@ -142,13 +142,13 @@ public class Vector2D extends MultiDimensionalEuclideanVector<Vector2D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return Vectors.norm(x, y); } /** {@inheritDoc} */ @Override - public double getNormSq() { + public double normSq() { return Vectors.normSq(x, y); } @@ -201,7 +201,7 @@ public class Vector2D extends MultiDimensionalEuclideanVector<Vector2D> { /** {@inheritDoc} */ @Override - public Vector2D scalarMultiply(double a) { + public Vector2D multiply(double a) { return new Vector2D(a * x, a * y); } @@ -397,7 +397,7 @@ public class Vector2D extends MultiDimensionalEuclideanVector<Vector2D> { // directly. This will produce the same error result as checking the actual norm since // Math.sqrt(0.0) == 0.0, Math.sqrt(Double.NaN) == Double.NaN and // Math.sqrt(Double.POSITIVE_INFINITY) == Double.POSITIVE_INFINITY. - final double baseMagSq = Vectors.checkedNorm(base.getNormSq()); + final double baseMagSq = Vectors.checkedNorm(base.normSq()); final double scale = aDotB / baseMagSq; @@ -550,7 +550,7 @@ public class Vector2D extends MultiDimensionalEuclideanVector<Vector2D> { /** {@inheritDoc} */ @Override - public double getNorm() { + public double norm() { return 1; } @@ -563,7 +563,7 @@ public class Vector2D extends MultiDimensionalEuclideanVector<Vector2D> { /** {@inheritDoc} */ @Override public Vector2D withNorm(final double mag) { - return scalarMultiply(mag); + return multiply(mag); } } } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1DTest.java index fae0fb5..ef5022d 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/AffineTransformMatrix1DTest.java @@ -427,7 +427,7 @@ public class AffineTransformMatrix1DTest { Vector1D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -469,7 +469,7 @@ public class AffineTransformMatrix1DTest { Vector1D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -477,9 +477,9 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_identity() { + public void testInverse_identity() { // act - AffineTransformMatrix1D inverse = AffineTransformMatrix1D.identity().getInverse(); + AffineTransformMatrix1D inverse = AffineTransformMatrix1D.identity().inverse(); // assert double[] expected = { 1, 0 }; @@ -487,11 +487,11 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_multiplyByInverse_producesIdentity() { + public void testInverse_multiplyByInverse_producesIdentity() { // arrange AffineTransformMatrix1D a = AffineTransformMatrix1D.of(1, 3); - AffineTransformMatrix1D inv = a.getInverse(); + AffineTransformMatrix1D inv = a.inverse(); // act AffineTransformMatrix1D result = inv.multiply(a); @@ -502,12 +502,12 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_translate() { + public void testInverse_translate() { // arrange AffineTransformMatrix1D transform = AffineTransformMatrix1D.createTranslation(3); // act - AffineTransformMatrix1D inverse = transform.getInverse(); + AffineTransformMatrix1D inverse = transform.inverse(); // assert double[] expected = { 1, -3 }; @@ -515,12 +515,12 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_scale() { + public void testInverse_scale() { // arrange AffineTransformMatrix1D transform = AffineTransformMatrix1D.createScale(10); // act - AffineTransformMatrix1D inverse = transform.getInverse(); + AffineTransformMatrix1D inverse = transform.inverse(); // assert double[] expected = { 0.1, 0 }; @@ -528,7 +528,7 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_undoesOriginalTransform_translationAndScale() { + public void testInverse_undoesOriginalTransform_translationAndScale() { // arrange Vector1D v1 = Vector1D.ZERO; Vector1D v2 = Vector1D.ONE; @@ -542,7 +542,7 @@ public class AffineTransformMatrix1DTest { .scale(2) .translate(x / 3); - AffineTransformMatrix1D inverse = transform.getInverse(); + AffineTransformMatrix1D inverse = transform.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, inverse.apply(transform.apply(v1)), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, inverse.apply(transform.apply(v2)), EPS); @@ -552,34 +552,34 @@ public class AffineTransformMatrix1DTest { } @Test - public void testGetInverse_nonInvertible() { + public void testInverse_nonInvertible() { // act/assert GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(0, 0).getInverse(); + AffineTransformMatrix1D.of(0, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is 0.0"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(Double.NaN, 0).getInverse(); + AffineTransformMatrix1D.of(Double.NaN, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is NaN"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(Double.NEGATIVE_INFINITY, 0.0).getInverse(); + AffineTransformMatrix1D.of(Double.NEGATIVE_INFINITY, 0.0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is -Infinity"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(Double.POSITIVE_INFINITY, 0).getInverse(); + AffineTransformMatrix1D.of(Double.POSITIVE_INFINITY, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is Infinity"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(1, Double.NaN).getInverse(); + AffineTransformMatrix1D.of(1, Double.NaN).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: NaN"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(1, Double.NEGATIVE_INFINITY).getInverse(); + AffineTransformMatrix1D.of(1, Double.NEGATIVE_INFINITY).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: -Infinity"); GeometryTestUtils.assertThrows(() -> { - AffineTransformMatrix1D.of(1, Double.POSITIVE_INFINITY).getInverse(); + AffineTransformMatrix1D.of(1, Double.POSITIVE_INFINITY).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: Infinity"); } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/Vector1DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/Vector1DTest.java index 7a74df8..fda735c 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/Vector1DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/oned/Vector1DTest.java @@ -105,17 +105,17 @@ public class Vector1DTest { @Test public void testNorm() { // act/assert - Assert.assertEquals(0.0, Vector1D.ZERO.getNorm(), TEST_TOLERANCE); - Assert.assertEquals(3.0, Vector1D.of(3).getNorm(), TEST_TOLERANCE); - Assert.assertEquals(3.0, Vector1D.of(-3).getNorm(), TEST_TOLERANCE); + Assert.assertEquals(0.0, Vector1D.ZERO.norm(), TEST_TOLERANCE); + Assert.assertEquals(3.0, Vector1D.of(3).norm(), TEST_TOLERANCE); + Assert.assertEquals(3.0, Vector1D.of(-3).norm(), TEST_TOLERANCE); } @Test public void testNormSq() { // act/assert - Assert.assertEquals(0.0, Vector1D.of(0).getNormSq(), TEST_TOLERANCE); - Assert.assertEquals(9.0, Vector1D.of(3).getNormSq(), TEST_TOLERANCE); - Assert.assertEquals(9.0, Vector1D.of(-3).getNormSq(), TEST_TOLERANCE); + Assert.assertEquals(0.0, Vector1D.of(0).normSq(), TEST_TOLERANCE); + Assert.assertEquals(9.0, Vector1D.of(3).normSq(), TEST_TOLERANCE); + Assert.assertEquals(9.0, Vector1D.of(-3).normSq(), TEST_TOLERANCE); } @Test @@ -154,7 +154,7 @@ public class Vector1DTest { for (double mag = -10.0; mag <= 10.0; ++mag) { - Assert.assertEquals(Math.abs(mag), v.withNorm(mag).getNorm(), TEST_TOLERANCE); + Assert.assertEquals(Math.abs(mag), v.withNorm(mag).norm(), TEST_TOLERANCE); } } @@ -262,11 +262,11 @@ public class Vector1DTest { @Test public void testScalarMultiply() { // act/assert - checkVector(Vector1D.of(1).scalarMultiply(3), 3); - checkVector(Vector1D.of(1).scalarMultiply(-3), -3); + checkVector(Vector1D.of(1).multiply(3), 3); + checkVector(Vector1D.of(1).multiply(-3), -3); - checkVector(Vector1D.of(1.5).scalarMultiply(7), 10.5); - checkVector(Vector1D.of(-1.5).scalarMultiply(7), -10.5); + checkVector(Vector1D.of(1.5).multiply(7), 10.5); + checkVector(Vector1D.of(-1.5).multiply(7), -10.5); } @Test @@ -280,7 +280,7 @@ public class Vector1DTest { Assert.assertEquals(5.0, v1.distance(v2), TEST_TOLERANCE); Assert.assertEquals(5.0, v2.distance(v1), TEST_TOLERANCE); - Assert.assertEquals(v1.subtract(v2).getNorm(), v1.distance(v2), TEST_TOLERANCE); + Assert.assertEquals(v1.subtract(v2).norm(), v1.distance(v2), TEST_TOLERANCE); Assert.assertEquals(0.0, Vector1D.of(-1).distance(Vector1D.of(-1)), TEST_TOLERANCE); } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3DTest.java index 115b114..2f4bfa9 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/AffineTransformMatrix3DTest.java @@ -443,7 +443,7 @@ public class AffineTransformMatrix3DTest { runWithCoordinates((x, y, z) -> { Vector3D vec = Vector3D.of(x, y, z); - Vector3D expectedVec = StandardRotations.PLUS_Z_HALF_PI.apply(vec.scalarMultiply(scaleFactor).subtract(center)).add(center); + Vector3D expectedVec = StandardRotations.PLUS_Z_HALF_PI.apply(vec.multiply(scaleFactor).subtract(center)).add(center); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); }); @@ -641,7 +641,7 @@ public class AffineTransformMatrix3DTest { Vector3D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -695,7 +695,7 @@ public class AffineTransformMatrix3DTest { Vector3D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -703,9 +703,9 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_identity() { + public void testInverse_identity() { // act - AffineTransformMatrix3D inverse = AffineTransformMatrix3D.identity().getInverse(); + AffineTransformMatrix3D inverse = AffineTransformMatrix3D.identity().inverse(); // assert double[] expected = { @@ -717,7 +717,7 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_multiplyByInverse_producesIdentity() { + public void testInverse_multiplyByInverse_producesIdentity() { // arrange AffineTransformMatrix3D a = AffineTransformMatrix3D.of( 1, 3, 7, 8, @@ -725,7 +725,7 @@ public class AffineTransformMatrix3DTest { 5, 6, 10, 11 ); - AffineTransformMatrix3D inv = a.getInverse(); + AffineTransformMatrix3D inv = a.inverse(); // act AffineTransformMatrix3D result = inv.multiply(a); @@ -740,12 +740,12 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_translate() { + public void testInverse_translate() { // arrange AffineTransformMatrix3D transform = AffineTransformMatrix3D.createTranslation(1, -2, 4); // act - AffineTransformMatrix3D inverse = transform.getInverse(); + AffineTransformMatrix3D inverse = transform.inverse(); // assert double[] expected = { @@ -757,12 +757,12 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_scale() { + public void testInverse_scale() { // arrange AffineTransformMatrix3D transform = AffineTransformMatrix3D.createScale(10, -2, 4); // act - AffineTransformMatrix3D inverse = transform.getInverse(); + AffineTransformMatrix3D inverse = transform.inverse(); // assert double[] expected = { @@ -774,7 +774,7 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_rotate() { + public void testInverse_rotate() { // arrange Vector3D center = Vector3D.of(1, 2, 3); QuaternionRotation rotation = QuaternionRotation.fromAxisAngle(Vector3D.PLUS_Z, Geometry.HALF_PI); @@ -782,7 +782,7 @@ public class AffineTransformMatrix3DTest { AffineTransformMatrix3D transform = AffineTransformMatrix3D.createRotation(center, rotation); // act - AffineTransformMatrix3D inverse = transform.getInverse(); + AffineTransformMatrix3D inverse = transform.inverse(); // assert double[] expected = { @@ -794,7 +794,7 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_undoesOriginalTransform() { + public void testInverse_undoesOriginalTransform() { // arrange Vector3D v1 = Vector3D.ZERO; Vector3D v2 = Vector3D.PLUS_X; @@ -812,7 +812,7 @@ public class AffineTransformMatrix3DTest { .rotate(center, rotation) .translate(x / 3, y / 3, z / 3); - AffineTransformMatrix3D inverse = transform.getInverse(); + AffineTransformMatrix3D inverse = transform.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, inverse.apply(transform.apply(v1)), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, inverse.apply(transform.apply(v2)), EPS); @@ -822,55 +822,55 @@ public class AffineTransformMatrix3DTest { } @Test - public void testGetInverse_nonInvertible() { + public void testInverse_nonInvertible() { // act/assert GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0).getInverse(); + 0, 0, 0, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is 0.0"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 1, 0, 0, 0, 0, 1, 0, 0, - 0, 0, Double.NaN, 0).getInverse(); + 0, 0, Double.NaN, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 1, 0, 0, 0, 0, Double.NEGATIVE_INFINITY, 0, 0, - 0, 0, 1, 0).getInverse(); + 0, 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( Double.POSITIVE_INFINITY, 0, 0, 0, 0, 1, 0, 0, - 0, 0, 1, 0).getInverse(); + 0, 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 1, 0, 0, Double.NaN, 0, 1, 0, 0, - 0, 0, 1, 0).getInverse(); + 0, 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 1, 0, 0, 0, 0, 1, 0, Double.POSITIVE_INFINITY, - 0, 0, 1, 0).getInverse(); + 0, 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: Infinity"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix3D.of( 1, 0, 0, 0, 0, 1, 0, 0, - 0, 0, 1, Double.NEGATIVE_INFINITY).getInverse(); + 0, 0, 1, Double.NEGATIVE_INFINITY).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: -Infinity"); } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PolyhedronsSetTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PolyhedronsSetTest.java index 7af299c..90d8b47 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PolyhedronsSetTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/PolyhedronsSetTest.java @@ -553,7 +553,7 @@ public class PolyhedronsSetTest { 1.0, c, 1.0, r.apply(barycenter.subtract(c))); Assert.assertEquals(0.0, - newB.subtract(tree.getBarycenter()).getNorm(), + newB.subtract(tree.getBarycenter()).norm(), TEST_TOLERANCE); final Vector3D[] expectedV = new Vector3D[] { @@ -603,7 +603,7 @@ public class PolyhedronsSetTest { Vector3D v = plane.toSpace(vertices[0][i]); double d = Double.POSITIVE_INFINITY; for (int k = 0; k < expectedV.length; ++k) { - d = Math.min(d, v.subtract(expectedV[k]).getNorm()); + d = Math.min(d, v.subtract(expectedV[k]).norm()); } Assert.assertEquals(0, d, TEST_TOLERANCE); } @@ -1459,7 +1459,7 @@ public class PolyhedronsSetTest { y = Math.sin(hAngle) * stackRadius; norm = Vector3D.of(x, y, stackHeight).normalize(); - pt = center.add(norm.scalarMultiply(adjustedRadius)); + pt = center.add(norm.multiply(adjustedRadius)); planes.add(new Plane(pt, norm, TEST_TOLERANCE)); } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Vector3DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Vector3DTest.java index d4f78b8..6254ef4 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Vector3DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/threed/Vector3DTest.java @@ -147,23 +147,23 @@ public class Vector3DTest { // assert checkVector(zero, 0, 0, 0); - Assert.assertEquals(0, zero.getNorm(), EPS); + Assert.assertEquals(0, zero.norm(), EPS); } @Test public void testNorm() { // act/assert - Assert.assertEquals(0.0, Vector3D.ZERO.getNorm(), 0); - Assert.assertEquals(Math.sqrt(29), Vector3D.of(2, 3, 4).getNorm(), EPS); - Assert.assertEquals(Math.sqrt(29), Vector3D.of(-2, -3, -4).getNorm(), EPS); + Assert.assertEquals(0.0, Vector3D.ZERO.norm(), 0); + Assert.assertEquals(Math.sqrt(29), Vector3D.of(2, 3, 4).norm(), EPS); + Assert.assertEquals(Math.sqrt(29), Vector3D.of(-2, -3, -4).norm(), EPS); } @Test public void testNormSq() { // act/assert - Assert.assertEquals(0.0, Vector3D.ZERO.getNormSq(), 0); - Assert.assertEquals(29, Vector3D.of(2, 3, 4).getNormSq(), EPS); - Assert.assertEquals(29, Vector3D.of(-2, -3, -4).getNormSq(), EPS); + Assert.assertEquals(0.0, Vector3D.ZERO.normSq(), 0); + Assert.assertEquals(29, Vector3D.of(2, 3, 4).normSq(), EPS); + Assert.assertEquals(29, Vector3D.of(-2, -3, -4).normSq(), EPS); } @Test @@ -199,7 +199,7 @@ public class Vector3DTest { for (double mag = -10.0; mag <= 10.0; ++mag) { - Assert.assertEquals(Math.abs(mag), Vector3D.of(x, y, z).withNorm(mag).getNorm(), EPS); + Assert.assertEquals(Math.abs(mag), Vector3D.of(x, y, z).withNorm(mag).norm(), EPS); } } @@ -228,7 +228,7 @@ public class Vector3DTest { for (double mag = -10.0; mag <= 10.0; ++mag) { - Assert.assertEquals(Math.abs(mag), v.withNorm(mag).getNorm(), EPS); + Assert.assertEquals(Math.abs(mag), v.withNorm(mag).norm(), EPS); } } @@ -329,7 +329,7 @@ public class Vector3DTest { checkVector(Vector3D.of(2, 2, 2).normalize(), invSqrt3, invSqrt3, invSqrt3); checkVector(Vector3D.of(-2, -2, -2).normalize(), -invSqrt3, -invSqrt3, -invSqrt3); - Assert.assertEquals(1.0, Vector3D.of(5, -4, 2).normalize().getNorm(), EPS); + Assert.assertEquals(1.0, Vector3D.of(5, -4, 2).normalize().norm(), EPS); } @Test @@ -486,7 +486,7 @@ public class Vector3DTest { Vector3D k = v1.normalize(); Vector3D i = k.orthogonal(); - Vector3D v2 = k.scalarMultiply(Math.cos(1.2)).add(i.scalarMultiply(Math.sin(1.2))); + Vector3D v2 = k.multiply(Math.cos(1.2)).add(i.multiply(Math.sin(1.2))); // act/assert Assert.assertTrue(Math.abs(v1.angle(v2) - 1.2) < 1.0e-12); @@ -533,8 +533,8 @@ public class Vector3DTest { Vector3D cAccurate = u1.crossProduct(u2); // assert - Assert.assertTrue(u3.distance(cNaive) > 2.9 * u3.getNorm()); - Assert.assertEquals(0.0, u3.distance(cAccurate), 1.0e-30 * cAccurate.getNorm()); + Assert.assertTrue(u3.distance(cNaive) > 2.9 * u3.norm()); + Assert.assertEquals(0.0, u3.distance(cAccurate), 1.0e-30 * cAccurate.norm()); } @Test @@ -556,7 +556,7 @@ public class Vector3DTest { Vector3D cAccurate = Vector3D.of(ux, uy, uz).crossProduct(Vector3D.of(vx, vy, vz)); // assert - Assert.assertEquals(0.0, cAccurate.distance(cNaive), 6.0e-15 * cAccurate.getNorm()); + Assert.assertEquals(0.0, cAccurate.distance(cNaive), 6.0e-15 * cAccurate.norm()); } } @@ -580,17 +580,17 @@ public class Vector3DTest { Vector3D v2 = Vector3D.of(-2, -3, -4); // act/assert - checkVector(v1.scalarMultiply(0), 0, 0, 0); - checkVector(v1.scalarMultiply(0.5), 1, 1.5, 2); - checkVector(v1.scalarMultiply(1), 2, 3, 4); - checkVector(v1.scalarMultiply(2), 4, 6, 8); - checkVector(v1.scalarMultiply(-2), -4, -6, -8); + checkVector(v1.multiply(0), 0, 0, 0); + checkVector(v1.multiply(0.5), 1, 1.5, 2); + checkVector(v1.multiply(1), 2, 3, 4); + checkVector(v1.multiply(2), 4, 6, 8); + checkVector(v1.multiply(-2), -4, -6, -8); - checkVector(v2.scalarMultiply(0), 0, 0, 0); - checkVector(v2.scalarMultiply(0.5), -1, -1.5, -2); - checkVector(v2.scalarMultiply(1), -2, -3, -4); - checkVector(v2.scalarMultiply(2), -4, -6, -8); - checkVector(v2.scalarMultiply(-2), 4, 6, 8); + checkVector(v2.multiply(0), 0, 0, 0); + checkVector(v2.multiply(0.5), -1, -1.5, -2); + checkVector(v2.multiply(1), -2, -3, -4); + checkVector(v2.multiply(2), -4, -6, -8); + checkVector(v2.multiply(-2), 4, 6, 8); } @Test @@ -607,7 +607,7 @@ public class Vector3DTest { Assert.assertEquals(Math.sqrt(50), v1.distance(v2), EPS); Assert.assertEquals(Math.sqrt(50), v2.distance(v1), EPS); - Assert.assertEquals(v1.subtract(v2).getNorm(), v1.distance(v2), EPS); + Assert.assertEquals(v1.subtract(v2).norm(), v1.distance(v2), EPS); Assert.assertEquals(Math.sqrt(132), v1.distance(v3), EPS); Assert.assertEquals(Math.sqrt(132), v3.distance(v1), EPS); @@ -627,7 +627,7 @@ public class Vector3DTest { Assert.assertEquals(50, v1.distanceSq(v2), EPS); Assert.assertEquals(50, v2.distanceSq(v1), EPS); - Assert.assertEquals(v1.subtract(v2).getNormSq(), v1.distanceSq(v2), EPS); + Assert.assertEquals(v1.subtract(v2).normSq(), v1.distanceSq(v2), EPS); Assert.assertEquals(132, v1.distanceSq(v3), EPS); Assert.assertEquals(132, v3.distanceSq(v1), 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 bf0d6c3..35175ea 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 @@ -275,12 +275,12 @@ public class QuaternionRotationTest { } @Test - public void testGetInverse() { + public void testInverse() { // arrange QuaternionRotation rot = QuaternionRotation.of(0.5, 0.5, 0.5, 0.5); // act - QuaternionRotation neg = rot.getInverse(); + QuaternionRotation neg = rot.inverse(); // assert Assert.assertEquals(-0.5, neg.getQuaternion().getX(), EPS); @@ -290,61 +290,61 @@ public class QuaternionRotationTest { } @Test - public void testGetInverse_apply() { + public void testInverse_apply() { // act/assert // --- x axes - assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.ZERO_PI).getInverse()); + assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.ZERO_PI).inverse()); - assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.PLUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.MINUS_X_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.PI).getInverse()); - assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.PI).getInverse()); + assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(PLUS_X_DIR, Geometry.PI).inverse()); + assertRotationEquals(StandardRotations.X_PI, QuaternionRotation.fromAxisAngle(MINUS_X_DIR, Geometry.PI).inverse()); // --- y axes - assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.ZERO_PI).getInverse()); + assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.ZERO_PI).inverse()); - assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.PLUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.MINUS_Y_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.PI).getInverse()); - assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.PI).getInverse()); + assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(PLUS_Y_DIR, Geometry.PI).inverse()); + assertRotationEquals(StandardRotations.Y_PI, QuaternionRotation.fromAxisAngle(MINUS_Y_DIR, Geometry.PI).inverse()); // --- z axes - assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.ZERO_PI).getInverse()); + assertRotationEquals(StandardRotations.IDENTITY, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.ZERO_PI).inverse()); - assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.PLUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.MINUS_HALF_PI).getInverse()); - assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.HALF_PI).getInverse()); + assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.MINUS_HALF_PI).inverse()); + assertRotationEquals(StandardRotations.MINUS_Z_HALF_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.HALF_PI).inverse()); - assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.PI).getInverse()); - assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.PI).getInverse()); + assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(PLUS_Z_DIR, Geometry.PI).inverse()); + assertRotationEquals(StandardRotations.Z_PI, QuaternionRotation.fromAxisAngle(MINUS_Z_DIR, Geometry.PI).inverse()); // --- diagonal - assertRotationEquals(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(PLUS_DIAGONAL, MINUS_TWO_THIRDS_PI).getInverse()); - assertRotationEquals(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(MINUS_DIAGONAL, TWO_THIRDS_PI).getInverse()); + assertRotationEquals(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(PLUS_DIAGONAL, MINUS_TWO_THIRDS_PI).inverse()); + assertRotationEquals(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(MINUS_DIAGONAL, TWO_THIRDS_PI).inverse()); - assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(MINUS_DIAGONAL, MINUS_TWO_THIRDS_PI).getInverse()); - assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(PLUS_DIAGONAL, TWO_THIRDS_PI).getInverse()); + assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(MINUS_DIAGONAL, MINUS_TWO_THIRDS_PI).inverse()); + assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, QuaternionRotation.fromAxisAngle(PLUS_DIAGONAL, TWO_THIRDS_PI).inverse()); } @Test - public void testGetInverse_undoesOriginalRotation() { + public void testInverse_undoesOriginalRotation() { EuclideanTestUtils.permuteSkipZero(-5, 5, 1, (x, y, z) -> { // arrange Vector3D vec = Vector3D.of(x, y, z); QuaternionRotation rot = QuaternionRotation.fromAxisAngle(vec, 0.75 * Geometry.PI); - QuaternionRotation neg = rot.getInverse(); + QuaternionRotation neg = rot.inverse(); // act/assert EuclideanTestUtils.assertCoordinatesEqual(PLUS_DIAGONAL, neg.apply(rot.apply(PLUS_DIAGONAL)), EPS); @@ -604,7 +604,7 @@ public class QuaternionRotationTest { QuaternionRotation result = QuaternionRotation.of(slerp.apply(t)); Vector3D slerpVec = result.apply(vec); - Assert.assertEquals(1, slerpVec.getNorm(), EPS); + Assert.assertEquals(1, slerpVec.norm(), EPS); // make sure that we're steadily progressing to the end angle double angle = slerpVec.angle(startVec); @@ -1064,7 +1064,7 @@ public class QuaternionRotationTest { Assert.assertEquals(Geometry.HALF_PI, q.getAngle(), EPS); EuclideanTestUtils.assertCoordinatesEqual(u2, q.apply(u1), EPS); - EuclideanTestUtils.assertCoordinatesEqual(u1, q.getInverse().apply(u2), EPS); + EuclideanTestUtils.assertCoordinatesEqual(u1, q.inverse().apply(u2), EPS); } @Test @@ -1083,7 +1083,7 @@ public class QuaternionRotationTest { Assert.assertEquals(Geometry.ZERO_PI, q.getAngle(), EPS); EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 2, 0), q.apply(u1), EPS); - EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 2, 0), q.getInverse().apply(u2), EPS); + EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 2, 0), q.inverse().apply(u2), EPS); } @Test @@ -1102,7 +1102,7 @@ public class QuaternionRotationTest { Assert.assertEquals(Geometry.ZERO_PI, q.getAngle(), EPS); EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 2, 0), q.apply(u1), EPS); - EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 3, 0), q.getInverse().apply(u2), EPS); + EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 3, 0), q.inverse().apply(u2), EPS); } @Test @@ -1121,7 +1121,7 @@ public class QuaternionRotationTest { Assert.assertEquals(Geometry.PI, q.getAngle(), EPS); EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, -2, 0), q.apply(u1), EPS); - EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 3, 0), q.getInverse().apply(u2), EPS); + EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 3, 0), q.inverse().apply(u2), EPS); } @Test @@ -1136,7 +1136,7 @@ public class QuaternionRotationTest { // assert Assert.assertEquals(0.0, q.apply(u1).angle(u2), EPS); - Assert.assertEquals(0.0, q.getInverse().apply(u2).angle(u1), EPS); + Assert.assertEquals(0.0, q.inverse().apply(u2).angle(u1), EPS); double angle = q.getAngle(); Assert.assertTrue(angle >= Geometry.ZERO_PI); @@ -1173,7 +1173,7 @@ public class QuaternionRotationTest { QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); // assert - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, q.apply(u1), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, q.apply(u2), EPS); @@ -1197,7 +1197,7 @@ public class QuaternionRotationTest { QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); // assert - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, q.apply(u1), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, q.apply(u2), EPS); @@ -1206,7 +1206,7 @@ public class QuaternionRotationTest { EuclideanTestUtils.assertCoordinatesEqual(u2, qInv.apply(v2), EPS); assertRotationEquals(StandardRotations.PLUS_DIAGONAL_TWO_THIRDS_PI, q); - assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, q.getInverse()); + assertRotationEquals(StandardRotations.MINUS_DIAGONAL_TWO_THIRDS_PI, q.inverse()); } @Test @@ -1222,7 +1222,7 @@ public class QuaternionRotationTest { QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); // assert - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, q.apply(u1), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, q.apply(u2), EPS); @@ -1246,7 +1246,7 @@ public class QuaternionRotationTest { QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); // assert - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); EuclideanTestUtils.assertCoordinatesEqual(u1, q.apply(u1), EPS); EuclideanTestUtils.assertCoordinatesEqual(u2, q.apply(u2), EPS); @@ -1270,7 +1270,7 @@ public class QuaternionRotationTest { QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); // assert - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(0, 2, 0), q.apply(u1), EPS); EuclideanTestUtils.assertCoordinatesEqual(Vector3D.of(-0.5, 1, 0), q.apply(u2), EPS); @@ -1299,7 +1299,7 @@ public class QuaternionRotationTest { // act QuaternionRotation q = QuaternionRotation.createBasisRotation(u1, u2, v1, v2); - QuaternionRotation qInv = q.getInverse(); + QuaternionRotation qInv = q.inverse(); // assert EuclideanTestUtils.assertCoordinatesEqual(v1Dir, q.apply(u1Dir), EPS); @@ -1316,9 +1316,9 @@ public class QuaternionRotationTest { Vector3D transformedY = q.apply(Vector3D.PLUS_Y); Vector3D transformedZ = q.apply(Vector3D.PLUS_Z); - Assert.assertEquals(1.0, transformedX.getNorm(), EPS); - Assert.assertEquals(1.0, transformedY.getNorm(), EPS); - Assert.assertEquals(1.0, transformedZ.getNorm(), EPS); + Assert.assertEquals(1.0, transformedX.norm(), EPS); + Assert.assertEquals(1.0, transformedY.norm(), EPS); + Assert.assertEquals(1.0, transformedZ.norm(), EPS); Assert.assertEquals(0.0, transformedX.dotProduct(transformedY), EPS); Assert.assertEquals(0.0, transformedX.dotProduct(transformedZ), EPS); 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 ef179f6..b2612af 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 @@ -642,7 +642,7 @@ public class AffineTransformMatrix2DTest { Vector2D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -693,7 +693,7 @@ public class AffineTransformMatrix2DTest { Vector2D expectedVec = vec .add(translation1) - .scalarMultiply(scale) + .multiply(scale) .add(translation2); EuclideanTestUtils.assertCoordinatesEqual(expectedVec, transform.apply(vec), EPS); @@ -701,9 +701,9 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_identity() { + public void testInverse_identity() { // act - AffineTransformMatrix2D inverse = AffineTransformMatrix2D.identity().getInverse(); + AffineTransformMatrix2D inverse = AffineTransformMatrix2D.identity().inverse(); // assert double[] expected = { @@ -714,14 +714,14 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_multiplyByInverse_producesIdentity() { + public void testInverse_multiplyByInverse_producesIdentity() { // arrange AffineTransformMatrix2D a = AffineTransformMatrix2D.of( 1, 3, 7, 2, 4, 9 ); - AffineTransformMatrix2D inv = a.getInverse(); + AffineTransformMatrix2D inv = a.inverse(); // act AffineTransformMatrix2D result = inv.multiply(a); @@ -735,12 +735,12 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_translate() { + public void testInverse_translate() { // arrange AffineTransformMatrix2D transform = AffineTransformMatrix2D.createTranslation(1, -2); // act - AffineTransformMatrix2D inverse = transform.getInverse(); + AffineTransformMatrix2D inverse = transform.inverse(); // assert double[] expected = { @@ -751,12 +751,12 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_scale() { + public void testInverse_scale() { // arrange AffineTransformMatrix2D transform = AffineTransformMatrix2D.createScale(10, -2); // act - AffineTransformMatrix2D inverse = transform.getInverse(); + AffineTransformMatrix2D inverse = transform.inverse(); // assert double[] expected = { @@ -767,12 +767,12 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_rotate() { + public void testInverse_rotate() { // arrange AffineTransformMatrix2D transform = AffineTransformMatrix2D.createRotation(Geometry.HALF_PI); // act - AffineTransformMatrix2D inverse = transform.getInverse(); + AffineTransformMatrix2D inverse = transform.inverse(); // assert double[] expected = { @@ -783,13 +783,13 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_rotate_aroundCenter() { + public void testInverse_rotate_aroundCenter() { // arrange Vector2D center = Vector2D.of(1, 2); AffineTransformMatrix2D transform = AffineTransformMatrix2D.createRotation(center, Geometry.HALF_PI); // act - AffineTransformMatrix2D inverse = transform.getInverse(); + AffineTransformMatrix2D inverse = transform.inverse(); // assert double[] expected = { @@ -800,7 +800,7 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_undoesOriginalTransform() { + public void testInverse_undoesOriginalTransform() { // arrange Vector2D v1 = Vector2D.ZERO; Vector2D v2 = Vector2D.PLUS_X; @@ -818,7 +818,7 @@ public class AffineTransformMatrix2DTest { .rotate(x / 4) .rotate(center, y / 2); - AffineTransformMatrix2D inverse = transform.getInverse(); + AffineTransformMatrix2D inverse = transform.inverse(); EuclideanTestUtils.assertCoordinatesEqual(v1, inverse.apply(transform.apply(v1)), EPS); EuclideanTestUtils.assertCoordinatesEqual(v2, inverse.apply(transform.apply(v2)), EPS); @@ -828,48 +828,48 @@ public class AffineTransformMatrix2DTest { } @Test - public void testGetInverse_nonInvertible() { + public void testInverse_nonInvertible() { // act/assert GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 0, 0, 0, - 0, 0, 0).getInverse(); + 0, 0, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is 0.0"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 1, 0, 0, - 0, Double.NaN, 0).getInverse(); + 0, Double.NaN, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 1, 0, 0, - 0, Double.NEGATIVE_INFINITY, 0).getInverse(); + 0, Double.NEGATIVE_INFINITY, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is -Infinity"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( Double.POSITIVE_INFINITY, 0, 0, - 0, 1, 0).getInverse(); + 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; matrix determinant is Infinity"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 1, 0, Double.NaN, - 0, 1, 0).getInverse(); + 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: NaN"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 1, 0, Double.POSITIVE_INFINITY, - 0, 1, 0).getInverse(); + 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: Infinity"); GeometryTestUtils.assertThrows(() -> { AffineTransformMatrix2D.of( 1, 0, Double.NEGATIVE_INFINITY, - 0, 1, 0).getInverse(); + 0, 1, 0).inverse(); }, NonInvertibleTransformException.class, "Transform is not invertible; invalid matrix element: -Infinity"); } diff --git a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/Vector2DTest.java b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/Vector2DTest.java index a3171de..e106537 100644 --- a/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/Vector2DTest.java +++ b/commons-geometry-euclidean/src/test/java/org/apache/commons/geometry/euclidean/twod/Vector2DTest.java @@ -131,27 +131,27 @@ public class Vector2DTest { @Test public void testNorm() { // act/assert - Assert.assertEquals(0.0, Vector2D.of(0, 0).getNorm(), EPS); + Assert.assertEquals(0.0, Vector2D.of(0, 0).norm(), EPS); - Assert.assertEquals(5.0, Vector2D.of(3, 4).getNorm(), EPS); - Assert.assertEquals(5.0, Vector2D.of(3, -4).getNorm(), EPS); - Assert.assertEquals(5.0, Vector2D.of(-3, 4).getNorm(), EPS); - Assert.assertEquals(5.0, Vector2D.of(-3, -4).getNorm(), EPS); + Assert.assertEquals(5.0, Vector2D.of(3, 4).norm(), EPS); + Assert.assertEquals(5.0, Vector2D.of(3, -4).norm(), EPS); + Assert.assertEquals(5.0, Vector2D.of(-3, 4).norm(), EPS); + Assert.assertEquals(5.0, Vector2D.of(-3, -4).norm(), EPS); - Assert.assertEquals(Math.sqrt(5.0), Vector2D.of(-1, -2).getNorm(), EPS); + Assert.assertEquals(Math.sqrt(5.0), Vector2D.of(-1, -2).norm(), EPS); } @Test public void testNormSq() { // act/assert - Assert.assertEquals(0.0, Vector2D.of(0, 0).getNormSq(), EPS); + Assert.assertEquals(0.0, Vector2D.of(0, 0).normSq(), EPS); - Assert.assertEquals(25.0, Vector2D.of(3, 4).getNormSq(), EPS); - Assert.assertEquals(25.0, Vector2D.of(3, -4).getNormSq(), EPS); - Assert.assertEquals(25.0, Vector2D.of(-3, 4).getNormSq(), EPS); - Assert.assertEquals(25.0, Vector2D.of(-3, -4).getNormSq(), EPS); + Assert.assertEquals(25.0, Vector2D.of(3, 4).normSq(), EPS); + Assert.assertEquals(25.0, Vector2D.of(3, -4).normSq(), EPS); + Assert.assertEquals(25.0, Vector2D.of(-3, 4).normSq(), EPS); + Assert.assertEquals(25.0, Vector2D.of(-3, -4).normSq(), EPS); - Assert.assertEquals(5.0, Vector2D.of(-1, -2).getNormSq(), EPS); + Assert.assertEquals(5.0, Vector2D.of(-1, -2).normSq(), EPS); } @Test @@ -192,7 +192,7 @@ public class Vector2DTest { for (int i = -10; i <= 10; i++) { final double mag = i; - Assert.assertEquals(Math.abs(mag), v.withNorm(mag).getNorm(), eps); + Assert.assertEquals(Math.abs(mag), v.withNorm(mag).norm(), eps); } } @@ -309,13 +309,13 @@ public class Vector2DTest { @Test public void testScalarMultiply() { // act/assert - checkVector(Vector2D.of(1, 2).scalarMultiply(0), 0, 0); + checkVector(Vector2D.of(1, 2).multiply(0), 0, 0); - checkVector(Vector2D.of(1, 2).scalarMultiply(3), 3, 6); - checkVector(Vector2D.of(1, 2).scalarMultiply(-3), -3, -6); + checkVector(Vector2D.of(1, 2).multiply(3), 3, 6); + checkVector(Vector2D.of(1, 2).multiply(-3), -3, -6); - checkVector(Vector2D.of(2, 3).scalarMultiply(1.5), 3, 4.5); - checkVector(Vector2D.of(2, 3).scalarMultiply(-1.5), -3, -4.5); + checkVector(Vector2D.of(2, 3).multiply(1.5), 3, 4.5); + checkVector(Vector2D.of(2, 3).multiply(-1.5), -3, -4.5); } @Test @@ -405,7 +405,7 @@ public class Vector2DTest { Vector2D ortho = v.orthogonal(); // assert - Assert.assertEquals(1.0, ortho.getNorm(), EPS); + Assert.assertEquals(1.0, ortho.norm(), EPS); Assert.assertEquals(0.0, v.dotProduct(ortho), EPS); } } diff --git a/commons-geometry-hull/src/test/java/org/apache/commons/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java b/commons-geometry-hull/src/test/java/org/apache/commons/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java index 7c62498..fff9971 100644 --- a/commons-geometry-hull/src/test/java/org/apache/commons/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java +++ b/commons-geometry-hull/src/test/java/org/apache/commons/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java @@ -396,8 +396,8 @@ public abstract class ConvexHullGenerator2DAbstractTest { Vector2D d1 = p2.subtract(p1); Vector2D d2 = p3.subtract(p2); - Assert.assertTrue(d1.getNorm() > 1e-10); - Assert.assertTrue(d2.getNorm() > 1e-10); + Assert.assertTrue(d1.norm() > 1e-10); + Assert.assertTrue(d2.norm() > 1e-10); final double cross = LinearCombination.value(d1.getX(), d2.getY(), -d1.getY(), d2.getX()); final int cmp = Precision.compareTo(cross, 0.0, tolerance); diff --git a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/PropertiesComputer.java b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/PropertiesComputer.java index 8051bd1..2781da4 100644 --- a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/PropertiesComputer.java +++ b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/PropertiesComputer.java @@ -157,7 +157,7 @@ class PropertiesComputer implements BSPTreeVisitor<S2Point> { * @return barycenter */ public S2Point getBarycenter() { - if (summedBarycenter.getNormSq() == 0) { + if (summedBarycenter.normSq() == 0) { return S2Point.NaN; } else { return S2Point.ofVector(summedBarycenter); diff --git a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SphericalPolygonsSet.java b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SphericalPolygonsSet.java index 1d72c7d..9f09d77 100644 --- a/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SphericalPolygonsSet.java +++ b/commons-geometry-spherical/src/main/java/org/apache/commons/geometry/spherical/twod/SphericalPolygonsSet.java @@ -508,7 +508,7 @@ public class SphericalPolygonsSet extends AbstractRegion<S2Point, S1Point> { // convert to 3D sphere to spherical cap final double r = enclosing3D.getRadius(); - final double h = enclosing3D.getCenter().getNorm(); + final double h = enclosing3D.getCenter().norm(); if (h < getTolerance()) { // the 3D sphere is centered on the unit sphere and covers it // fall back to a crude approximation, based only on outside convex cells
