http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/main/java/org/apache/commons/math4/geometry/spherical/twod/SubCircle.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/geometry/spherical/twod/SubCircle.java b/src/main/java/org/apache/commons/math4/geometry/spherical/twod/SubCircle.java index 1e09a2d..8710e47 100644 --- a/src/main/java/org/apache/commons/math4/geometry/spherical/twod/SubCircle.java +++ b/src/main/java/org/apache/commons/math4/geometry/spherical/twod/SubCircle.java @@ -16,7 +16,7 @@ */ package org.apache.commons.math4.geometry.spherical.twod; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.geometry.partitioning.AbstractSubHyperplane; import org.apache.commons.math4.geometry.partitioning.Hyperplane; import org.apache.commons.math4.geometry.partitioning.Region; @@ -52,7 +52,7 @@ public class SubCircle extends AbstractSubHyperplane<Sphere2D, Sphere1D> { final Circle thisCircle = (Circle) getHyperplane(); final Circle otherCircle = (Circle) hyperplane; - final double angle = Coordinates3D.angle(thisCircle.getPole(), otherCircle.getPole()); + final double angle = Cartesian3D.angle(thisCircle.getPole(), otherCircle.getPole()); if (angle < thisCircle.getTolerance() || angle > FastMath.PI - thisCircle.getTolerance()) { // the two circles are aligned or opposite
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/complex/QuaternionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/complex/QuaternionTest.java b/src/test/java/org/apache/commons/math4/complex/QuaternionTest.java index 16159ec..06feaa5 100644 --- a/src/test/java/org/apache/commons/math4/complex/QuaternionTest.java +++ b/src/test/java/org/apache/commons/math4/complex/QuaternionTest.java @@ -23,7 +23,7 @@ import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.ZeroException; import org.apache.commons.math4.geometry.euclidean.threed.Rotation; import org.apache.commons.math4.geometry.euclidean.threed.RotationConvention; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.util.FastMath; import org.junit.Test; import org.junit.Assert; @@ -121,16 +121,16 @@ public class QuaternionTest { // qResult = (scalarA * scalarB - vectorA . vectorB) + (scalarA * vectorB + scalarB * vectorA + vectorA ^ // vectorB) - final Coordinates3D vectorA = new Coordinates3D(qA.getVectorPart()); - final Coordinates3D vectorB = new Coordinates3D(qB.getVectorPart()); - final Coordinates3D vectorResult = new Coordinates3D(qResult.getVectorPart()); + final Cartesian3D vectorA = new Cartesian3D(qA.getVectorPart()); + final Cartesian3D vectorB = new Cartesian3D(qB.getVectorPart()); + final Cartesian3D vectorResult = new Cartesian3D(qResult.getVectorPart()); - final double scalarPartRef = qA.getScalarPart() * qB.getScalarPart() - Coordinates3D.dotProduct(vectorA, vectorB); + final double scalarPartRef = qA.getScalarPart() * qB.getScalarPart() - Cartesian3D.dotProduct(vectorA, vectorB); Assert.assertEquals(scalarPartRef, qResult.getScalarPart(), EPS); - final Coordinates3D vectorPartRef = ((vectorA.scalarMultiply(qB.getScalarPart())).add(vectorB.scalarMultiply(qA - .getScalarPart()))).add(Coordinates3D.crossProduct(vectorA, vectorB)); + final Cartesian3D vectorPartRef = ((vectorA.scalarMultiply(qB.getScalarPart())).add(vectorB.scalarMultiply(qA + .getScalarPart()))).add(Cartesian3D.crossProduct(vectorA, vectorB)); final double norm = (vectorResult.subtract(vectorPartRef)).getNorm(); Assert.assertEquals(0, norm, EPS); @@ -167,12 +167,12 @@ public class QuaternionTest { final double[] vectorQ = quaternion.getVectorPart(); final double[] vectorResultQxV = qResultQxV.getVectorPart(); - final double scalarPartRefQxV = -Coordinates3D.dotProduct(new Coordinates3D(vectorQ), new Coordinates3D(vector)); + final double scalarPartRefQxV = -Cartesian3D.dotProduct(new Cartesian3D(vectorQ), new Cartesian3D(vector)); Assert.assertEquals(scalarPartRefQxV, qResultQxV.getScalarPart(), EPS); - final Coordinates3D vectorPartRefQxV = (new Coordinates3D(vector).scalarMultiply(quaternion.getScalarPart())).add(Coordinates3D - .crossProduct(new Coordinates3D(vectorQ), new Coordinates3D(vector))); - final double normQxV = (new Coordinates3D(vectorResultQxV).subtract(vectorPartRefQxV)).getNorm(); + final Cartesian3D vectorPartRefQxV = (new Cartesian3D(vector).scalarMultiply(quaternion.getScalarPart())).add(Cartesian3D + .crossProduct(new Cartesian3D(vectorQ), new Cartesian3D(vector))); + final double normQxV = (new Cartesian3D(vectorResultQxV).subtract(vectorPartRefQxV)).getNorm(); Assert.assertEquals(0, normQxV, EPS); // Case : Product between a vector and a quaternion : VxQ @@ -189,12 +189,12 @@ public class QuaternionTest { // comparison with the result given by the formula : // qResult = (- vector . vectorQ) + (scalarQ * vector + vector ^ vectorQ) - final double scalarPartRefVxQ = -Coordinates3D.dotProduct(new Coordinates3D(vectorQ), new Coordinates3D(vector)); + final double scalarPartRefVxQ = -Cartesian3D.dotProduct(new Cartesian3D(vectorQ), new Cartesian3D(vector)); Assert.assertEquals(scalarPartRefVxQ, qResultVxQ.getScalarPart(), EPS); - final Coordinates3D vectorPartRefVxQ = (new Coordinates3D(vector).scalarMultiply(quaternion.getScalarPart())).add(Coordinates3D - .crossProduct(new Coordinates3D(vector), new Coordinates3D(vectorQ))); - final double normVxQ = (new Coordinates3D(vectorResultVxQ).subtract(vectorPartRefVxQ)).getNorm(); + final Cartesian3D vectorPartRefVxQ = (new Cartesian3D(vector).scalarMultiply(quaternion.getScalarPart())).add(Cartesian3D + .crossProduct(new Cartesian3D(vector), new Cartesian3D(vectorQ))); + final double normVxQ = (new Cartesian3D(vectorResultVxQ).subtract(vectorPartRefVxQ)).getNorm(); Assert.assertEquals(0, normVxQ, EPS); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java index 648fee3..1bea90a 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/AbstractLeastSquaresOptimizerAbstractTest.java @@ -26,7 +26,7 @@ import org.apache.commons.math4.fitting.leastsquares.LeastSquaresProblem; import org.apache.commons.math4.fitting.leastsquares.MultivariateJacobianFunction; import org.apache.commons.math4.fitting.leastsquares.LeastSquaresOptimizer.Optimum; import org.apache.commons.math4.fitting.leastsquares.LeastSquaresProblem.Evaluation; -import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; import org.apache.commons.math4.linear.Array2DRowRealMatrix; import org.apache.commons.math4.linear.ArrayRealVector; import org.apache.commons.math4.linear.BlockRealMatrix; @@ -412,7 +412,7 @@ public abstract class AbstractLeastSquaresOptimizerAbstractTest { double rms = optimum.getRMS(); Assert.assertEquals(1.768262623567235, FastMath.sqrt(circle.getN()) * rms, TOl); - Coordinates2D center = new Coordinates2D(optimum.getPoint().getEntry(0), optimum.getPoint().getEntry(1)); + Cartesian2D center = new Cartesian2D(optimum.getPoint().getEntry(0), optimum.getPoint().getEntry(1)); Assert.assertEquals(69.96016176931406, circle.getRadius(center), 1e-6); Assert.assertEquals(96.07590211815305, center.getX(), 1e-6); Assert.assertEquals(48.13516790438953, center.getY(), 1e-6); @@ -455,7 +455,7 @@ public abstract class AbstractLeastSquaresOptimizerAbstractTest { Optimum optimum = optimizer.optimize(builder(circle).weight(new DiagonalMatrix(weights)).start(start).build()); - Coordinates2D center = new Coordinates2D(optimum.getPoint().getEntry(0), optimum.getPoint().getEntry(1)); + Cartesian2D center = new Cartesian2D(optimum.getPoint().getEntry(0), optimum.getPoint().getEntry(1)); Assert.assertTrue(optimum.getEvaluations() < 25); Assert.assertEquals(0.043, optimum.getRMS(), 1e-3); Assert.assertEquals(0.292235, circle.getRadius(center), 1e-6); http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/fitting/leastsquares/CircleVectorial.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/CircleVectorial.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/CircleVectorial.java index 414ee2c..db9cef8 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/CircleVectorial.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/CircleVectorial.java @@ -20,29 +20,29 @@ import java.util.ArrayList; import org.apache.commons.math4.analysis.MultivariateMatrixFunction; import org.apache.commons.math4.analysis.MultivariateVectorFunction; -import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; /** * Class used in the tests. */ class CircleVectorial { - private ArrayList<Coordinates2D> points; + private ArrayList<Cartesian2D> points; public CircleVectorial() { points = new ArrayList<>(); } public void addPoint(double px, double py) { - points.add(new Coordinates2D(px, py)); + points.add(new Cartesian2D(px, py)); } public int getN() { return points.size(); } - public double getRadius(Coordinates2D center) { + public double getRadius(Cartesian2D center) { double r = 0; - for (Coordinates2D point : points) { + for (Cartesian2D point : points) { r += point.distance(center); } return r / points.size(); @@ -52,7 +52,7 @@ class CircleVectorial { return new MultivariateVectorFunction() { @Override public double[] value(double[] params) { - Coordinates2D center = new Coordinates2D(params[0], params[1]); + Cartesian2D center = new Cartesian2D(params[0], params[1]); double radius = getRadius(center); double[] residuals = new double[points.size()]; for (int i = 0; i < residuals.length; i++) { @@ -69,11 +69,11 @@ class CircleVectorial { @Override public double[][] value(double[] params) { final int n = points.size(); - final Coordinates2D center = new Coordinates2D(params[0], params[1]); + final Cartesian2D center = new Cartesian2D(params[0], params[1]); double dRdX = 0; double dRdY = 0; - for (Coordinates2D pk : points) { + for (Cartesian2D pk : points) { double dk = pk.distance(center); dRdX += (center.getX() - pk.getX()) / dk; dRdY += (center.getY() - pk.getY()) / dk; @@ -84,7 +84,7 @@ class CircleVectorial { // Jacobian of the radius residuals. double[][] jacobian = new double[n][2]; for (int i = 0; i < n; i++) { - final Coordinates2D pi = points.get(i); + final Cartesian2D pi = points.get(i); final double di = pi.distance(center); jacobian[i][0] = (center.getX() - pi.getX()) / di - dRdX; jacobian[i][1] = (center.getY() - pi.getY()) / di - dRdY; http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java index 5f121e0..626a3a0 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/GaussNewtonOptimizerWithSVDTest.java @@ -25,7 +25,7 @@ import org.apache.commons.math4.fitting.leastsquares.LeastSquaresProblem; import org.apache.commons.math4.fitting.leastsquares.GaussNewtonOptimizer.Decomposition; import org.apache.commons.math4.fitting.leastsquares.LeastSquaresOptimizer.Optimum; import org.apache.commons.math4.geometry.euclidean.threed.Plane; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.optim.SimpleVectorValueChecker; import org.apache.commons.math4.util.FastMath; import org.junit.Assert; @@ -140,8 +140,8 @@ public class GaussNewtonOptimizerWithSVDTest Optimum optimum = optimizer.optimize(problem.getBuilder().build()); - Plane span = new Plane(Coordinates3D.ZERO, new Coordinates3D(1, 2, -3), new Coordinates3D(2, 1, 0), TOl); - double expected = FastMath.abs(span.getOffset(new Coordinates3D(1, 1, 1))); + Plane span = new Plane(Cartesian3D.ZERO, new Cartesian3D(1, 2, -3), new Cartesian3D(2, 1, 0), TOl); + double expected = FastMath.abs(span.getOffset(new Cartesian3D(1, 1, 1))); double actual = optimum.getResiduals().getNorm(); //verify http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java index 56980a6..8d0f495 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/LevenbergMarquardtOptimizerTest.java @@ -28,7 +28,7 @@ import org.apache.commons.math4.fitting.leastsquares.LevenbergMarquardtOptimizer import org.apache.commons.math4.fitting.leastsquares.ParameterValidator; import org.apache.commons.math4.fitting.leastsquares.LeastSquaresOptimizer.Optimum; import org.apache.commons.math4.fitting.leastsquares.LeastSquaresProblem.Evaluation; -import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; import org.apache.commons.math4.linear.DiagonalMatrix; import org.apache.commons.math4.linear.RealMatrix; import org.apache.commons.math4.linear.RealVector; @@ -270,7 +270,7 @@ public class LevenbergMarquardtOptimizerTest final CircleProblem circle = new CircleProblem(xSigma, ySigma); final int numPoints = 10; - for (Coordinates2D p : factory.generate(numPoints)) { + for (Cartesian2D p : factory.generate(numPoints)) { circle.addPoint(p.getX(), p.getY()); } @@ -307,7 +307,7 @@ public class LevenbergMarquardtOptimizerTest final CircleProblem circle = new CircleProblem(xSigma, ySigma); final int numPoints = 10; - for (Coordinates2D p : factory.generate(numPoints)) { + for (Cartesian2D p : factory.generate(numPoints)) { circle.addPoint(p.getX(), p.getY()); } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java index a849c03..312b67f 100644 --- a/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java +++ b/src/test/java/org/apache/commons/math4/fitting/leastsquares/RandomCirclePointGenerator.java @@ -19,7 +19,7 @@ package org.apache.commons.math4.fitting.leastsquares; import org.apache.commons.math4.distribution.NormalDistribution; import org.apache.commons.math4.distribution.RealDistribution; import org.apache.commons.math4.distribution.UniformRealDistribution; -import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; import org.apache.commons.math4.util.FastMath; @@ -65,8 +65,8 @@ public class RandomCirclePointGenerator { * @param n Number of points to create. * @return the cloud of {@code n} points. */ - public Coordinates2D[] generate(int n) { - final Coordinates2D[] cloud = new Coordinates2D[n]; + public Cartesian2D[] generate(int n) { + final Cartesian2D[] cloud = new Cartesian2D[n]; for (int i = 0; i < n; i++) { cloud[i] = create(); } @@ -78,11 +78,11 @@ public class RandomCirclePointGenerator { * * @return a point. */ - private Coordinates2D create() { + private Cartesian2D create() { final double t = tP.sample(); final double pX = cX.sample() + radius * FastMath.cos(t); final double pY = cY.sample() + radius * FastMath.sin(t); - return new Coordinates2D(pX, pY); + return new Cartesian2D(pX, pY); } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser2DTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser2DTest.java b/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser2DTest.java index 2e08195..bde0468 100644 --- a/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser2DTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser2DTest.java @@ -24,7 +24,7 @@ import org.apache.commons.math4.geometry.enclosing.EnclosingBall; import org.apache.commons.math4.geometry.enclosing.WelzlEncloser; import org.apache.commons.math4.geometry.euclidean.twod.DiskGenerator; import org.apache.commons.math4.geometry.euclidean.twod.Euclidean2D; -import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; import org.junit.Assert; @@ -36,36 +36,36 @@ public class WelzlEncloser2DTest { @Test public void testNullList() { DiskGenerator generator = new DiskGenerator(); - WelzlEncloser<Euclidean2D, Coordinates2D> encloser = + WelzlEncloser<Euclidean2D, Cartesian2D> encloser = new WelzlEncloser<>(1.0e-10, generator); - EnclosingBall<Euclidean2D, Coordinates2D> ball = encloser.enclose(null); + EnclosingBall<Euclidean2D, Cartesian2D> ball = encloser.enclose(null); Assert.assertTrue(ball.getRadius() < 0); } @Test public void testNoPoints() { DiskGenerator generator = new DiskGenerator(); - WelzlEncloser<Euclidean2D, Coordinates2D> encloser = + WelzlEncloser<Euclidean2D, Cartesian2D> encloser = new WelzlEncloser<>(1.0e-10, generator); - EnclosingBall<Euclidean2D, Coordinates2D> ball = encloser.enclose(new ArrayList<Coordinates2D>()); + EnclosingBall<Euclidean2D, Cartesian2D> ball = encloser.enclose(new ArrayList<Cartesian2D>()); Assert.assertTrue(ball.getRadius() < 0); } @Test public void testRegularPoints() { - List<Coordinates2D> list = buildList(22, 26, 30, 38, 64, 28, 8, 54, 11, 15); + List<Cartesian2D> list = buildList(22, 26, 30, 38, 64, 28, 8, 54, 11, 15); checkDisk(list, Arrays.asList(list.get(2), list.get(3), list.get(4))); } @Test public void testSolutionOnDiameter() { - List<Coordinates2D> list = buildList(22, 26, 30, 38, 64, 28, 8, 54); + List<Cartesian2D> list = buildList(22, 26, 30, 38, 64, 28, 8, 54); checkDisk(list, Arrays.asList(list.get(2), list.get(3))); } @Test public void testReducingBall1() { - List<Coordinates2D> list = buildList(0.05380958511396061, 0.57332359658700000, + List<Cartesian2D> list = buildList(0.05380958511396061, 0.57332359658700000, 0.99348810731127870, 0.02056421361521466, 0.01203950647796437, 0.99779675042261860, 0.00810189987706078, 0.00589246003827815, @@ -75,7 +75,7 @@ public class WelzlEncloser2DTest { @Test public void testReducingBall2() { - List<Coordinates2D> list = buildList(0.016930586154703, 0.333955448537779, + List<Cartesian2D> list = buildList(0.016930586154703, 0.333955448537779, 0.987189104892331, 0.969778855274507, 0.983696889599935, 0.012904580013266, 0.013114499572905, 0.034740156356895); @@ -87,39 +87,39 @@ public class WelzlEncloser2DTest { UniformRandomProvider random = RandomSource.create(RandomSource.WELL_1024_A, 0xa2a63cad12c01fb2l); for (int k = 0; k < 100; ++k) { int nbPoints = random.nextInt(10000); - List<Coordinates2D> points = new ArrayList<>(); + List<Cartesian2D> points = new ArrayList<>(); for (int i = 0; i < nbPoints; ++i) { double x = random.nextDouble(); double y = random.nextDouble(); - points.add(new Coordinates2D(x, y)); + points.add(new Cartesian2D(x, y)); } checkDisk(points); } } - private List<Coordinates2D> buildList(final double ... coordinates) { - List<Coordinates2D> list = new ArrayList<>(coordinates.length / 2); + private List<Cartesian2D> buildList(final double ... coordinates) { + List<Cartesian2D> list = new ArrayList<>(coordinates.length / 2); for (int i = 0; i < coordinates.length; i += 2) { - list.add(new Coordinates2D(coordinates[i], coordinates[i + 1])); + list.add(new Cartesian2D(coordinates[i], coordinates[i + 1])); } return list; } - private void checkDisk(List<Coordinates2D> points, List<Coordinates2D> refSupport) { + private void checkDisk(List<Cartesian2D> points, List<Cartesian2D> refSupport) { - EnclosingBall<Euclidean2D, Coordinates2D> disk = checkDisk(points); + EnclosingBall<Euclidean2D, Cartesian2D> disk = checkDisk(points); // compare computed disk with expected disk DiskGenerator generator = new DiskGenerator(); - EnclosingBall<Euclidean2D, Coordinates2D> expected = generator.ballOnSupport(refSupport); + EnclosingBall<Euclidean2D, Cartesian2D> expected = generator.ballOnSupport(refSupport); Assert.assertEquals(refSupport.size(), disk.getSupportSize()); Assert.assertEquals(expected.getRadius(), disk.getRadius(), 1.0e-10); Assert.assertEquals(expected.getCenter().getX(), disk.getCenter().getX(), 1.0e-10); Assert.assertEquals(expected.getCenter().getY(), disk.getCenter().getY(), 1.0e-10); - for (Coordinates2D s : disk.getSupport()) { + for (Cartesian2D s : disk.getSupport()) { boolean found = false; - for (Coordinates2D rs : refSupport) { + for (Cartesian2D rs : refSupport) { if (s == rs) { found = true; } @@ -129,14 +129,14 @@ public class WelzlEncloser2DTest { // check removing any point of the support disk fails to enclose the point for (int i = 0; i < disk.getSupportSize(); ++i) { - List<Coordinates2D> reducedSupport = new ArrayList<>(); + List<Cartesian2D> reducedSupport = new ArrayList<>(); int count = 0; - for (Coordinates2D s : disk.getSupport()) { + for (Cartesian2D s : disk.getSupport()) { if (count++ != i) { reducedSupport.add(s); } } - EnclosingBall<Euclidean2D, Coordinates2D> reducedDisk = generator.ballOnSupport(reducedSupport); + EnclosingBall<Euclidean2D, Cartesian2D> reducedDisk = generator.ballOnSupport(reducedSupport); boolean foundOutside = false; for (int j = 0; j < points.size() && !foundOutside; ++j) { if (!reducedDisk.contains(points.get(j), 1.0e-10)) { @@ -148,20 +148,20 @@ public class WelzlEncloser2DTest { } - private EnclosingBall<Euclidean2D, Coordinates2D> checkDisk(List<Coordinates2D> points) { + private EnclosingBall<Euclidean2D, Cartesian2D> checkDisk(List<Cartesian2D> points) { - WelzlEncloser<Euclidean2D, Coordinates2D> encloser = + WelzlEncloser<Euclidean2D, Cartesian2D> encloser = new WelzlEncloser<>(1.0e-10, new DiskGenerator()); - EnclosingBall<Euclidean2D, Coordinates2D> disk = encloser.enclose(points); + EnclosingBall<Euclidean2D, Cartesian2D> disk = encloser.enclose(points); // all points are enclosed - for (Coordinates2D v : points) { + for (Cartesian2D v : points) { Assert.assertTrue(disk.contains(v, 1.0e-10)); } - for (Coordinates2D v : points) { + for (Cartesian2D v : points) { boolean inSupport = false; - for (Coordinates2D s : disk.getSupport()) { + for (Cartesian2D s : disk.getSupport()) { if (v == s) { inSupport = true; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser3DTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser3DTest.java b/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser3DTest.java index c2af261..4bd3d04 100644 --- a/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser3DTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/enclosing/WelzlEncloser3DTest.java @@ -25,7 +25,7 @@ import org.apache.commons.math4.geometry.enclosing.EnclosingBall; import org.apache.commons.math4.geometry.enclosing.WelzlEncloser; import org.apache.commons.math4.geometry.euclidean.threed.Euclidean3D; import org.apache.commons.math4.geometry.euclidean.threed.SphereGenerator; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.random.UnitSphereRandomVectorGenerator; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; @@ -38,67 +38,67 @@ public class WelzlEncloser3DTest { @Test public void testNullList() { SphereGenerator generator = new SphereGenerator(); - WelzlEncloser<Euclidean3D, Coordinates3D> encloser = + WelzlEncloser<Euclidean3D, Cartesian3D> encloser = new WelzlEncloser<>(1.0e-10, generator); - EnclosingBall<Euclidean3D, Coordinates3D> ball = encloser.enclose(null); + EnclosingBall<Euclidean3D, Cartesian3D> ball = encloser.enclose(null); Assert.assertTrue(ball.getRadius() < 0); } @Test public void testNoPoints() { SphereGenerator generator = new SphereGenerator(); - WelzlEncloser<Euclidean3D, Coordinates3D> encloser = + WelzlEncloser<Euclidean3D, Cartesian3D> encloser = new WelzlEncloser<>(1.0e-10, generator); - EnclosingBall<Euclidean3D, Coordinates3D> ball = encloser.enclose(new ArrayList<Coordinates3D>()); + EnclosingBall<Euclidean3D, Cartesian3D> ball = encloser.enclose(new ArrayList<Cartesian3D>()); Assert.assertTrue(ball.getRadius() < 0); } @Test public void testReducingBall() { - List<Coordinates3D> list = - Arrays.asList(new Coordinates3D(-7.140397329568118, -16.571661242582177, 11.714458961735405), - new Coordinates3D(-7.137986707455888, -16.570767323375720, 11.708602108715928), - new Coordinates3D(-7.139185068549035, -16.570891204702250, 11.715554057357394), - new Coordinates3D(-7.142682716997507, -16.571609818234290, 11.710787934580328), - new Coordinates3D(-7.139018392423351, -16.574405614157020, 11.710518716711425), - new Coordinates3D(-7.140870659936730, -16.567993074240455, 11.710914678204503), - new Coordinates3D(-7.136350173659562, -16.570498228820930, 11.713965225900928), - new Coordinates3D(-7.141675762759172, -16.572852471407028, 11.714033471449508), - new Coordinates3D(-7.140453077221105, -16.570212820780647, 11.708624578004980), - new Coordinates3D(-7.140322188726825, -16.574152894557717, 11.710305611121410), - new Coordinates3D(-7.141116131477088, -16.574061164624560, 11.712938509321699)); - WelzlEncloser<Euclidean3D, Coordinates3D> encloser = + List<Cartesian3D> list = + Arrays.asList(new Cartesian3D(-7.140397329568118, -16.571661242582177, 11.714458961735405), + new Cartesian3D(-7.137986707455888, -16.570767323375720, 11.708602108715928), + new Cartesian3D(-7.139185068549035, -16.570891204702250, 11.715554057357394), + new Cartesian3D(-7.142682716997507, -16.571609818234290, 11.710787934580328), + new Cartesian3D(-7.139018392423351, -16.574405614157020, 11.710518716711425), + new Cartesian3D(-7.140870659936730, -16.567993074240455, 11.710914678204503), + new Cartesian3D(-7.136350173659562, -16.570498228820930, 11.713965225900928), + new Cartesian3D(-7.141675762759172, -16.572852471407028, 11.714033471449508), + new Cartesian3D(-7.140453077221105, -16.570212820780647, 11.708624578004980), + new Cartesian3D(-7.140322188726825, -16.574152894557717, 11.710305611121410), + new Cartesian3D(-7.141116131477088, -16.574061164624560, 11.712938509321699)); + WelzlEncloser<Euclidean3D, Cartesian3D> encloser = new WelzlEncloser<>(1.0e-10, new SphereGenerator()); - EnclosingBall<Euclidean3D, Coordinates3D> ball = encloser.enclose(list); + EnclosingBall<Euclidean3D, Cartesian3D> ball = encloser.enclose(list); Assert.assertTrue(ball.getRadius() > 0); } @Test public void testInfiniteLoop() { // this test used to generate an infinite loop - List<Coordinates3D> list = - Arrays.asList(new Coordinates3D( -0.89227075512164380, -2.89317694645713900, 14.84572323743355500), - new Coordinates3D( -0.92099498940693580, -2.31086108263908940, 12.92071026467688300), - new Coordinates3D( -0.85227999411005200, -3.06314731441320730, 15.40163831651287000), - new Coordinates3D( -1.77399413020785970, -3.65630391378114260, 14.13190097751873400), - new Coordinates3D( 0.33157833272465354, -2.22813591757792160, 14.21225234159008200), - new Coordinates3D( -1.53065579165484400, -1.65692084770139570, 14.61483055714788500), - new Coordinates3D( -1.08457093941217140, -1.96100325935602980, 13.09265170575555000), - new Coordinates3D( 0.30029469589708850, -3.05470831395667370, 14.56352400426342600), - new Coordinates3D( -0.95007443938638460, -1.86810946486118360, 15.14491234340057000), - new Coordinates3D( -1.89661503804130830, -2.17004080885185860, 14.81235128513927000), - new Coordinates3D( -0.72193328761607530, -1.44513142833618270, 14.52355724218561800), - new Coordinates3D( -0.26895980939606550, -3.69512371522084140, 14.72272846327652000), - new Coordinates3D( -1.53501693431786170, -3.25055166611021900, 15.15509062584274800), - new Coordinates3D( -0.71727553535519410, -3.62284279460799100, 13.26256700929380700), - new Coordinates3D( -0.30220950676137365, -3.25410412500779070, 13.13682612771606000), - new Coordinates3D( -0.04543996608267075, -1.93081853923797750, 14.79497997883171400), - new Coordinates3D( -1.53348892951571640, -3.66688919703524900, 14.73095600812074200), - new Coordinates3D( -0.98034899533935820, -3.34004481162763960, 13.03245014017556800)); - - WelzlEncloser<Euclidean3D, Coordinates3D> encloser = + List<Cartesian3D> list = + Arrays.asList(new Cartesian3D( -0.89227075512164380, -2.89317694645713900, 14.84572323743355500), + new Cartesian3D( -0.92099498940693580, -2.31086108263908940, 12.92071026467688300), + new Cartesian3D( -0.85227999411005200, -3.06314731441320730, 15.40163831651287000), + new Cartesian3D( -1.77399413020785970, -3.65630391378114260, 14.13190097751873400), + new Cartesian3D( 0.33157833272465354, -2.22813591757792160, 14.21225234159008200), + new Cartesian3D( -1.53065579165484400, -1.65692084770139570, 14.61483055714788500), + new Cartesian3D( -1.08457093941217140, -1.96100325935602980, 13.09265170575555000), + new Cartesian3D( 0.30029469589708850, -3.05470831395667370, 14.56352400426342600), + new Cartesian3D( -0.95007443938638460, -1.86810946486118360, 15.14491234340057000), + new Cartesian3D( -1.89661503804130830, -2.17004080885185860, 14.81235128513927000), + new Cartesian3D( -0.72193328761607530, -1.44513142833618270, 14.52355724218561800), + new Cartesian3D( -0.26895980939606550, -3.69512371522084140, 14.72272846327652000), + new Cartesian3D( -1.53501693431786170, -3.25055166611021900, 15.15509062584274800), + new Cartesian3D( -0.71727553535519410, -3.62284279460799100, 13.26256700929380700), + new Cartesian3D( -0.30220950676137365, -3.25410412500779070, 13.13682612771606000), + new Cartesian3D( -0.04543996608267075, -1.93081853923797750, 14.79497997883171400), + new Cartesian3D( -1.53348892951571640, -3.66688919703524900, 14.73095600812074200), + new Cartesian3D( -0.98034899533935820, -3.34004481162763960, 13.03245014017556800)); + + WelzlEncloser<Euclidean3D, Cartesian3D> encloser = new WelzlEncloser<>(1.0e-10, new SphereGenerator()); - EnclosingBall<Euclidean3D, Coordinates3D> ball = encloser.enclose(list); + EnclosingBall<Euclidean3D, Cartesian3D> ball = encloser.enclose(list); Assert.assertTrue(ball.getRadius() > 0); } @@ -112,13 +112,13 @@ public class WelzlEncloser3DTest { // define the reference sphere we want to compute double d = 25 * random.nextDouble(); double refRadius = 10 * random.nextDouble(); - Coordinates3D refCenter = new Coordinates3D(d, new Coordinates3D(sr.nextVector())); + Cartesian3D refCenter = new Cartesian3D(d, new Cartesian3D(sr.nextVector())); // set up a large sample inside the reference sphere int nbPoints = random.nextInt(1000); - List<Coordinates3D> points = new ArrayList<>(); + List<Cartesian3D> points = new ArrayList<>(); for (int i = 0; i < nbPoints; ++i) { double r = refRadius * random.nextDouble(); - points.add(new Coordinates3D(1.0, refCenter, r, new Coordinates3D(sr.nextVector()))); + points.add(new Cartesian3D(1.0, refCenter, r, new Cartesian3D(sr.nextVector()))); } // test we find a sphere at most as large as the one used for random drawings @@ -127,23 +127,23 @@ public class WelzlEncloser3DTest { } } - private void checkSphere(List<Coordinates3D> points, double refRadius) { + private void checkSphere(List<Cartesian3D> points, double refRadius) { - EnclosingBall<Euclidean3D, Coordinates3D> sphere = checkSphere(points); + EnclosingBall<Euclidean3D, Cartesian3D> sphere = checkSphere(points); // compare computed sphere with bounding sphere Assert.assertTrue(sphere.getRadius() <= refRadius); // check removing any point of the support Sphere fails to enclose the point for (int i = 0; i < sphere.getSupportSize(); ++i) { - List<Coordinates3D> reducedSupport = new ArrayList<>(); + List<Cartesian3D> reducedSupport = new ArrayList<>(); int count = 0; - for (Coordinates3D s : sphere.getSupport()) { + for (Cartesian3D s : sphere.getSupport()) { if (count++ != i) { reducedSupport.add(s); } } - EnclosingBall<Euclidean3D, Coordinates3D> reducedSphere = + EnclosingBall<Euclidean3D, Cartesian3D> reducedSphere = new SphereGenerator().ballOnSupport(reducedSupport); boolean foundOutside = false; for (int j = 0; j < points.size() && !foundOutside; ++j) { @@ -156,20 +156,20 @@ public class WelzlEncloser3DTest { } - private EnclosingBall<Euclidean3D, Coordinates3D> checkSphere(List<Coordinates3D> points) { + private EnclosingBall<Euclidean3D, Cartesian3D> checkSphere(List<Cartesian3D> points) { - WelzlEncloser<Euclidean3D, Coordinates3D> encloser = + WelzlEncloser<Euclidean3D, Cartesian3D> encloser = new WelzlEncloser<>(1.0e-10, new SphereGenerator()); - EnclosingBall<Euclidean3D, Coordinates3D> Sphere = encloser.enclose(points); + EnclosingBall<Euclidean3D, Cartesian3D> Sphere = encloser.enclose(points); // all points are enclosed - for (Coordinates3D v : points) { + for (Cartesian3D v : points) { Assert.assertTrue(Sphere.contains(v, 1.0e-10)); } - for (Coordinates3D v : points) { + for (Cartesian3D v : points) { boolean inSupport = false; - for (Coordinates3D s : Sphere.getSupport()) { + for (Cartesian3D s : Sphere.getSupport()) { if (v == s) { inSupport = true; } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalsSetTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalsSetTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalsSetTest.java index 50b406b..5281ba1 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalsSetTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalsSetTest.java @@ -18,10 +18,6 @@ package org.apache.commons.math4.geometry.euclidean.oned; import java.util.List; -import org.apache.commons.math4.geometry.euclidean.oned.Euclidean1D; -import org.apache.commons.math4.geometry.euclidean.oned.Interval; -import org.apache.commons.math4.geometry.euclidean.oned.IntervalsSet; -import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D; import org.apache.commons.math4.geometry.partitioning.Region; import org.apache.commons.math4.geometry.partitioning.RegionFactory; import org.apache.commons.math4.util.FastMath; @@ -35,12 +31,12 @@ public class IntervalsSetTest { public void testInterval() { IntervalsSet set = new IntervalsSet(2.3, 5.7, 1.0e-10); Assert.assertEquals(3.4, set.getSize(), 1.0e-10); - Assert.assertEquals(4.0, ((Coordinates1D) set.getBarycenter()).getX(), 1.0e-10); - Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Coordinates1D(2.3))); - Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Coordinates1D(5.7))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(1.2))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(8.7))); - Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Coordinates1D(3.0))); + Assert.assertEquals(4.0, ((Cartesian1D) set.getBarycenter()).getX(), 1.0e-10); + Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Cartesian1D(2.3))); + Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Cartesian1D(5.7))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(1.2))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(8.7))); + Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Cartesian1D(3.0))); Assert.assertEquals(2.3, set.getInf(), 1.0e-10); Assert.assertEquals(5.7, set.getSup(), 1.0e-10); } @@ -48,11 +44,11 @@ public class IntervalsSetTest { @Test public void testInfinite() { IntervalsSet set = new IntervalsSet(9.0, Double.POSITIVE_INFINITY, 1.0e-10); - Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Coordinates1D(9.0))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(8.4))); + Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Cartesian1D(9.0))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(8.4))); for (double e = 1.0; e <= 6.0; e += 1.0) { Assert.assertEquals(Region.Location.INSIDE, - set.checkPoint(new Coordinates1D(FastMath.pow(10.0, e)))); + set.checkPoint(new Cartesian1D(FastMath.pow(10.0, e)))); } Assert.assertTrue(Double.isInfinite(set.getSize())); Assert.assertEquals(9.0, set.getInf(), 1.0e-10); @@ -73,16 +69,16 @@ public class IntervalsSetTest { new IntervalsSet(9.0, Double.POSITIVE_INFINITY, 1.0e-10)), new IntervalsSet(Double.NEGATIVE_INFINITY, 11.0, 1.0e-10)); Assert.assertEquals(5.0, set.getSize(), 1.0e-10); - Assert.assertEquals(5.9, ((Coordinates1D) set.getBarycenter()).getX(), 1.0e-10); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(0.0))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(4.0))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(8.0))); - Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Coordinates1D(12.0))); - Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Coordinates1D(1.2))); - Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Coordinates1D(5.9))); - Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Coordinates1D(9.01))); - Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Coordinates1D(5.0))); - Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Coordinates1D(11.0))); + Assert.assertEquals(5.9, ((Cartesian1D) set.getBarycenter()).getX(), 1.0e-10); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(0.0))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(4.0))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(8.0))); + Assert.assertEquals(Region.Location.OUTSIDE, set.checkPoint(new Cartesian1D(12.0))); + Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Cartesian1D(1.2))); + Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Cartesian1D(5.9))); + Assert.assertEquals(Region.Location.INSIDE, set.checkPoint(new Cartesian1D(9.01))); + Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Cartesian1D(5.0))); + Assert.assertEquals(Region.Location.BOUNDARY, set.checkPoint(new Cartesian1D(11.0))); Assert.assertEquals( 1.0, set.getInf(), 1.0e-10); Assert.assertEquals(11.0, set.getSup(), 1.0e-10); @@ -101,7 +97,7 @@ public class IntervalsSetTest { public void testSinglePoint() { IntervalsSet set = new IntervalsSet(1.0, 1.0, 1.0e-10); Assert.assertEquals(0.0, set.getSize(), Precision.SAFE_MIN); - Assert.assertEquals(1.0, ((Coordinates1D) set.getBarycenter()).getX(), Precision.EPSILON); + Assert.assertEquals(1.0, ((Cartesian1D) set.getBarycenter()).getX(), Precision.EPSILON); } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DFormatAbstractTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DFormatAbstractTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DFormatAbstractTest.java index 2e26cef..2cb5ae2 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DFormatAbstractTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DFormatAbstractTest.java @@ -22,7 +22,6 @@ import java.text.ParsePosition; import java.util.Locale; import org.apache.commons.math4.exception.MathParseException; -import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D; import org.apache.commons.math4.geometry.euclidean.oned.Vector1DFormat; import org.junit.Assert; import org.junit.Test; @@ -45,7 +44,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testSimpleNoDecimals() { - Coordinates1D c = new Coordinates1D(1); + Cartesian1D c = new Cartesian1D(1); String expected = "{1}"; String actual = vector1DFormat.format(c); Assert.assertEquals(expected, actual); @@ -53,7 +52,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testSimpleWithDecimals() { - Coordinates1D c = new Coordinates1D(1.23); + Cartesian1D c = new Cartesian1D(1.23); String expected = "{1" + getDecimalCharacter() + "23}"; @@ -63,7 +62,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testSimpleWithDecimalsTrunc() { - Coordinates1D c = new Coordinates1D(1.232323232323); + Cartesian1D c = new Cartesian1D(1.232323232323); String expected = "{1" + getDecimalCharacter() + "2323232323}"; @@ -73,7 +72,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testNegativeX() { - Coordinates1D c = new Coordinates1D(-1.232323232323); + Cartesian1D c = new Cartesian1D(-1.232323232323); String expected = "{-1" + getDecimalCharacter() + "2323232323}"; @@ -83,7 +82,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testNonDefaultSetting() { - Coordinates1D c = new Coordinates1D(1); + Cartesian1D c = new Cartesian1D(1); String expected = "[1]"; String actual = vector1DFormatSquare.format(c); Assert.assertEquals(expected, actual); @@ -94,7 +93,7 @@ public abstract class Vector1DFormatAbstractTest { Locale defaultLocal = Locale.getDefault(); Locale.setDefault(getLocale()); - Coordinates1D c = new Coordinates1D(232.22222222222); + Cartesian1D c = new Cartesian1D(232.22222222222); String expected = "{232" + getDecimalCharacter() + "2222222222}"; @@ -106,7 +105,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testNan() { - Coordinates1D c = Coordinates1D.NaN; + Cartesian1D c = Cartesian1D.NaN; String expected = "{(NaN)}"; String actual = vector1DFormat.format(c); Assert.assertEquals(expected, actual); @@ -114,7 +113,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testPositiveInfinity() { - Coordinates1D c = Coordinates1D.POSITIVE_INFINITY; + Cartesian1D c = Cartesian1D.POSITIVE_INFINITY; String expected = "{(Infinity)}"; String actual = vector1DFormat.format(c); Assert.assertEquals(expected, actual); @@ -122,7 +121,7 @@ public abstract class Vector1DFormatAbstractTest { @Test public void tesNegativeInfinity() { - Coordinates1D c = Coordinates1D.NEGATIVE_INFINITY; + Cartesian1D c = Cartesian1D.NEGATIVE_INFINITY; String expected = "{(-Infinity)}"; String actual = vector1DFormat.format(c); Assert.assertEquals(expected, actual); @@ -131,14 +130,14 @@ public abstract class Vector1DFormatAbstractTest { @Test public void testParseSimpleNoDecimals() throws MathParseException { String source = "{1}"; - Coordinates1D expected = new Coordinates1D(1); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(1); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @Test public void testParseIgnoredWhitespace() { - Coordinates1D expected = new Coordinates1D(1); + Cartesian1D expected = new Cartesian1D(1); ParsePosition pos1 = new ParsePosition(0); String source1 = "{1}"; Assert.assertEquals(expected, vector1DFormat.parse(source1, pos1)); @@ -154,8 +153,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{1" + getDecimalCharacter() + "23}"; - Coordinates1D expected = new Coordinates1D(1.23); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(1.23); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -164,8 +163,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{1" + getDecimalCharacter() + "2323}"; - Coordinates1D expected = new Coordinates1D(1.2323); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(1.2323); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -174,8 +173,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{-1" + getDecimalCharacter() + "2323}"; - Coordinates1D expected = new Coordinates1D(-1.2323); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(-1.2323); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -184,8 +183,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{1" + getDecimalCharacter() + "2323}"; - Coordinates1D expected = new Coordinates1D(1.2323); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(1.2323); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -194,8 +193,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{1" + getDecimalCharacter() + "2323}"; - Coordinates1D expected = new Coordinates1D(1.2323); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(1.2323); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -204,8 +203,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{-1" + getDecimalCharacter() + "2323}"; - Coordinates1D expected = new Coordinates1D(-1.2323); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(-1.2323); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -214,8 +213,8 @@ public abstract class Vector1DFormatAbstractTest { String source = "{0" + getDecimalCharacter() + "0}"; - Coordinates1D expected = new Coordinates1D(0.0); - Coordinates1D actual = vector1DFormat.parse(source); + Cartesian1D expected = new Cartesian1D(0.0); + Cartesian1D actual = vector1DFormat.parse(source); Assert.assertEquals(expected, actual); } @@ -224,30 +223,30 @@ public abstract class Vector1DFormatAbstractTest { String source = "[1" + getDecimalCharacter() + "2323]"; - Coordinates1D expected = new Coordinates1D(1.2323); - Coordinates1D actual = vector1DFormatSquare.parse(source); + Cartesian1D expected = new Cartesian1D(1.2323); + Cartesian1D actual = vector1DFormatSquare.parse(source); Assert.assertEquals(expected, actual); } @Test public void testParseNan() throws MathParseException { String source = "{(NaN)}"; - Coordinates1D actual = vector1DFormat.parse(source); - Assert.assertEquals(Coordinates1D.NaN, actual); + Cartesian1D actual = vector1DFormat.parse(source); + Assert.assertEquals(Cartesian1D.NaN, actual); } @Test public void testParsePositiveInfinity() throws MathParseException { String source = "{(Infinity)}"; - Coordinates1D actual = vector1DFormat.parse(source); - Assert.assertEquals(Coordinates1D.POSITIVE_INFINITY, actual); + Cartesian1D actual = vector1DFormat.parse(source); + Assert.assertEquals(Cartesian1D.POSITIVE_INFINITY, actual); } @Test public void testParseNegativeInfinity() throws MathParseException { String source = "{(-Infinity)}"; - Coordinates1D actual = vector1DFormat.parse(source); - Assert.assertEquals(Coordinates1D.NEGATIVE_INFINITY, actual); + Cartesian1D actual = vector1DFormat.parse(source); + Assert.assertEquals(Cartesian1D.NEGATIVE_INFINITY, actual); } @Test http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DTest.java index 832716c..c1db959 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Vector1DTest.java @@ -25,7 +25,6 @@ import java.util.Locale; import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathArithmeticException; import org.apache.commons.math4.geometry.Space; -import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D; import org.apache.commons.math4.util.FastMath; import org.apache.commons.math4.util.Precision; import org.junit.Assert; @@ -34,143 +33,143 @@ import org.junit.Test; public class Vector1DTest { @Test public void testConstructors() throws DimensionMismatchException { - checkVector(new Coordinates1D(3, new Coordinates1D(FastMath.PI / 3)), + checkVector(new Cartesian1D(3, new Cartesian1D(FastMath.PI / 3)), FastMath.PI); - checkVector(new Coordinates1D(2, Coordinates1D.ONE, -3, new Coordinates1D(2)), + checkVector(new Cartesian1D(2, Cartesian1D.ONE, -3, new Cartesian1D(2)), -4); - checkVector(new Coordinates1D(2, Coordinates1D.ONE, - 5, new Coordinates1D(2), - -3, new Coordinates1D(3)), + checkVector(new Cartesian1D(2, Cartesian1D.ONE, + 5, new Cartesian1D(2), + -3, new Cartesian1D(3)), 3); - checkVector(new Coordinates1D(2, Coordinates1D.ONE, - 5, new Coordinates1D(2), - 5, new Coordinates1D(-2), - -3, new Coordinates1D(-3)), + checkVector(new Cartesian1D(2, Cartesian1D.ONE, + 5, new Cartesian1D(2), + 5, new Cartesian1D(-2), + -3, new Cartesian1D(-3)), 11); } @Test public void testSpace() { - Space space = new Coordinates1D(1).getSpace(); + Space space = new Cartesian1D(1).getSpace(); Assert.assertEquals(1, space.getDimension()); } @Test public void testZero() { - Assert.assertEquals(0, new Coordinates1D(1).getZero().getNorm(), 1.0e-15); + Assert.assertEquals(0, new Cartesian1D(1).getZero().getNorm(), 1.0e-15); } @Test public void testEquals() { - Coordinates1D u1 = new Coordinates1D(1); - Coordinates1D u2 = new Coordinates1D(1); + Cartesian1D u1 = new Cartesian1D(1); + Cartesian1D u2 = new Cartesian1D(1); Assert.assertTrue(u1.equals(u1)); Assert.assertTrue(u1.equals(u2)); - Assert.assertFalse(u1.equals(new Coordinates1D(1 + 10 * Precision.EPSILON))); - Assert.assertTrue(new Coordinates1D(Double.NaN).equals(new Coordinates1D(Double.NaN))); + Assert.assertFalse(u1.equals(new Cartesian1D(1 + 10 * Precision.EPSILON))); + Assert.assertTrue(new Cartesian1D(Double.NaN).equals(new Cartesian1D(Double.NaN))); } @Test public void testHash() { - Assert.assertEquals(new Coordinates1D(Double.NaN).hashCode(), new Coordinates1D(Double.NaN).hashCode()); - Coordinates1D u = new Coordinates1D(1); - Coordinates1D v = new Coordinates1D(1 + 10 * Precision.EPSILON); + Assert.assertEquals(new Cartesian1D(Double.NaN).hashCode(), new Cartesian1D(Double.NaN).hashCode()); + Cartesian1D u = new Cartesian1D(1); + Cartesian1D v = new Cartesian1D(1 + 10 * Precision.EPSILON); Assert.assertTrue(u.hashCode() != v.hashCode()); } @Test public void testInfinite() { - Assert.assertTrue(new Coordinates1D(Double.NEGATIVE_INFINITY).isInfinite()); - Assert.assertTrue(new Coordinates1D(Double.POSITIVE_INFINITY).isInfinite()); - Assert.assertFalse(new Coordinates1D(1).isInfinite()); - Assert.assertFalse(new Coordinates1D(Double.NaN).isInfinite()); + Assert.assertTrue(new Cartesian1D(Double.NEGATIVE_INFINITY).isInfinite()); + Assert.assertTrue(new Cartesian1D(Double.POSITIVE_INFINITY).isInfinite()); + Assert.assertFalse(new Cartesian1D(1).isInfinite()); + Assert.assertFalse(new Cartesian1D(Double.NaN).isInfinite()); } @Test public void testNaN() { - Assert.assertTrue(new Coordinates1D(Double.NaN).isNaN()); - Assert.assertFalse(new Coordinates1D(1).isNaN()); - Assert.assertFalse(new Coordinates1D(Double.NEGATIVE_INFINITY).isNaN()); + Assert.assertTrue(new Cartesian1D(Double.NaN).isNaN()); + Assert.assertFalse(new Cartesian1D(1).isNaN()); + Assert.assertFalse(new Cartesian1D(Double.NEGATIVE_INFINITY).isNaN()); } @Test public void testToString() { - Assert.assertEquals("{3}", new Coordinates1D(3).toString()); + Assert.assertEquals("{3}", new Cartesian1D(3).toString()); NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US)); - Assert.assertEquals("{3.000}", new Coordinates1D(3).toString(format)); + Assert.assertEquals("{3.000}", new Cartesian1D(3).toString(format)); } @Test public void testCoordinates() { - Coordinates1D v = new Coordinates1D(1); + Cartesian1D v = new Cartesian1D(1); Assert.assertTrue(FastMath.abs(v.getX() - 1) < 1.0e-12); } @Test public void testNorm1() { - Assert.assertEquals(0.0, Coordinates1D.ZERO.getNorm1(), 0); - Assert.assertEquals(6.0, new Coordinates1D(6).getNorm1(), 0); + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm1(), 0); + Assert.assertEquals(6.0, new Cartesian1D(6).getNorm1(), 0); } @Test public void testNorm() { - Assert.assertEquals(0.0, Coordinates1D.ZERO.getNorm(), 0); - Assert.assertEquals(3.0, new Coordinates1D(-3).getNorm(), 1.0e-12); + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm(), 0); + Assert.assertEquals(3.0, new Cartesian1D(-3).getNorm(), 1.0e-12); } @Test public void testNormSq() { - Assert.assertEquals(0.0, new Coordinates1D(0).getNormSq(), 0); - Assert.assertEquals(9.0, new Coordinates1D(-3).getNormSq(), 1.0e-12); + Assert.assertEquals(0.0, new Cartesian1D(0).getNormSq(), 0); + Assert.assertEquals(9.0, new Cartesian1D(-3).getNormSq(), 1.0e-12); } @Test public void testNormInf() { - Assert.assertEquals(0.0, Coordinates1D.ZERO.getNormInf(), 0); - Assert.assertEquals(3.0, new Coordinates1D(-3).getNormInf(), 0); + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNormInf(), 0); + Assert.assertEquals(3.0, new Cartesian1D(-3).getNormInf(), 0); } @Test public void testDistance1() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-4); - Assert.assertEquals(0.0, new Coordinates1D(-1).distance1(new Coordinates1D(-1)), 0); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-4); + Assert.assertEquals(0.0, new Cartesian1D(-1).distance1(new Cartesian1D(-1)), 0); Assert.assertEquals(5.0, v1.distance1(v2), 1.0e-12); Assert.assertEquals(v1.subtract(v2).getNorm1(), v1.distance1(v2), 1.0e-12); } @Test public void testDistance() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-4); - Assert.assertEquals(0.0, Coordinates1D.distance(new Coordinates1D(-1), new Coordinates1D(-1)), 0); - Assert.assertEquals(5.0, Coordinates1D.distance(v1, v2), 1.0e-12); - Assert.assertEquals(v1.subtract(v2).getNorm(), Coordinates1D.distance(v1, v2), 1.0e-12); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-4); + Assert.assertEquals(0.0, Cartesian1D.distance(new Cartesian1D(-1), new Cartesian1D(-1)), 0); + Assert.assertEquals(5.0, Cartesian1D.distance(v1, v2), 1.0e-12); + Assert.assertEquals(v1.subtract(v2).getNorm(), Cartesian1D.distance(v1, v2), 1.0e-12); } @Test public void testDistanceSq() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-4); - Assert.assertEquals(0.0, Coordinates1D.distanceSq(new Coordinates1D(-1), new Coordinates1D(-1)), 0); - Assert.assertEquals(25.0, Coordinates1D.distanceSq(v1, v2), 1.0e-12); - Assert.assertEquals(Coordinates1D.distance(v1, v2) * Coordinates1D.distance(v1, v2), - Coordinates1D.distanceSq(v1, v2), 1.0e-12); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-4); + Assert.assertEquals(0.0, Cartesian1D.distanceSq(new Cartesian1D(-1), new Cartesian1D(-1)), 0); + Assert.assertEquals(25.0, Cartesian1D.distanceSq(v1, v2), 1.0e-12); + Assert.assertEquals(Cartesian1D.distance(v1, v2) * Cartesian1D.distance(v1, v2), + Cartesian1D.distanceSq(v1, v2), 1.0e-12); } @Test public void testDistanceInf() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-4); - Assert.assertEquals(0.0, Coordinates1D.distanceInf(new Coordinates1D(-1), new Coordinates1D(-1)), 0); - Assert.assertEquals(5.0, Coordinates1D.distanceInf(v1, v2), 1.0e-12); - Assert.assertEquals(v1.subtract(v2).getNormInf(), Coordinates1D.distanceInf(v1, v2), 1.0e-12); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-4); + Assert.assertEquals(0.0, Cartesian1D.distanceInf(new Cartesian1D(-1), new Cartesian1D(-1)), 0); + Assert.assertEquals(5.0, Cartesian1D.distanceInf(v1, v2), 1.0e-12); + Assert.assertEquals(v1.subtract(v2).getNormInf(), Cartesian1D.distanceInf(v1, v2), 1.0e-12); } @Test public void testSubtract() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-3); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-3); v1 = v1.subtract(v2); checkVector(v1, 4); @@ -180,8 +179,8 @@ public class Vector1DTest { @Test public void testAdd() { - Coordinates1D v1 = new Coordinates1D(1); - Coordinates1D v2 = new Coordinates1D(-3); + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-3); v1 = v1.add(v2); checkVector(v1, -2); @@ -191,7 +190,7 @@ public class Vector1DTest { @Test public void testScalarProduct() { - Coordinates1D v = new Coordinates1D(1); + Cartesian1D v = new Cartesian1D(1); v = v.scalarMultiply(3); checkVector(v, 3); @@ -200,9 +199,9 @@ public class Vector1DTest { @Test public void testNormalize() throws MathArithmeticException { - Assert.assertEquals(1.0, new Coordinates1D(5).normalize().getNorm(), 1.0e-12); + Assert.assertEquals(1.0, new Cartesian1D(5).normalize().getNorm(), 1.0e-12); try { - Coordinates1D.ZERO.normalize(); + Cartesian1D.ZERO.normalize(); Assert.fail("an exception should have been thrown"); } catch (MathArithmeticException ae) { // expected behavior @@ -211,10 +210,10 @@ public class Vector1DTest { @Test public void testNegate() { - checkVector(new Coordinates1D(0.1).negate(), -0.1); + checkVector(new Cartesian1D(0.1).negate(), -0.1); } - private void checkVector(Coordinates1D v, double x) { + private void checkVector(Cartesian1D v, double x) { Assert.assertEquals(x, v.getX(), 1.0e-12); } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDSTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDSTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDSTest.java index 65f45a3..b54e2e0 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDSTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDSTest.java @@ -26,7 +26,7 @@ import org.apache.commons.math4.geometry.euclidean.threed.FieldVector3D; import org.apache.commons.math4.geometry.euclidean.threed.NotARotationMatrixException; import org.apache.commons.math4.geometry.euclidean.threed.Rotation; import org.apache.commons.math4.geometry.euclidean.threed.RotationOrder; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.linear.MatrixUtils; import org.apache.commons.math4.linear.RealMatrix; import org.apache.commons.math4.random.UnitSphereRandomVectorGenerator; @@ -975,7 +975,7 @@ public class FieldRotationDSTest { FieldVector3D<DerivativeStructure> uds = createVector(x, y, z); FieldVector3D<DerivativeStructure> ruds = r.applyTo(uds); FieldVector3D<DerivativeStructure> rIuds = r.applyInverseTo(uds); - Coordinates3D u = new Coordinates3D(x, y, z); + Cartesian3D u = new Cartesian3D(x, y, z); FieldVector3D<DerivativeStructure> ru = r.applyTo(u); FieldVector3D<DerivativeStructure> rIu = r.applyInverseTo(u); DerivativeStructure[] ruArray = new DerivativeStructure[3]; @@ -1000,7 +1000,7 @@ public class FieldRotationDSTest { UnitSphereRandomVectorGenerator g = new UnitSphereRandomVectorGenerator(3, random); for (int i = 0; i < 10; ++i) { double[] unit1 = g.nextVector(); - Rotation r1 = new Rotation(new Coordinates3D(unit1[0], unit1[1], unit1[2]), + Rotation r1 = new Rotation(new Cartesian3D(unit1[0], unit1[1], unit1[2]), random.nextDouble(), RotationConvention.VECTOR_OPERATOR); FieldRotation<DerivativeStructure> r1Prime = new FieldRotation<>(new DerivativeStructure(4, 1, 0, r1.getQ0()), new DerivativeStructure(4, 1, 1, r1.getQ1()), @@ -1051,7 +1051,7 @@ public class FieldRotationDSTest { FieldRotation<DerivativeStructure> r = new FieldRotation<>(createAxis(kx, ky, kz), createAngle(theta), RotationConvention.VECTOR_OPERATOR); - Coordinates3D a = new Coordinates3D(kx / n, ky / n, kz / n); + Cartesian3D a = new Cartesian3D(kx / n, ky / n, kz / n); // Jacobian of the normalized rotation axis a with respect to the Cartesian vector k RealMatrix dadk = MatrixUtils.createRealMatrix(new double[][] { @@ -1063,15 +1063,15 @@ public class FieldRotationDSTest { for (double x = -0.9; x < 0.9; x += 0.2) { for (double y = -0.9; y < 0.9; y += 0.2) { for (double z = -0.9; z < 0.9; z += 0.2) { - Coordinates3D u = new Coordinates3D(x, y, z); + Cartesian3D u = new Cartesian3D(x, y, z); FieldVector3D<DerivativeStructure> v = r.applyTo(createVector(x, y, z)); // explicit formula for rotation of vector u around axis a with angle theta - double dot = Coordinates3D.dotProduct(u, a); - Coordinates3D cross = Coordinates3D.crossProduct(a, u); + double dot = Cartesian3D.dotProduct(u, a); + Cartesian3D cross = Cartesian3D.crossProduct(a, u); double c1 = 1 - cosTheta; double c2 = c1 * dot; - Coordinates3D rt = new Coordinates3D(cosTheta, u, c2, a, sinTheta, cross); + Cartesian3D rt = new Cartesian3D(cosTheta, u, c2, a, sinTheta, cross); Assert.assertEquals(rt.getX(), v.getX().getReal(), eps); Assert.assertEquals(rt.getY(), v.getY().getReal(), eps); Assert.assertEquals(rt.getZ(), v.getZ().getReal(), eps); @@ -1100,8 +1100,8 @@ public class FieldRotationDSTest { // derivative with respect to rotation angle // (analytical differentiation of the explicit formula) - Coordinates3D dvdTheta = - new Coordinates3D(-sinTheta, u, sinTheta * dot, a, cosTheta, cross); + Cartesian3D dvdTheta = + new Cartesian3D(-sinTheta, u, sinTheta * dot, a, cosTheta, cross); Assert.assertEquals(dvdTheta.getX(), v.getX().getPartialDerivative(0, 0, 0, 1), eps); Assert.assertEquals(dvdTheta.getY(), v.getY().getPartialDerivative(0, 0, 0, 1), eps); Assert.assertEquals(dvdTheta.getZ(), v.getZ().getPartialDerivative(0, 0, 0, 1), eps); http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDfpTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDfpTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDfpTest.java index 4e250c0..f4f3403 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDfpTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/threed/FieldRotationDfpTest.java @@ -27,7 +27,7 @@ import org.apache.commons.math4.geometry.euclidean.threed.FieldVector3D; import org.apache.commons.math4.geometry.euclidean.threed.NotARotationMatrixException; import org.apache.commons.math4.geometry.euclidean.threed.Rotation; import org.apache.commons.math4.geometry.euclidean.threed.RotationOrder; -import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; import org.apache.commons.math4.random.UnitSphereRandomVectorGenerator; import org.apache.commons.rng.UniformRandomProvider; import org.apache.commons.rng.simple.RandomSource; @@ -816,7 +816,7 @@ public class FieldRotationDfpTest { FieldVector3D<Dfp> uds = createVector(x, y, z); FieldVector3D<Dfp> ruds = r.applyTo(uds); FieldVector3D<Dfp> rIuds = r.applyInverseTo(uds); - Coordinates3D u = new Coordinates3D(x, y, z); + Cartesian3D u = new Cartesian3D(x, y, z); FieldVector3D<Dfp> ru = r.applyTo(u); FieldVector3D<Dfp> rIu = r.applyInverseTo(u); Dfp[] ruArray = new Dfp[3]; @@ -842,7 +842,7 @@ public class FieldRotationDfpTest { UnitSphereRandomVectorGenerator g = new UnitSphereRandomVectorGenerator(3, random); for (int i = 0; i < 10; ++i) { double[] unit1 = g.nextVector(); - Rotation r1 = new Rotation(new Coordinates3D(unit1[0], unit1[1], unit1[2]), + Rotation r1 = new Rotation(new Cartesian3D(unit1[0], unit1[1], unit1[2]), random.nextDouble(), RotationConvention.VECTOR_OPERATOR); FieldRotation<Dfp> r1Prime = new FieldRotation<>(field.newDfp(r1.getQ0()), field.newDfp(r1.getQ1()),
