You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ra...@apache.org on 2017/05/06 15:04:20 UTC
[07/19] [math] MATH-1284: Replace/rename Coordinate?D classes (nee
Vector?D) as Cartesian?D classes as per discussion. When there are existing
overridden methods accepting Vector and Point,
add a disambiguating method accepting
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()),