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/12 21:32:22 UTC
[13/31] [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/test/java/org/apache/commons/math4/geometry/euclidean/twod/SegmentTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SegmentTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SegmentTest.java
index 41f9d77..cbbd003 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SegmentTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SegmentTest.java
@@ -18,7 +18,7 @@ package org.apache.commons.math4.geometry.euclidean.twod;
import org.apache.commons.math4.geometry.euclidean.twod.Line;
import org.apache.commons.math4.geometry.euclidean.twod.Segment;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.util.FastMath;
import org.junit.Assert;
import org.junit.Test;
@@ -27,20 +27,20 @@ public class SegmentTest {
@Test
public void testDistance() {
- Coordinates2D start = new Coordinates2D(2, 2);
- Coordinates2D end = new Coordinates2D(-2, -2);
+ Cartesian2D start = new Cartesian2D(2, 2);
+ Cartesian2D end = new Cartesian2D(-2, -2);
Segment segment = new Segment(start, end, new Line(start, end, 1.0e-10));
// distance to center of segment
- Assert.assertEquals(FastMath.sqrt(2), segment.distance(new Coordinates2D(1, -1)), 1.0e-10);
+ Assert.assertEquals(FastMath.sqrt(2), segment.distance(new Cartesian2D(1, -1)), 1.0e-10);
// distance a point on segment
- Assert.assertEquals(FastMath.sin(Math.PI / 4.0), segment.distance(new Coordinates2D(0, -1)), 1.0e-10);
+ Assert.assertEquals(FastMath.sin(Math.PI / 4.0), segment.distance(new Cartesian2D(0, -1)), 1.0e-10);
// distance to end point
- Assert.assertEquals(FastMath.sqrt(8), segment.distance(new Coordinates2D(0, 4)), 1.0e-10);
+ Assert.assertEquals(FastMath.sqrt(8), segment.distance(new Cartesian2D(0, 4)), 1.0e-10);
// distance to start point
- Assert.assertEquals(FastMath.sqrt(8), segment.distance(new Coordinates2D(0, -4)), 1.0e-10);
+ Assert.assertEquals(FastMath.sqrt(8), segment.distance(new Cartesian2D(0, -4)), 1.0e-10);
}
}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SubLineTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SubLineTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SubLineTest.java
index c59ab8c..cdfc2c0 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SubLineTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/SubLineTest.java
@@ -23,7 +23,7 @@ import org.apache.commons.math4.geometry.euclidean.oned.IntervalsSet;
import org.apache.commons.math4.geometry.euclidean.twod.Line;
import org.apache.commons.math4.geometry.euclidean.twod.Segment;
import org.apache.commons.math4.geometry.euclidean.twod.SubLine;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.partitioning.RegionFactory;
import org.junit.Assert;
import org.junit.Test;
@@ -32,19 +32,19 @@ public class SubLineTest {
@Test
public void testEndPoints() {
- Coordinates2D p1 = new Coordinates2D(-1, -7);
- Coordinates2D p2 = new Coordinates2D(7, -1);
+ Cartesian2D p1 = new Cartesian2D(-1, -7);
+ Cartesian2D p2 = new Cartesian2D(7, -1);
Segment segment = new Segment(p1, p2, new Line(p1, p2, 1.0e-10));
SubLine sub = new SubLine(segment);
List<Segment> segments = sub.getSegments();
Assert.assertEquals(1, segments.size());
- Assert.assertEquals(0.0, new Coordinates2D(-1, -7).distance(segments.get(0).getStart()), 1.0e-10);
- Assert.assertEquals(0.0, new Coordinates2D( 7, -1).distance(segments.get(0).getEnd()), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(-1, -7).distance(segments.get(0).getStart()), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D( 7, -1).distance(segments.get(0).getEnd()), 1.0e-10);
}
@Test
public void testNoEndPoints() {
- SubLine wholeLine = new Line(new Coordinates2D(-1, 7), new Coordinates2D(7, 1), 1.0e-10).wholeHyperplane();
+ SubLine wholeLine = new Line(new Cartesian2D(-1, 7), new Cartesian2D(7, 1), 1.0e-10).wholeHyperplane();
List<Segment> segments = wholeLine.getSegments();
Assert.assertEquals(1, segments.size());
Assert.assertTrue(Double.isInfinite(segments.get(0).getStart().getX()) &&
@@ -59,7 +59,7 @@ public class SubLineTest {
@Test
public void testNoSegments() {
- SubLine empty = new SubLine(new Line(new Coordinates2D(-1, -7), new Coordinates2D(7, -1), 1.0e-10),
+ SubLine empty = new SubLine(new Line(new Cartesian2D(-1, -7), new Cartesian2D(7, -1), 1.0e-10),
new RegionFactory<Euclidean1D>().getComplement(new IntervalsSet(1.0e-10)));
List<Segment> segments = empty.getSegments();
Assert.assertEquals(0, segments.size());
@@ -67,7 +67,7 @@ public class SubLineTest {
@Test
public void testSeveralSegments() {
- SubLine twoSubs = new SubLine(new Line(new Coordinates2D(-1, -7), new Coordinates2D(7, -1), 1.0e-10),
+ SubLine twoSubs = new SubLine(new Line(new Cartesian2D(-1, -7), new Cartesian2D(7, -1), 1.0e-10),
new RegionFactory<Euclidean1D>().union(new IntervalsSet(1, 2, 1.0e-10),
new IntervalsSet(3, 4, 1.0e-10)));
List<Segment> segments = twoSubs.getSegments();
@@ -76,7 +76,7 @@ public class SubLineTest {
@Test
public void testHalfInfiniteNeg() {
- SubLine empty = new SubLine(new Line(new Coordinates2D(-1, -7), new Coordinates2D(7, -1), 1.0e-10),
+ SubLine empty = new SubLine(new Line(new Cartesian2D(-1, -7), new Cartesian2D(7, -1), 1.0e-10),
new IntervalsSet(Double.NEGATIVE_INFINITY, 0.0, 1.0e-10));
List<Segment> segments = empty.getSegments();
Assert.assertEquals(1, segments.size());
@@ -84,16 +84,16 @@ public class SubLineTest {
segments.get(0).getStart().getX() < 0);
Assert.assertTrue(Double.isInfinite(segments.get(0).getStart().getY()) &&
segments.get(0).getStart().getY() < 0);
- Assert.assertEquals(0.0, new Coordinates2D(3, -4).distance(segments.get(0).getEnd()), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(3, -4).distance(segments.get(0).getEnd()), 1.0e-10);
}
@Test
public void testHalfInfinitePos() {
- SubLine empty = new SubLine(new Line(new Coordinates2D(-1, -7), new Coordinates2D(7, -1), 1.0e-10),
+ SubLine empty = new SubLine(new Line(new Cartesian2D(-1, -7), new Cartesian2D(7, -1), 1.0e-10),
new IntervalsSet(0.0, Double.POSITIVE_INFINITY, 1.0e-10));
List<Segment> segments = empty.getSegments();
Assert.assertEquals(1, segments.size());
- Assert.assertEquals(0.0, new Coordinates2D(3, -4).distance(segments.get(0).getStart()), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(3, -4).distance(segments.get(0).getStart()), 1.0e-10);
Assert.assertTrue(Double.isInfinite(segments.get(0).getEnd().getX()) &&
segments.get(0).getEnd().getX() > 0);
Assert.assertTrue(Double.isInfinite(segments.get(0).getEnd().getY()) &&
@@ -102,56 +102,56 @@ public class SubLineTest {
@Test
public void testIntersectionInsideInside() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(3, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 2), 1.0e-10);
- Assert.assertEquals(0.0, new Coordinates2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
- Assert.assertEquals(0.0, new Coordinates2D(2, 1).distance(sub1.intersection(sub2, false)), 1.0e-12);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(3, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 2), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
+ Assert.assertEquals(0.0, new Cartesian2D(2, 1).distance(sub1.intersection(sub2, false)), 1.0e-12);
}
@Test
public void testIntersectionInsideBoundary() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(3, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 1), 1.0e-10);
- Assert.assertEquals(0.0, new Coordinates2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(3, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 1), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
Assert.assertNull(sub1.intersection(sub2, false));
}
@Test
public void testIntersectionInsideOutside() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(3, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 0.5), 1.0e-10);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(3, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 0.5), 1.0e-10);
Assert.assertNull(sub1.intersection(sub2, true));
Assert.assertNull(sub1.intersection(sub2, false));
}
@Test
public void testIntersectionBoundaryBoundary() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(2, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 1), 1.0e-10);
- Assert.assertEquals(0.0, new Coordinates2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(2, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 1), 1.0e-10);
+ Assert.assertEquals(0.0, new Cartesian2D(2, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
Assert.assertNull(sub1.intersection(sub2, false));
}
@Test
public void testIntersectionBoundaryOutside() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(2, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 0.5), 1.0e-10);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(2, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 0.5), 1.0e-10);
Assert.assertNull(sub1.intersection(sub2, true));
Assert.assertNull(sub1.intersection(sub2, false));
}
@Test
public void testIntersectionOutsideOutside() {
- SubLine sub1 = new SubLine(new Coordinates2D(1, 1), new Coordinates2D(1.5, 1), 1.0e-10);
- SubLine sub2 = new SubLine(new Coordinates2D(2, 0), new Coordinates2D(2, 0.5), 1.0e-10);
+ SubLine sub1 = new SubLine(new Cartesian2D(1, 1), new Cartesian2D(1.5, 1), 1.0e-10);
+ SubLine sub2 = new SubLine(new Cartesian2D(2, 0), new Cartesian2D(2, 0.5), 1.0e-10);
Assert.assertNull(sub1.intersection(sub2, true));
Assert.assertNull(sub1.intersection(sub2, false));
}
@Test
public void testIntersectionParallel() {
- final SubLine sub1 = new SubLine(new Coordinates2D(0, 1), new Coordinates2D(0, 2), 1.0e-10);
- final SubLine sub2 = new SubLine(new Coordinates2D(66, 3), new Coordinates2D(66, 4), 1.0e-10);
+ final SubLine sub1 = new SubLine(new Cartesian2D(0, 1), new Cartesian2D(0, 2), 1.0e-10);
+ final SubLine sub2 = new SubLine(new Cartesian2D(66, 3), new Cartesian2D(66, 4), 1.0e-10);
Assert.assertNull(sub1.intersection(sub2, true));
Assert.assertNull(sub1.intersection(sub2, false));
}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DFormatAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DFormatAbstractTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DFormatAbstractTest.java
index 491a04d..11f518a 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DFormatAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DFormatAbstractTest.java
@@ -22,7 +22,7 @@ import java.text.ParsePosition;
import java.util.Locale;
import org.apache.commons.math4.exception.MathParseException;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.euclidean.twod.Vector2DFormat;
import org.junit.Assert;
import org.junit.Test;
@@ -45,7 +45,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testSimpleNoDecimals() {
- Coordinates2D c = new Coordinates2D(1, 1);
+ Cartesian2D c = new Cartesian2D(1, 1);
String expected = "{1; 1}";
String actual = vector2DFormat.format(c);
Assert.assertEquals(expected, actual);
@@ -53,7 +53,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testSimpleWithDecimals() {
- Coordinates2D c = new Coordinates2D(1.23, 1.43);
+ Cartesian2D c = new Cartesian2D(1.23, 1.43);
String expected =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
@@ -64,7 +64,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testSimpleWithDecimalsTrunc() {
- Coordinates2D c = new Coordinates2D(1.232323232323, 1.434343434343);
+ Cartesian2D c = new Cartesian2D(1.232323232323, 1.434343434343);
String expected =
"{1" + getDecimalCharacter() +
"2323232323; 1" + getDecimalCharacter() +
@@ -75,7 +75,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testNegativeX() {
- Coordinates2D c = new Coordinates2D(-1.232323232323, 1.43);
+ Cartesian2D c = new Cartesian2D(-1.232323232323, 1.43);
String expected =
"{-1" + getDecimalCharacter() +
"2323232323; 1" + getDecimalCharacter() +
@@ -86,7 +86,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testNegativeY() {
- Coordinates2D c = new Coordinates2D(1.23, -1.434343434343);
+ Cartesian2D c = new Cartesian2D(1.23, -1.434343434343);
String expected =
"{1" + getDecimalCharacter() +
"23; -1" + getDecimalCharacter() +
@@ -97,7 +97,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testNegativeZ() {
- Coordinates2D c = new Coordinates2D(1.23, 1.43);
+ Cartesian2D c = new Cartesian2D(1.23, 1.43);
String expected =
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
@@ -108,7 +108,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testNonDefaultSetting() {
- Coordinates2D c = new Coordinates2D(1, 1);
+ Cartesian2D c = new Cartesian2D(1, 1);
String expected = "[1 : 1]";
String actual = vector2DFormatSquare.format(c);
Assert.assertEquals(expected, actual);
@@ -119,7 +119,7 @@ public abstract class Vector2DFormatAbstractTest {
Locale defaultLocal = Locale.getDefault();
Locale.setDefault(getLocale());
- Coordinates2D c = new Coordinates2D(232.22222222222, -342.3333333333);
+ Cartesian2D c = new Cartesian2D(232.22222222222, -342.3333333333);
String expected =
"{232" + getDecimalCharacter() +
"2222222222; -342" + getDecimalCharacter() +
@@ -132,7 +132,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testNan() {
- Coordinates2D c = Coordinates2D.NaN;
+ Cartesian2D c = Cartesian2D.NaN;
String expected = "{(NaN); (NaN)}";
String actual = vector2DFormat.format(c);
Assert.assertEquals(expected, actual);
@@ -140,7 +140,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testPositiveInfinity() {
- Coordinates2D c = Coordinates2D.POSITIVE_INFINITY;
+ Cartesian2D c = Cartesian2D.POSITIVE_INFINITY;
String expected = "{(Infinity); (Infinity)}";
String actual = vector2DFormat.format(c);
Assert.assertEquals(expected, actual);
@@ -148,7 +148,7 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void tesNegativeInfinity() {
- Coordinates2D c = Coordinates2D.NEGATIVE_INFINITY;
+ Cartesian2D c = Cartesian2D.NEGATIVE_INFINITY;
String expected = "{(-Infinity); (-Infinity)}";
String actual = vector2DFormat.format(c);
Assert.assertEquals(expected, actual);
@@ -157,14 +157,14 @@ public abstract class Vector2DFormatAbstractTest {
@Test
public void testParseSimpleNoDecimals() throws MathParseException {
String source = "{1; 1}";
- Coordinates2D expected = new Coordinates2D(1, 1);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(1, 1);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@Test
public void testParseIgnoredWhitespace() {
- Coordinates2D expected = new Coordinates2D(1, 1);
+ Cartesian2D expected = new Cartesian2D(1, 1);
ParsePosition pos1 = new ParsePosition(0);
String source1 = "{1;1}";
Assert.assertEquals(expected, vector2DFormat.parse(source1, pos1));
@@ -181,8 +181,8 @@ public abstract class Vector2DFormatAbstractTest {
"{1" + getDecimalCharacter() +
"23; 1" + getDecimalCharacter() +
"43}";
- Coordinates2D expected = new Coordinates2D(1.23, 1.43);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(1.23, 1.43);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -192,8 +192,8 @@ public abstract class Vector2DFormatAbstractTest {
"{1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(1.2323, 1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(1.2323, 1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -203,8 +203,8 @@ public abstract class Vector2DFormatAbstractTest {
"{-1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(-1.2323, 1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(-1.2323, 1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -214,8 +214,8 @@ public abstract class Vector2DFormatAbstractTest {
"{1" + getDecimalCharacter() +
"2323; -1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(1.2323, -1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(1.2323, -1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -225,8 +225,8 @@ public abstract class Vector2DFormatAbstractTest {
"{1" + getDecimalCharacter() +
"2323; 1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(1.2323, 1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(1.2323, 1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -236,8 +236,8 @@ public abstract class Vector2DFormatAbstractTest {
"{-1" + getDecimalCharacter() +
"2323; -1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(-1.2323, -1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(-1.2323, -1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -247,8 +247,8 @@ public abstract class Vector2DFormatAbstractTest {
"{0" + getDecimalCharacter() +
"0; -1" + getDecimalCharacter() +
"4343}";
- Coordinates2D expected = new Coordinates2D(0.0, -1.4343);
- Coordinates2D actual = vector2DFormat.parse(source);
+ Cartesian2D expected = new Cartesian2D(0.0, -1.4343);
+ Cartesian2D actual = vector2DFormat.parse(source);
Assert.assertEquals(expected, actual);
}
@@ -258,30 +258,30 @@ public abstract class Vector2DFormatAbstractTest {
"[1" + getDecimalCharacter() +
"2323 : 1" + getDecimalCharacter() +
"4343]";
- Coordinates2D expected = new Coordinates2D(1.2323, 1.4343);
- Coordinates2D actual = vector2DFormatSquare.parse(source);
+ Cartesian2D expected = new Cartesian2D(1.2323, 1.4343);
+ Cartesian2D actual = vector2DFormatSquare.parse(source);
Assert.assertEquals(expected, actual);
}
@Test
public void testParseNan() throws MathParseException {
String source = "{(NaN); (NaN)}";
- Coordinates2D actual = vector2DFormat.parse(source);
- Assert.assertEquals(Coordinates2D.NaN, actual);
+ Cartesian2D actual = vector2DFormat.parse(source);
+ Assert.assertEquals(Cartesian2D.NaN, actual);
}
@Test
public void testParsePositiveInfinity() throws MathParseException {
String source = "{(Infinity); (Infinity)}";
- Coordinates2D actual = vector2DFormat.parse(source);
- Assert.assertEquals(Coordinates2D.POSITIVE_INFINITY, actual);
+ Cartesian2D actual = vector2DFormat.parse(source);
+ Assert.assertEquals(Cartesian2D.POSITIVE_INFINITY, actual);
}
@Test
public void testParseNegativeInfinity() throws MathParseException {
String source = "{(-Infinity); (-Infinity)}";
- Coordinates2D actual = vector2DFormat.parse(source);
- Assert.assertEquals(Coordinates2D.NEGATIVE_INFINITY, actual);
+ Cartesian2D actual = vector2DFormat.parse(source);
+ Assert.assertEquals(Cartesian2D.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/twod/Vector2DTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
index 77b68d1..cb760b2 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/Vector2DTest.java
@@ -28,11 +28,11 @@ public class Vector2DTest {
@Test
public void testScaledVectorTripleConstructor() {
- Coordinates2D oneOne = new Coordinates2D(1.0,1.0);
- Coordinates2D oneTwo = new Coordinates2D(1.0,2.0);
- Coordinates2D oneThree = new Coordinates2D(1.0,3.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0,1.0);
+ Cartesian2D oneTwo = new Cartesian2D(1.0,2.0);
+ Cartesian2D oneThree = new Cartesian2D(1.0,3.0);
- Coordinates2D tripleCombo = new Coordinates2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree);
+ Cartesian2D tripleCombo = new Cartesian2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree);
Assert.assertEquals(3.0 * 1 + 1.0 * 1 + 2.5 * 1,tripleCombo.getX(), EPS);
Assert.assertEquals(3.0 * 1 + 1.0 * 2 + 2.5 * 3,tripleCombo.getY(), EPS);
@@ -40,12 +40,12 @@ public class Vector2DTest {
@Test
public void testScaledVectorQuadrupleConstructor() {
- Coordinates2D oneOne = new Coordinates2D(1.0, 1.0);
- Coordinates2D oneTwo = new Coordinates2D(1.0, 2.0);
- Coordinates2D oneThree = new Coordinates2D(1.0, 3.0);
- Coordinates2D oneFour = new Coordinates2D(1.0, 4.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0, 1.0);
+ Cartesian2D oneTwo = new Cartesian2D(1.0, 2.0);
+ Cartesian2D oneThree = new Cartesian2D(1.0, 3.0);
+ Cartesian2D oneFour = new Cartesian2D(1.0, 4.0);
- Coordinates2D tripleCombo = new Coordinates2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree, 2.0, oneFour);
+ Cartesian2D tripleCombo = new Cartesian2D(3.0, oneOne, 1.0, oneTwo, 2.5, oneThree, 2.0, oneFour);
Assert.assertEquals(3.0 * 1.0 + 1.0 * 1.0 + 2.5 * 1.0 + 2.0 * 1.0,tripleCombo.getX(), EPS);
Assert.assertEquals(3.0 * 1.0 + 1.0 * 2.0 + 2.5 * 3.0 + 2.0 * 4.0,tripleCombo.getY(), EPS);
@@ -55,7 +55,7 @@ public class Vector2DTest {
public void testConstructorExceptions() {
double[] v = new double[] {0.0, 1.0, 2.0};
try {
- new Coordinates2D(v);
+ new Cartesian2D(v);
}
catch (Exception e) {
Assert.assertTrue(e instanceof DimensionMismatchException);
@@ -64,7 +64,7 @@ public class Vector2DTest {
@Test
public void testToArray() {
- Coordinates2D oneTwo = new Coordinates2D(1.0, 2.0);
+ Cartesian2D oneTwo = new Cartesian2D(1.0, 2.0);
double[] array = oneTwo.toArray();
Assert.assertEquals(1.0, array[0], EPS);
Assert.assertEquals(2.0, array[1], EPS);
@@ -72,72 +72,72 @@ public class Vector2DTest {
@Test
public void testGetZero() {
- Coordinates2D zero = (new Coordinates2D(1.0, 1.0)).getZero();
+ Cartesian2D zero = (new Cartesian2D(1.0, 1.0)).getZero();
Assert.assertEquals(0.0, zero.getX(), EPS);
Assert.assertEquals(0.0, zero.getY(), EPS);
}
@Test
public void testNorm1() {
- Coordinates2D oneTwo = new Coordinates2D(-1.0, 2.0);
+ Cartesian2D oneTwo = new Cartesian2D(-1.0, 2.0);
Assert.assertEquals(3.0, oneTwo.getNorm1(), EPS);
}
@Test
public void testNormSq() {
- Coordinates2D oneTwo = new Coordinates2D(-1.0, 2.0);
+ Cartesian2D oneTwo = new Cartesian2D(-1.0, 2.0);
Assert.assertEquals(5.0, oneTwo.getNormSq(), EPS);
}
@Test
public void testNormInf() {
- Coordinates2D oneTwo = new Coordinates2D(-1.0, 2.0);
+ Cartesian2D oneTwo = new Cartesian2D(-1.0, 2.0);
Assert.assertEquals(2.0, oneTwo.getNormInf(), EPS);
}
@Test
public void testVectorAddition() {
- Coordinates2D minusOneTwo = new Coordinates2D(-1.0,2.0);
- Coordinates2D threeFive = new Coordinates2D(3.0,5.0);
- Coordinates2D addition = minusOneTwo.add(threeFive);
+ Cartesian2D minusOneTwo = new Cartesian2D(-1.0,2.0);
+ Cartesian2D threeFive = new Cartesian2D(3.0,5.0);
+ Cartesian2D addition = minusOneTwo.add(threeFive);
Assert.assertEquals(2.0, addition.getX(), EPS);
Assert.assertEquals(7.0, addition.getY(), EPS);
}
@Test
public void testScaledVectorAddition() {
- Coordinates2D minusOneTwo = new Coordinates2D(-1.0,2.0);
- Coordinates2D threeFive = new Coordinates2D(3.0,5.0);
- Coordinates2D addition = minusOneTwo.add(2.0, threeFive);
+ Cartesian2D minusOneTwo = new Cartesian2D(-1.0,2.0);
+ Cartesian2D threeFive = new Cartesian2D(3.0,5.0);
+ Cartesian2D addition = minusOneTwo.add(2.0, threeFive);
Assert.assertEquals(5.0, addition.getX(), EPS);
Assert.assertEquals(12.0, addition.getY(), EPS);
}
@Test
public void testVectorSubtraction() {
- Coordinates2D minusOneTwo = new Coordinates2D(-1.0,2.0);
- Coordinates2D threeFive = new Coordinates2D(3.0,5.0);
- Coordinates2D addition = minusOneTwo.subtract(threeFive);
+ Cartesian2D minusOneTwo = new Cartesian2D(-1.0,2.0);
+ Cartesian2D threeFive = new Cartesian2D(3.0,5.0);
+ Cartesian2D addition = minusOneTwo.subtract(threeFive);
Assert.assertEquals(-4.0, addition.getX(), EPS);
Assert.assertEquals(-3.0, addition.getY(), EPS);
}
@Test
public void testScaledVectorSubtraction() {
- Coordinates2D minusOneTwo = new Coordinates2D(-1.0,2.0);
- Coordinates2D threeFive = new Coordinates2D(3.0,5.0);
- Coordinates2D addition = minusOneTwo.subtract(2.0, threeFive);
+ Cartesian2D minusOneTwo = new Cartesian2D(-1.0,2.0);
+ Cartesian2D threeFive = new Cartesian2D(3.0,5.0);
+ Cartesian2D addition = minusOneTwo.subtract(2.0, threeFive);
Assert.assertEquals(-7.0, addition.getX(), EPS);
Assert.assertEquals(-8.0, addition.getY(), EPS);
}
@Test
public void testNormalize() {
- Coordinates2D minusOneTwo = new Coordinates2D(-1.0,2.0);
- Coordinates2D normalizedMinusOneTwo = minusOneTwo.normalize();
+ Cartesian2D minusOneTwo = new Cartesian2D(-1.0,2.0);
+ Cartesian2D normalizedMinusOneTwo = minusOneTwo.normalize();
Assert.assertEquals(-1.0/FastMath.sqrt(5), normalizedMinusOneTwo.getX(), EPS);
Assert.assertEquals(2.0/FastMath.sqrt(5), normalizedMinusOneTwo.getY(), EPS);
- Coordinates2D zero = minusOneTwo.getZero();
+ Cartesian2D zero = minusOneTwo.getZero();
try {
zero.normalize();
}
@@ -148,88 +148,88 @@ public class Vector2DTest {
@Test
public void testAngle() {
- Coordinates2D oneOne = new Coordinates2D(1.0, 1.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0, 1.0);
try {
- Coordinates2D.angle(oneOne.getZero(), oneOne.getZero());
+ Cartesian2D.angle(oneOne.getZero(), oneOne.getZero());
}
catch (Exception e) {
Assert.assertTrue(e instanceof MathArithmeticException);
}
- Coordinates2D oneZero = new Coordinates2D(1.0,0.0);
- double angle = Coordinates2D.angle(oneOne, oneZero);
+ Cartesian2D oneZero = new Cartesian2D(1.0,0.0);
+ double angle = Cartesian2D.angle(oneOne, oneZero);
Assert.assertEquals(FastMath.PI/4, angle, EPS);
- Assert.assertEquals(0.004999958333958323, Coordinates2D.angle(new Coordinates2D(20.0,0.0), new Coordinates2D(20.0,0.1)), EPS);
+ Assert.assertEquals(0.004999958333958323, Cartesian2D.angle(new Cartesian2D(20.0,0.0), new Cartesian2D(20.0,0.1)), EPS);
}
@Test
public void testNegate() {
- Coordinates2D oneOne = new Coordinates2D(1.0,1.0);
- Coordinates2D negated = oneOne.negate();
+ Cartesian2D oneOne = new Cartesian2D(1.0,1.0);
+ Cartesian2D negated = oneOne.negate();
Assert.assertEquals(-1.0, negated.getX(), EPS);
Assert.assertEquals(-1.0, negated.getY(), EPS);
}
@Test
public void testIsInfinite() {
- Coordinates2D oneOne = new Coordinates2D(1.0, 1.0);
- Coordinates2D infiniteVector = new Coordinates2D(Double.POSITIVE_INFINITY, 0.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0, 1.0);
+ Cartesian2D infiniteVector = new Cartesian2D(Double.POSITIVE_INFINITY, 0.0);
Assert.assertFalse(oneOne.isInfinite());
Assert.assertTrue(infiniteVector.isInfinite());
}
@Test
public void testDistance1() {
- Coordinates2D oneOne = new Coordinates2D(1.0,1.0);
- Coordinates2D fiveEleven = new Coordinates2D(5.0,11.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0,1.0);
+ Cartesian2D fiveEleven = new Cartesian2D(5.0,11.0);
double distance1 = oneOne.distance1(fiveEleven);
Assert.assertEquals(14.0, distance1, EPS);
}
@Test
public void testDistanceInf() {
- Coordinates2D oneOne = new Coordinates2D(1.0,1.0);
- Coordinates2D fiveEleven = new Coordinates2D(5.0,11.0);
+ Cartesian2D oneOne = new Cartesian2D(1.0,1.0);
+ Cartesian2D fiveEleven = new Cartesian2D(5.0,11.0);
double distanceInf = oneOne.distanceInf(fiveEleven);
- double staticDistanceInf = Coordinates2D.distanceInf(oneOne, fiveEleven);
+ double staticDistanceInf = Cartesian2D.distanceInf(oneOne, fiveEleven);
Assert.assertEquals(10.0, distanceInf, EPS);
Assert.assertEquals(distanceInf, staticDistanceInf, EPS);
}
@Test
public void testDistanceSq() {
- Coordinates2D oneFive = new Coordinates2D(1.0, 5.0);
- Coordinates2D fourOne = new Coordinates2D(4.0, 1.0);
+ Cartesian2D oneFive = new Cartesian2D(1.0, 5.0);
+ Cartesian2D fourOne = new Cartesian2D(4.0, 1.0);
double distanceSq = oneFive.distanceSq(fourOne);
- double staticDistanceSq = Coordinates2D.distanceSq(oneFive, fourOne);
+ double staticDistanceSq = Cartesian2D.distanceSq(oneFive, fourOne);
Assert.assertEquals(25.0, distanceSq, EPS);
Assert.assertEquals(distanceSq, staticDistanceSq, EPS);
}
@Test
public void testHashCode() {
- int hashCode = (new Coordinates2D(1.0,1.0)).hashCode();
+ int hashCode = (new Cartesian2D(1.0,1.0)).hashCode();
Assert.assertEquals(887095296, hashCode);
- Assert.assertEquals(542, (new Coordinates2D(Double.NaN, Double.NaN)).hashCode());
+ Assert.assertEquals(542, (new Cartesian2D(Double.NaN, Double.NaN)).hashCode());
}
@Test
public void testToString() {
- Assert.assertEquals("{1; 2}", (new Coordinates2D(1.0,2.0)).toString());
+ Assert.assertEquals("{1; 2}", (new Cartesian2D(1.0,2.0)).toString());
}
@Test
public void testCrossProduct() {
- Coordinates2D p1 = new Coordinates2D(1, 1);
- Coordinates2D p2 = new Coordinates2D(2, 2);
+ Cartesian2D p1 = new Cartesian2D(1, 1);
+ Cartesian2D p2 = new Cartesian2D(2, 2);
- Coordinates2D p3 = new Coordinates2D(3, 3);
+ Cartesian2D p3 = new Cartesian2D(3, 3);
Assert.assertEquals(0.0, p3.crossProduct(p1, p2), EPS);
- Coordinates2D p4 = new Coordinates2D(1, 2);
+ Cartesian2D p4 = new Cartesian2D(1, 2);
Assert.assertEquals(1.0, p4.crossProduct(p1, p2), EPS);
- Coordinates2D p5 = new Coordinates2D(2, 1);
+ Cartesian2D p5 = new Cartesian2D(2, 1);
Assert.assertEquals(-1.0, p5.crossProduct(p1, p2), EPS);
}
}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/AklToussaintHeuristicTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/AklToussaintHeuristicTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/AklToussaintHeuristicTest.java
index d91016a..edc5596 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/AklToussaintHeuristicTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/AklToussaintHeuristicTest.java
@@ -18,7 +18,7 @@ package org.apache.commons.math4.geometry.euclidean.twod.hull;
import java.util.Collection;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.AklToussaintHeuristic;
import org.apache.commons.math4.geometry.euclidean.twod.hull.ConvexHullGenerator2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.MonotoneChain;
@@ -34,7 +34,7 @@ public class AklToussaintHeuristicTest extends ConvexHullGenerator2DAbstractTest
}
@Override
- protected Collection<Coordinates2D> reducePoints(Collection<Coordinates2D> points) {
+ protected Collection<Cartesian2D> reducePoints(Collection<Cartesian2D> points) {
return AklToussaintHeuristic.reducePoints(points);
}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java
index 7f2fc7e..fd32cfe 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/ConvexHullGenerator2DAbstractTest.java
@@ -24,7 +24,7 @@ import java.util.List;
import org.apache.commons.math4.exception.NullArgumentException;
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.math4.geometry.euclidean.twod.hull.ConvexHull2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.ConvexHullGenerator2D;
import org.apache.commons.math4.geometry.partitioning.Region;
@@ -49,7 +49,7 @@ public abstract class ConvexHullGenerator2DAbstractTest {
protected abstract ConvexHullGenerator2D createConvexHullGenerator(boolean includeCollinearPoints);
- protected Collection<Coordinates2D> reducePoints(Collection<Coordinates2D> points) {
+ protected Collection<Cartesian2D> reducePoints(Collection<Cartesian2D> points) {
// do nothing by default, may be overridden by other tests
return points;
}
@@ -70,14 +70,14 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testEmpty() {
- ConvexHull2D hull = generator.generate(Collections.<Coordinates2D>emptyList());
+ ConvexHull2D hull = generator.generate(Collections.<Cartesian2D>emptyList());
Assert.assertTrue(hull.getVertices().length == 0);
Assert.assertTrue(hull.getLineSegments().length == 0);
}
@Test
public void testOnePoint() {
- List<Coordinates2D> points = createRandomPoints(1);
+ List<Cartesian2D> points = createRandomPoints(1);
ConvexHull2D hull = generator.generate(points);
Assert.assertTrue(hull.getVertices().length == 1);
Assert.assertTrue(hull.getLineSegments().length == 0);
@@ -85,7 +85,7 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testTwoPoints() {
- List<Coordinates2D> points = createRandomPoints(2);
+ List<Cartesian2D> points = createRandomPoints(2);
ConvexHull2D hull = generator.generate(points);
Assert.assertTrue(hull.getVertices().length == 2);
Assert.assertTrue(hull.getLineSegments().length == 1);
@@ -93,11 +93,11 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testAllIdentical() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(1, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(1, 1));
final ConvexHull2D hull = generator.generate(points);
Assert.assertTrue(hull.getVertices().length == 1);
@@ -110,7 +110,7 @@ public abstract class ConvexHullGenerator2DAbstractTest {
// randomize the size from 4 to 100
int size = (int) FastMath.floor(random.nextDouble() * 96.0 + 4.0);
- List<Coordinates2D> points = createRandomPoints(size);
+ List<Cartesian2D> points = createRandomPoints(size);
ConvexHull2D hull = generator.generate(reducePoints(points));
checkConvexHull(points, hull);
}
@@ -118,12 +118,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testCollinearPoints() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(4, 1));
- points.add(new Coordinates2D(10, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(4, 1));
+ points.add(new Cartesian2D(10, 1));
final ConvexHull2D hull = generator.generate(points);
checkConvexHull(points, hull);
@@ -131,12 +131,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testCollinearPointsReverse() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(10, 1));
- points.add(new Coordinates2D(4, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(10, 1));
+ points.add(new Cartesian2D(4, 1));
final ConvexHull2D hull = generator.generate(points);
checkConvexHull(points, hull);
@@ -144,12 +144,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testCollinearPointsIncluded() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(4, 1));
- points.add(new Coordinates2D(10, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(4, 1));
+ points.add(new Cartesian2D(10, 1));
final ConvexHull2D hull = createConvexHullGenerator(true).generate(points);
checkConvexHull(points, hull, true);
@@ -157,12 +157,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testCollinearPointsIncludedReverse() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(10, 1));
- points.add(new Coordinates2D(4, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(10, 1));
+ points.add(new Cartesian2D(4, 1));
final ConvexHull2D hull = createConvexHullGenerator(true).generate(points);
checkConvexHull(points, hull, true);
@@ -170,12 +170,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testIdenticalPoints() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(4, 1));
- points.add(new Coordinates2D(1, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(4, 1));
+ points.add(new Cartesian2D(1, 1));
final ConvexHull2D hull = generator.generate(points);
checkConvexHull(points, hull);
@@ -183,12 +183,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testIdenticalPoints2() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(4, 1));
- points.add(new Coordinates2D(1, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(4, 1));
+ points.add(new Cartesian2D(1, 1));
final ConvexHull2D hull = createConvexHullGenerator(true).generate(points);
checkConvexHull(points, hull, true);
@@ -196,12 +196,12 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testClosePoints() {
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(2, 2));
- points.add(new Coordinates2D(2, 4));
- points.add(new Coordinates2D(4, 1));
- points.add(new Coordinates2D(1.00001, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(2, 2));
+ points.add(new Cartesian2D(2, 4));
+ points.add(new Cartesian2D(4, 1));
+ points.add(new Cartesian2D(1.00001, 1));
final ConvexHull2D hull = generator.generate(points);
checkConvexHull(points, hull);
@@ -211,17 +211,17 @@ public abstract class ConvexHullGenerator2DAbstractTest {
public void testCollinearPointOnExistingBoundary() {
// MATH-1135: check that collinear points on the hull are handled correctly
// when only a minimal hull shall be constructed
- final Collection<Coordinates2D> points = new ArrayList<>();
- points.add(new Coordinates2D(7.3152, 34.7472));
- points.add(new Coordinates2D(6.400799999999997, 34.747199999999985));
- points.add(new Coordinates2D(5.486399999999997, 34.7472));
- points.add(new Coordinates2D(4.876799999999999, 34.7472));
- points.add(new Coordinates2D(4.876799999999999, 34.1376));
- points.add(new Coordinates2D(4.876799999999999, 30.48));
- points.add(new Coordinates2D(6.0959999999999965, 30.48));
- points.add(new Coordinates2D(6.0959999999999965, 34.1376));
- points.add(new Coordinates2D(7.315199999999996, 34.1376));
- points.add(new Coordinates2D(7.3152, 30.48));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+ points.add(new Cartesian2D(7.3152, 34.7472));
+ points.add(new Cartesian2D(6.400799999999997, 34.747199999999985));
+ points.add(new Cartesian2D(5.486399999999997, 34.7472));
+ points.add(new Cartesian2D(4.876799999999999, 34.7472));
+ points.add(new Cartesian2D(4.876799999999999, 34.1376));
+ points.add(new Cartesian2D(4.876799999999999, 30.48));
+ points.add(new Cartesian2D(6.0959999999999965, 30.48));
+ points.add(new Cartesian2D(6.0959999999999965, 34.1376));
+ points.add(new Cartesian2D(7.315199999999996, 34.1376));
+ points.add(new Cartesian2D(7.3152, 30.48));
final ConvexHull2D hull = createConvexHullGenerator(false).generate(points);
checkConvexHull(points, hull);
@@ -233,13 +233,13 @@ public abstract class ConvexHullGenerator2DAbstractTest {
// make sure that they are processed in the proper order
// for each algorithm.
- List<Coordinates2D> points = new ArrayList<>();
+ List<Cartesian2D> points = new ArrayList<>();
// first case: 3 points are collinear
- points.add(new Coordinates2D(16.078200000000184, -36.52519999989808));
- points.add(new Coordinates2D(19.164300000000186, -36.52519999989808));
- points.add(new Coordinates2D(19.1643, -25.28136477910407));
- points.add(new Coordinates2D(19.1643, -17.678400000004157));
+ points.add(new Cartesian2D(16.078200000000184, -36.52519999989808));
+ points.add(new Cartesian2D(19.164300000000186, -36.52519999989808));
+ points.add(new Cartesian2D(19.1643, -25.28136477910407));
+ points.add(new Cartesian2D(19.1643, -17.678400000004157));
ConvexHull2D hull = createConvexHullGenerator(false).generate(points);
checkConvexHull(points, hull);
@@ -250,15 +250,15 @@ public abstract class ConvexHullGenerator2DAbstractTest {
points.clear();
// second case: multiple points are collinear
- points.add(new Coordinates2D(0, -29.959696875));
- points.add(new Coordinates2D(0, -31.621809375));
- points.add(new Coordinates2D(0, -28.435696875));
- points.add(new Coordinates2D(0, -33.145809375));
- points.add(new Coordinates2D(3.048, -33.145809375));
- points.add(new Coordinates2D(3.048, -31.621809375));
- points.add(new Coordinates2D(3.048, -29.959696875));
- points.add(new Coordinates2D(4.572, -33.145809375));
- points.add(new Coordinates2D(4.572, -28.435696875));
+ points.add(new Cartesian2D(0, -29.959696875));
+ points.add(new Cartesian2D(0, -31.621809375));
+ points.add(new Cartesian2D(0, -28.435696875));
+ points.add(new Cartesian2D(0, -33.145809375));
+ points.add(new Cartesian2D(3.048, -33.145809375));
+ points.add(new Cartesian2D(3.048, -31.621809375));
+ points.add(new Cartesian2D(3.048, -29.959696875));
+ points.add(new Cartesian2D(4.572, -33.145809375));
+ points.add(new Cartesian2D(4.572, -28.435696875));
hull = createConvexHullGenerator(false).generate(points);
checkConvexHull(points, hull);
@@ -270,7 +270,7 @@ public abstract class ConvexHullGenerator2DAbstractTest {
@Test
public void testIssue1123() {
- List<Coordinates2D> points = new ArrayList<>();
+ List<Cartesian2D> points = new ArrayList<>();
int[][] data = new int[][] { { -11, -1 }, { -11, 0 }, { -11, 1 },
{ -10, -3 }, { -10, -2 }, { -10, -1 }, { -10, 0 }, { -10, 1 },
@@ -324,26 +324,26 @@ public abstract class ConvexHullGenerator2DAbstractTest {
{ 11, -1 }, { 11, 0 }, { 11, 1 } };
for (int[] line : data) {
- points.add(new Coordinates2D(line[0], line[1]));
+ points.add(new Cartesian2D(line[0], line[1]));
}
- Coordinates2D[] referenceHull = new Coordinates2D[] {
- new Coordinates2D(-11.0, -1.0),
- new Coordinates2D(-10.0, -3.0),
- new Coordinates2D( -6.0, -7.0),
- new Coordinates2D( -3.0, -8.0),
- new Coordinates2D( 3.0, -8.0),
- new Coordinates2D( 6.0, -7.0),
- new Coordinates2D( 10.0, -3.0),
- new Coordinates2D( 11.0, -1.0),
- new Coordinates2D( 11.0, 1.0),
- new Coordinates2D( 10.0, 3.0),
- new Coordinates2D( 6.0, 7.0),
- new Coordinates2D( 3.0, 8.0),
- new Coordinates2D( -3.0, 8.0),
- new Coordinates2D( -6.0, 7.0),
- new Coordinates2D(-10.0, 3.0),
- new Coordinates2D(-11.0, 1.0),
+ Cartesian2D[] referenceHull = new Cartesian2D[] {
+ new Cartesian2D(-11.0, -1.0),
+ new Cartesian2D(-10.0, -3.0),
+ new Cartesian2D( -6.0, -7.0),
+ new Cartesian2D( -3.0, -8.0),
+ new Cartesian2D( 3.0, -8.0),
+ new Cartesian2D( 6.0, -7.0),
+ new Cartesian2D( 10.0, -3.0),
+ new Cartesian2D( 11.0, -1.0),
+ new Cartesian2D( 11.0, 1.0),
+ new Cartesian2D( 10.0, 3.0),
+ new Cartesian2D( 6.0, 7.0),
+ new Cartesian2D( 3.0, 8.0),
+ new Cartesian2D( -3.0, 8.0),
+ new Cartesian2D( -6.0, 7.0),
+ new Cartesian2D(-10.0, 3.0),
+ new Cartesian2D(-11.0, 1.0),
};
ConvexHull2D convHull = generator.generate(points);
@@ -352,7 +352,7 @@ public abstract class ConvexHullGenerator2DAbstractTest {
Assert.assertEquals(274.0, hullRegion.getSize(), 1.0e-12);
double perimeter = 0;
for (int i = 0; i < referenceHull.length; ++i) {
- perimeter += Coordinates2D.distance(referenceHull[i],
+ perimeter += Cartesian2D.distance(referenceHull[i],
referenceHull[(i + 1) % referenceHull.length]);
}
Assert.assertEquals(perimeter, hullRegion.getBoundarySize(), 1.0e-12);
@@ -365,26 +365,26 @@ public abstract class ConvexHullGenerator2DAbstractTest {
// ------------------------------------------------------------------------------
- protected final List<Coordinates2D> createRandomPoints(int size) {
+ protected final List<Cartesian2D> createRandomPoints(int size) {
// create the cloud container
- List<Coordinates2D> points = new ArrayList<>(size);
+ List<Cartesian2D> points = new ArrayList<>(size);
// fill the cloud with a random distribution of points
for (int i = 0; i < size; i++) {
- points.add(new Coordinates2D(random.nextDouble() * 2.0 - 1.0, random.nextDouble() * 2.0 - 1.0));
+ points.add(new Cartesian2D(random.nextDouble() * 2.0 - 1.0, random.nextDouble() * 2.0 - 1.0));
}
return points;
}
- protected final void checkConvexHull(final Collection<Coordinates2D> points, final ConvexHull2D hull) {
+ protected final void checkConvexHull(final Collection<Cartesian2D> points, final ConvexHull2D hull) {
checkConvexHull(points, hull, false);
}
- protected final void checkConvexHull(final Collection<Coordinates2D> points, final ConvexHull2D hull,
+ protected final void checkConvexHull(final Collection<Cartesian2D> points, final ConvexHull2D hull,
final boolean includesCollinearPoints) {
checkConvexHull(points, hull, includesCollinearPoints, 1e-10);
}
- protected final void checkConvexHull(final Collection<Coordinates2D> points, final ConvexHull2D hull,
+ protected final void checkConvexHull(final Collection<Cartesian2D> points, final ConvexHull2D hull,
final boolean includesCollinearPoints, final double tolerance) {
Assert.assertNotNull(hull);
Assert.assertTrue(isConvex(hull, includesCollinearPoints, tolerance));
@@ -395,16 +395,16 @@ public abstract class ConvexHullGenerator2DAbstractTest {
protected final boolean isConvex(final ConvexHull2D hull, final boolean includesCollinearPoints,
final double tolerance) {
- final Coordinates2D[] points = hull.getVertices();
+ final Cartesian2D[] points = hull.getVertices();
int sign = 0;
for (int i = 0; i < points.length; i++) {
- Coordinates2D p1 = points[i == 0 ? points.length - 1 : i - 1];
- Coordinates2D p2 = points[i];
- Coordinates2D p3 = points[i == points.length - 1 ? 0 : i + 1];
+ Cartesian2D p1 = points[i == 0 ? points.length - 1 : i - 1];
+ Cartesian2D p2 = points[i];
+ Cartesian2D p3 = points[i == points.length - 1 ? 0 : i + 1];
- Coordinates2D d1 = p2.subtract(p1);
- Coordinates2D d2 = p3.subtract(p2);
+ Cartesian2D d1 = p2.subtract(p1);
+ Cartesian2D d2 = p3.subtract(p2);
Assert.assertTrue(d1.getNorm() > 1e-10);
Assert.assertTrue(d2.getNorm() > 1e-10);
@@ -427,14 +427,14 @@ public abstract class ConvexHullGenerator2DAbstractTest {
}
// verify that all points are inside the convex hull region
- protected final void checkPointsInsideHullRegion(final Collection<Coordinates2D> points,
+ protected final void checkPointsInsideHullRegion(final Collection<Cartesian2D> points,
final ConvexHull2D hull,
final boolean includesCollinearPoints) {
- final Collection<Coordinates2D> hullVertices = Arrays.asList(hull.getVertices());
+ final Collection<Cartesian2D> hullVertices = Arrays.asList(hull.getVertices());
final Region<Euclidean2D> region = hull.createRegion();
- for (final Coordinates2D p : points) {
+ for (final Cartesian2D p : points) {
Location location = region.checkPoint(p);
Assert.assertTrue(location != Location.OUTSIDE);
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/MonotoneChainTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/MonotoneChainTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/MonotoneChainTest.java
index 4813fdd..8ce3979 100644
--- a/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/MonotoneChainTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/twod/hull/MonotoneChainTest.java
@@ -20,7 +20,7 @@ import java.util.ArrayList;
import java.util.Collection;
import org.apache.commons.math4.exception.ConvergenceException;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.ConvexHull2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.ConvexHullGenerator2D;
import org.apache.commons.math4.geometry.euclidean.twod.hull.MonotoneChain;
@@ -40,16 +40,16 @@ public class MonotoneChainTest extends ConvexHullGenerator2DAbstractTest {
@Test(expected=ConvergenceException.class)
public void testConvergenceException() {
- final Collection<Coordinates2D> points = new ArrayList<>();
-
- points.add(new Coordinates2D(1, 1));
- points.add(new Coordinates2D(1, 5));
- points.add(new Coordinates2D(0, 7));
- points.add(new Coordinates2D(1, 10));
- points.add(new Coordinates2D(1, 20));
- points.add(new Coordinates2D(20, 20));
- points.add(new Coordinates2D(20, 40));
- points.add(new Coordinates2D(40, 1));
+ final Collection<Cartesian2D> points = new ArrayList<>();
+
+ points.add(new Cartesian2D(1, 1));
+ points.add(new Cartesian2D(1, 5));
+ points.add(new Cartesian2D(0, 7));
+ points.add(new Cartesian2D(1, 10));
+ points.add(new Cartesian2D(1, 20));
+ points.add(new Cartesian2D(20, 20));
+ points.add(new Cartesian2D(20, 40));
+ points.add(new Cartesian2D(40, 1));
@SuppressWarnings("unused")
final ConvexHull2D hull = new MonotoneChain(true, 2).generate(points);
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionDumper.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionDumper.java b/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionDumper.java
index 5c356a2..0107e22 100644
--- a/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionDumper.java
+++ b/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionDumper.java
@@ -23,15 +23,15 @@ import org.apache.commons.math4.geometry.Space;
import org.apache.commons.math4.geometry.euclidean.oned.Euclidean1D;
import org.apache.commons.math4.geometry.euclidean.oned.IntervalsSet;
import org.apache.commons.math4.geometry.euclidean.oned.OrientedPoint;
-import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D;
+import org.apache.commons.math4.geometry.euclidean.oned.Cartesian1D;
import org.apache.commons.math4.geometry.euclidean.threed.Euclidean3D;
import org.apache.commons.math4.geometry.euclidean.threed.Plane;
import org.apache.commons.math4.geometry.euclidean.threed.PolyhedronsSet;
-import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D;
+import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D;
import org.apache.commons.math4.geometry.euclidean.twod.Euclidean2D;
import org.apache.commons.math4.geometry.euclidean.twod.Line;
import org.apache.commons.math4.geometry.euclidean.twod.PolygonsSet;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.spherical.oned.ArcsSet;
import org.apache.commons.math4.geometry.spherical.oned.LimitAngle;
import org.apache.commons.math4.geometry.spherical.oned.Sphere1D;
@@ -125,7 +125,7 @@ public class RegionDumper {
@Override
protected void formatHyperplane(final Hyperplane<Euclidean2D> hyperplane) {
final Line h = (Line) hyperplane;
- final Coordinates2D p = h.toSpace(Coordinates1D.ZERO);
+ final Cartesian2D p = h.toSpace(Cartesian1D.ZERO);
getFormatter().format("%22.15e %22.15e %22.15e %22.15e",
p.getX(), p.getY(), h.getAngle(), h.getTolerance());
}
@@ -146,7 +146,7 @@ public class RegionDumper {
@Override
protected void formatHyperplane(final Hyperplane<Euclidean3D> hyperplane) {
final Plane h = (Plane) hyperplane;
- final Coordinates3D p = h.toSpace(Coordinates2D.ZERO);
+ final Cartesian3D p = h.toSpace(Cartesian2D.ZERO);
getFormatter().format("%22.15e %22.15e %22.15e %22.15e %22.15e %22.15e %22.15e",
p.getX(), p.getY(), p.getZ(),
h.getNormal().getX(), h.getNormal().getY(), h.getNormal().getZ(),
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionParser.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionParser.java b/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionParser.java
index 23a4c01..c338749 100644
--- a/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionParser.java
+++ b/src/test/java/org/apache/commons/math4/geometry/partitioning/RegionParser.java
@@ -24,15 +24,15 @@ import org.apache.commons.math4.geometry.Space;
import org.apache.commons.math4.geometry.euclidean.oned.Euclidean1D;
import org.apache.commons.math4.geometry.euclidean.oned.IntervalsSet;
import org.apache.commons.math4.geometry.euclidean.oned.OrientedPoint;
-import org.apache.commons.math4.geometry.euclidean.oned.Coordinates1D;
+import org.apache.commons.math4.geometry.euclidean.oned.Cartesian1D;
import org.apache.commons.math4.geometry.euclidean.threed.Euclidean3D;
import org.apache.commons.math4.geometry.euclidean.threed.Plane;
import org.apache.commons.math4.geometry.euclidean.threed.PolyhedronsSet;
-import org.apache.commons.math4.geometry.euclidean.threed.Coordinates3D;
+import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D;
import org.apache.commons.math4.geometry.euclidean.twod.Euclidean2D;
import org.apache.commons.math4.geometry.euclidean.twod.Line;
import org.apache.commons.math4.geometry.euclidean.twod.PolygonsSet;
-import org.apache.commons.math4.geometry.euclidean.twod.Coordinates2D;
+import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D;
import org.apache.commons.math4.geometry.spherical.oned.ArcsSet;
import org.apache.commons.math4.geometry.spherical.oned.LimitAngle;
import org.apache.commons.math4.geometry.spherical.oned.S1Point;
@@ -90,7 +90,7 @@ public class RegionParser {
@Override
public Circle parseHyperplane()
throws IOException, ParseException {
- return new Circle(new Coordinates3D(getNumber(), getNumber(), getNumber()), getNumber());
+ return new Circle(new Cartesian3D(getNumber(), getNumber(), getNumber()), getNumber());
}
};
@@ -111,7 +111,7 @@ public class RegionParser {
@Override
public OrientedPoint parseHyperplane()
throws IOException, ParseException {
- return new OrientedPoint(new Coordinates1D(getNumber()), getBoolean(), getNumber());
+ return new OrientedPoint(new Cartesian1D(getNumber()), getBoolean(), getNumber());
}
};
@@ -132,7 +132,7 @@ public class RegionParser {
@Override
public Line parseHyperplane()
throws IOException, ParseException {
- return new Line(new Coordinates2D(getNumber(), getNumber()), getNumber(), getNumber());
+ return new Line(new Cartesian2D(getNumber(), getNumber()), getNumber(), getNumber());
}
};
@@ -153,8 +153,8 @@ public class RegionParser {
@Override
public Plane parseHyperplane()
throws IOException, ParseException {
- return new Plane(new Coordinates3D(getNumber(), getNumber(), getNumber()),
- new Coordinates3D(getNumber(), getNumber(), getNumber()),
+ return new Plane(new Cartesian3D(getNumber(), getNumber(), getNumber()),
+ new Cartesian3D(getNumber(), getNumber(), getNumber()),
getNumber());
}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/e21d4d43/src/test/java/org/apache/commons/math4/geometry/spherical/twod/CircleTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/geometry/spherical/twod/CircleTest.java b/src/test/java/org/apache/commons/math4/geometry/spherical/twod/CircleTest.java
index 3b6cd9d..f45c22d 100644
--- a/src/test/java/org/apache/commons/math4/geometry/spherical/twod/CircleTest.java
+++ b/src/test/java/org/apache/commons/math4/geometry/spherical/twod/CircleTest.java
@@ -18,7 +18,7 @@ package org.apache.commons.math4.geometry.spherical.twod;
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.geometry.partitioning.Transform;
import org.apache.commons.math4.geometry.spherical.oned.Arc;
import org.apache.commons.math4.geometry.spherical.oned.LimitAngle;
@@ -40,13 +40,13 @@ public class CircleTest {
@Test
public void testEquator() {
- Circle circle = new Circle(new Coordinates3D(0, 0, 1000), 1.0e-10).copySelf();
- Assert.assertEquals(Coordinates3D.PLUS_K, circle.getPole());
+ Circle circle = new Circle(new Cartesian3D(0, 0, 1000), 1.0e-10).copySelf();
+ Assert.assertEquals(Cartesian3D.PLUS_K, circle.getPole());
Assert.assertEquals(1.0e-10, circle.getTolerance(), 1.0e-20);
circle.revertSelf();
- Assert.assertEquals(Coordinates3D.MINUS_K, circle.getPole());
- Assert.assertEquals(Coordinates3D.PLUS_K, circle.getReverse().getPole());
- Assert.assertEquals(Coordinates3D.MINUS_K, circle.getPole());
+ Assert.assertEquals(Cartesian3D.MINUS_K, circle.getPole());
+ Assert.assertEquals(Cartesian3D.PLUS_K, circle.getReverse().getPole());
+ Assert.assertEquals(Cartesian3D.MINUS_K, circle.getPole());
}
@Test
@@ -54,11 +54,11 @@ public class CircleTest {
Circle circle = new Circle(new S2Point(1.2, 2.5), new S2Point(-4.3, 0), 1.0e-10);
Assert.assertEquals(0.0, circle.getPointAt(0).distance(circle.getXAxis()), 1.0e-10);
Assert.assertEquals(0.0, circle.getPointAt(0.5 * FastMath.PI).distance(circle.getYAxis()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(circle.getXAxis(), circle.getYAxis()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(circle.getXAxis(), circle.getPole()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(circle.getPole(), circle.getYAxis()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(circle.getXAxis(), circle.getYAxis()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(circle.getXAxis(), circle.getPole()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(circle.getPole(), circle.getYAxis()), 1.0e-10);
Assert.assertEquals(0.0,
- circle.getPole().distance(Coordinates3D.crossProduct(circle.getXAxis(), circle.getYAxis())),
+ circle.getPole().distance(Cartesian3D.crossProduct(circle.getXAxis(), circle.getYAxis())),
1.0e-10);
}
@@ -68,16 +68,16 @@ public class CircleTest {
Circle reversed = circle.getReverse();
Assert.assertEquals(0.0, reversed.getPointAt(0).distance(reversed.getXAxis()), 1.0e-10);
Assert.assertEquals(0.0, reversed.getPointAt(0.5 * FastMath.PI).distance(reversed.getYAxis()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(reversed.getXAxis(), reversed.getYAxis()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(reversed.getXAxis(), reversed.getPole()), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(reversed.getPole(), reversed.getYAxis()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(reversed.getXAxis(), reversed.getYAxis()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(reversed.getXAxis(), reversed.getPole()), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(reversed.getPole(), reversed.getYAxis()), 1.0e-10);
Assert.assertEquals(0.0,
- reversed.getPole().distance(Coordinates3D.crossProduct(reversed.getXAxis(), reversed.getYAxis())),
+ reversed.getPole().distance(Cartesian3D.crossProduct(reversed.getXAxis(), reversed.getYAxis())),
1.0e-10);
- Assert.assertEquals(0, Coordinates3D.angle(circle.getXAxis(), reversed.getXAxis()), 1.0e-10);
- Assert.assertEquals(FastMath.PI, Coordinates3D.angle(circle.getYAxis(), reversed.getYAxis()), 1.0e-10);
- Assert.assertEquals(FastMath.PI, Coordinates3D.angle(circle.getPole(), reversed.getPole()), 1.0e-10);
+ Assert.assertEquals(0, Cartesian3D.angle(circle.getXAxis(), reversed.getXAxis()), 1.0e-10);
+ Assert.assertEquals(FastMath.PI, Cartesian3D.angle(circle.getYAxis(), reversed.getYAxis()), 1.0e-10);
+ Assert.assertEquals(FastMath.PI, Cartesian3D.angle(circle.getPole(), reversed.getPole()), 1.0e-10);
Assert.assertTrue(circle.sameOrientationAs(circle));
Assert.assertFalse(circle.sameOrientationAs(reversed));
@@ -87,13 +87,13 @@ public class CircleTest {
@Test
public void testPhase() {
Circle circle = new Circle(new S2Point(1.2, 2.5), new S2Point(-4.3, 0), 1.0e-10);
- Coordinates3D p = new Coordinates3D(1, 2, -4);
- Coordinates3D samePhase = circle.getPointAt(circle.getPhase(p));
+ Cartesian3D p = new Cartesian3D(1, 2, -4);
+ Cartesian3D samePhase = circle.getPointAt(circle.getPhase(p));
Assert.assertEquals(0.0,
- Coordinates3D.angle(Coordinates3D.crossProduct(circle.getPole(), p),
- Coordinates3D.crossProduct(circle.getPole(), samePhase)),
+ Cartesian3D.angle(Cartesian3D.crossProduct(circle.getPole(), p),
+ Cartesian3D.crossProduct(circle.getPole(), samePhase)),
1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(circle.getPole(), samePhase), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(circle.getPole(), samePhase), 1.0e-10);
Assert.assertEquals(circle.getPhase(p), circle.getPhase(samePhase), 1.0e-10);
Assert.assertEquals(0.0, circle.getPhase(circle.getXAxis()), 1.0e-10);
Assert.assertEquals(0.5 * FastMath.PI, circle.getPhase(circle.getYAxis()), 1.0e-10);
@@ -105,7 +105,7 @@ public class CircleTest {
Circle circle = new Circle(new S2Point(1.2, 2.5), new S2Point(-4.3, 0), 1.0e-10);
Assert.assertEquals(0.0, circle.toSubSpace(new S2Point(circle.getXAxis())).getAlpha(), 1.0e-10);
Assert.assertEquals(0.5 * FastMath.PI, circle.toSubSpace(new S2Point(circle.getYAxis())).getAlpha(), 1.0e-10);
- Coordinates3D p = new Coordinates3D(1, 2, -4);
+ Cartesian3D p = new Cartesian3D(1, 2, -4);
Assert.assertEquals(circle.getPhase(p), circle.toSubSpace(new S2Point(p)).getAlpha(), 1.0e-10);
}
@@ -113,23 +113,23 @@ public class CircleTest {
public void testSpace() {
Circle circle = new Circle(new S2Point(1.2, 2.5), new S2Point(-4.3, 0), 1.0e-10);
for (double alpha = 0; alpha < MathUtils.TWO_PI; alpha += 0.1) {
- Coordinates3D p = new Coordinates3D(FastMath.cos(alpha), circle.getXAxis(),
+ Cartesian3D p = new Cartesian3D(FastMath.cos(alpha), circle.getXAxis(),
FastMath.sin(alpha), circle.getYAxis());
- Coordinates3D q = circle.toSpace(new S1Point(alpha)).getVector();
+ Cartesian3D q = circle.toSpace(new S1Point(alpha)).getVector();
Assert.assertEquals(0.0, p.distance(q), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, Coordinates3D.angle(circle.getPole(), q), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, Cartesian3D.angle(circle.getPole(), q), 1.0e-10);
}
}
@Test
public void testOffset() {
- Circle circle = new Circle(Coordinates3D.PLUS_K, 1.0e-10);
- Assert.assertEquals(0.0, circle.getOffset(new S2Point(Coordinates3D.PLUS_I)), 1.0e-10);
- Assert.assertEquals(0.0, circle.getOffset(new S2Point(Coordinates3D.MINUS_I)), 1.0e-10);
- Assert.assertEquals(0.0, circle.getOffset(new S2Point(Coordinates3D.PLUS_J)), 1.0e-10);
- Assert.assertEquals(0.0, circle.getOffset(new S2Point(Coordinates3D.MINUS_J)), 1.0e-10);
- Assert.assertEquals(-0.5 * FastMath.PI, circle.getOffset(new S2Point(Coordinates3D.PLUS_K)), 1.0e-10);
- Assert.assertEquals(0.5 * FastMath.PI, circle.getOffset(new S2Point(Coordinates3D.MINUS_K)), 1.0e-10);
+ Circle circle = new Circle(Cartesian3D.PLUS_K, 1.0e-10);
+ Assert.assertEquals(0.0, circle.getOffset(new S2Point(Cartesian3D.PLUS_I)), 1.0e-10);
+ Assert.assertEquals(0.0, circle.getOffset(new S2Point(Cartesian3D.MINUS_I)), 1.0e-10);
+ Assert.assertEquals(0.0, circle.getOffset(new S2Point(Cartesian3D.PLUS_J)), 1.0e-10);
+ Assert.assertEquals(0.0, circle.getOffset(new S2Point(Cartesian3D.MINUS_J)), 1.0e-10);
+ Assert.assertEquals(-0.5 * FastMath.PI, circle.getOffset(new S2Point(Cartesian3D.PLUS_K)), 1.0e-10);
+ Assert.assertEquals(0.5 * FastMath.PI, circle.getOffset(new S2Point(Cartesian3D.MINUS_K)), 1.0e-10);
}
@@ -138,8 +138,8 @@ public class CircleTest {
UnitSphereRandomVectorGenerator sphRandom = new UnitSphereRandomVectorGenerator(3, RandomSource.create(RandomSource.WELL_1024_A,
0xbfd34e92231bbcfel));
for (int i = 0; i < 100; ++i) {
- Circle c1 = new Circle(new Coordinates3D(sphRandom.nextVector()), 1.0e-10);
- Circle c2 = new Circle(new Coordinates3D(sphRandom.nextVector()), 1.0e-10);
+ Circle c1 = new Circle(new Cartesian3D(sphRandom.nextVector()), 1.0e-10);
+ Circle c2 = new Circle(new Cartesian3D(sphRandom.nextVector()), 1.0e-10);
checkArcIsInside(c1, c2);
checkArcIsInside(c2, c1);
}
@@ -163,16 +163,16 @@ public class CircleTest {
UnitSphereRandomVectorGenerator sphRandom = new UnitSphereRandomVectorGenerator(3, random);
for (int i = 0; i < 100; ++i) {
- Rotation r = new Rotation(new Coordinates3D(sphRandom.nextVector()),
+ Rotation r = new Rotation(new Cartesian3D(sphRandom.nextVector()),
FastMath.PI * random.nextDouble(),
RotationConvention.VECTOR_OPERATOR);
Transform<Sphere2D, Sphere1D> t = Circle.getTransform(r);
- S2Point p = new S2Point(new Coordinates3D(sphRandom.nextVector()));
+ S2Point p = new S2Point(new Cartesian3D(sphRandom.nextVector()));
S2Point tp = (S2Point) t.apply(p);
Assert.assertEquals(0.0, r.applyTo(p.getVector()).distance(tp.getVector()), 1.0e-10);
- Circle c = new Circle(new Coordinates3D(sphRandom.nextVector()), 1.0e-10);
+ Circle c = new Circle(new Cartesian3D(sphRandom.nextVector()), 1.0e-10);
Circle tc = (Circle) t.apply(c);
Assert.assertEquals(0.0, r.applyTo(c.getPole()).distance(tc.getPole()), 1.0e-10);
Assert.assertEquals(0.0, r.applyTo(c.getXAxis()).distance(tc.getXAxis()), 1.0e-10);
@@ -181,9 +181,9 @@ public class CircleTest {
SubLimitAngle sub = new LimitAngle(new S1Point(MathUtils.TWO_PI * random.nextDouble()),
random.nextBoolean(), 1.0e-10).wholeHyperplane();
- Coordinates3D psub = c.getPointAt(((LimitAngle) sub.getHyperplane()).getLocation().getAlpha());
+ Cartesian3D psub = c.getPointAt(((LimitAngle) sub.getHyperplane()).getLocation().getAlpha());
SubLimitAngle tsub = (SubLimitAngle) t.apply(sub, c, tc);
- Coordinates3D ptsub = tc.getPointAt(((LimitAngle) tsub.getHyperplane()).getLocation().getAlpha());
+ Cartesian3D ptsub = tc.getPointAt(((LimitAngle) tsub.getHyperplane()).getLocation().getAlpha());
Assert.assertEquals(0.0, r.applyTo(psub).distance(ptsub), 1.0e-10);
}