MATH-1437: adding additional unit tests and test utilities for o.a.c.m.geometry.euclidean.twod and o.a.c.m.geometry.euclidean.threed
Project: http://git-wip-us.apache.org/repos/asf/commons-math/repo Commit: http://git-wip-us.apache.org/repos/asf/commons-math/commit/24d3dd8b Tree: http://git-wip-us.apache.org/repos/asf/commons-math/tree/24d3dd8b Diff: http://git-wip-us.apache.org/repos/asf/commons-math/diff/24d3dd8b Branch: refs/heads/master Commit: 24d3dd8ba7032bc4590b82a99ff37713fb3cc5bb Parents: 1b99b45 Author: darkma773r <matt.juntu...@hotmail.com> Authored: Thu Jan 25 22:41:43 2018 -0500 Committer: darkma773r <matt.juntu...@hotmail.com> Committed: Thu Jan 25 22:41:43 2018 -0500 ---------------------------------------------------------------------- .../euclidean/threed/PolyhedronsSet.java | 2 +- .../math4/geometry/GeometryTestUtils.java | 324 +++++ .../euclidean/oned/Cartesian1DTest.java | 366 ++++-- .../geometry/euclidean/oned/IntervalTest.java | 158 ++- .../euclidean/oned/IntervalsSetTest.java | 543 +++++++- .../euclidean/oned/OrientedPointTest.java | 188 +++ .../euclidean/oned/SubOrientedPointTest.java | 98 +- .../geometry/euclidean/threed/OBJWriter.java | 337 +++++ .../euclidean/threed/PolyhedronsSetTest.java | 1238 +++++++++++++++--- 9 files changed, 2881 insertions(+), 373 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/PolyhedronsSet.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/PolyhedronsSet.java b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/PolyhedronsSet.java index ab27283..cfd9f7c 100644 --- a/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/PolyhedronsSet.java +++ b/src/main/java/org/apache/commons/math4/geometry/euclidean/threed/PolyhedronsSet.java @@ -512,7 +512,7 @@ public class PolyhedronsSet extends AbstractRegion<Euclidean3D, Euclidean2D> { final Plane plane = (Plane) cut.getHyperplane(); // establish search order - final double offset = plane.getOffset((Point<Euclidean3D>) point); + final double offset = plane.getOffset(point); final boolean in = FastMath.abs(offset) < getTolerance(); final BSPTree<Euclidean3D> near; final BSPTree<Euclidean3D> far; http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/src/test/java/org/apache/commons/math4/geometry/GeometryTestUtils.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/GeometryTestUtils.java b/src/test/java/org/apache/commons/math4/geometry/GeometryTestUtils.java new file mode 100644 index 0000000..74f2beb --- /dev/null +++ b/src/test/java/org/apache/commons/math4/geometry/GeometryTestUtils.java @@ -0,0 +1,324 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.math4.geometry; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.commons.math3.util.FastMath; +import org.apache.commons.math4.geometry.euclidean.oned.Cartesian1D; +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.SubOrientedPoint; +import org.apache.commons.math4.geometry.euclidean.oned.Vector1D; +import org.apache.commons.math4.geometry.euclidean.threed.Cartesian3D; +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.SubPlane; +import org.apache.commons.math4.geometry.euclidean.threed.Vector3D; +import org.apache.commons.math4.geometry.euclidean.twod.Cartesian2D; +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.SubLine; +import org.apache.commons.math4.geometry.euclidean.twod.Vector2D; +import org.apache.commons.math4.geometry.partitioning.BSPTree; +import org.apache.commons.math4.geometry.partitioning.BSPTreeVisitor; +import org.junit.Assert; + +/** Class containing various geometry-related test utilities. + * @since 4.0 + */ +public class GeometryTestUtils { + + /** Asserts that corresponding values in the given vectors are equal, using the specified + * tolerance value. + * @param expected + * @param actual + * @param tolerance + */ + public static void assertVectorEquals(Vector1D expected, Vector1D actual, double tolerance) { + String msg = "Expected vector to equal " + expected + " but was " + actual + ";"; + Assert.assertEquals(msg, expected.getX(), actual.getX(), tolerance); + } + + /** Asserts that corresponding values in the given vectors are equal, using the specified + * tolerance value. + * @param expected + * @param actual + * @param tolerance + */ + public static void assertVectorEquals(Vector2D expected, Vector2D actual, double tolerance) { + String msg = "Expected vector to equal " + expected + " but was " + actual + ";"; + Assert.assertEquals(msg, expected.getX(), actual.getX(), tolerance); + Assert.assertEquals(msg, expected.getY(), actual.getY(), tolerance); + } + + /** Asserts that corresponding values in the given vectors are equal, using the specified + * tolerance value. + * @param expected + * @param actual + * @param tolerance + */ + public static void assertVectorEquals(Vector3D expected, Vector3D actual, double tolerance) { + String msg = "Expected vector to equal " + expected + " but was " + actual + ";"; + Assert.assertEquals(msg, expected.getX(), actual.getX(), tolerance); + Assert.assertEquals(msg, expected.getY(), actual.getY(), tolerance); + Assert.assertEquals(msg, expected.getZ(), actual.getZ(), tolerance); + } + + /** Prints a string representation of the given 1D {@link BSPTree} to + * the console. This is intended for quick debugging of small trees. + * @param tree + */ + public static void printTree1D(BSPTree<Euclidean1D> tree) { + TreePrinter1D printer = new TreePrinter1D(); + System.out.println(printer.writeAsString(tree)); + } + + /** Prints a string representation of the given 2D {@link BSPTree} to + * the console. This is intended for quick debugging of small trees. + * @param tree + */ + public static void printTree2D(BSPTree<Euclidean2D> tree) { + TreePrinter2D printer = new TreePrinter2D(); + System.out.println(printer.writeAsString(tree)); + } + + /** Prints a string representation of the given 3D {@link BSPTree} to + * the console. This is intended for quick debugging of small trees. + * @param tree + */ + public static void printTree3D(BSPTree<Euclidean3D> tree) { + TreePrinter3D printer = new TreePrinter3D(); + System.out.println(printer.writeAsString(tree)); + } + + /** + * Base for classes that create string representations of {@link BSPTree}s. + * @param <S> + */ + public static abstract class TreePrinter<S extends Space> implements BSPTreeVisitor<S> { + + /** Indent per tree level */ + protected static final String INDENT = " "; + + /** Current depth in the tree */ + protected int depth; + + /** Contains the string output */ + protected StringBuilder output = new StringBuilder(); + + /** Returns a string representation of the given {@link BSPTree}. + * @param tree + * @return + */ + public String writeAsString(BSPTree<S> tree) { + output.delete(0, output.length()); + + tree.visit(this); + + return output.toString(); + } + + /** {@inheritDoc} */ + @Override + public Order visitOrder(BSPTree<S> node) { + return Order.SUB_MINUS_PLUS; + } + + /** {@inheritDoc} */ + @Override + public void visitInternalNode(BSPTree<S> node) { + writeLinePrefix(node); + writeInternalNode(node); + + write("\n"); + + ++depth; + } + + /** {@inheritDoc} */ + @Override + public void visitLeafNode(BSPTree<S> node) { + writeLinePrefix(node); + writeLeafNode(node); + + write("\n"); + + BSPTree<S> cur = node; + while (cur.getParent() != null && cur.getParent().getPlus() == cur) { + --depth; + cur = cur.getParent(); + } + } + + /** Writes the prefix for the current line in the output. This includes + * the line indent, the plus/minus node indicator, and a string identifier + * for the node itself. + * @param node + */ + protected void writeLinePrefix(BSPTree<S> node) { + for (int i=0; i<depth; ++i) { + write(INDENT); + } + + if (node.getParent() != null) { + if (node.getParent().getMinus() == node) { + write("[-] "); + } + else { + write("[+] "); + } + } + + write(node.getClass().getSimpleName() + "@" + System.identityHashCode(node) + " | "); + } + + /** Adds the given string to the output. + * @param str + */ + protected void write(String str) { + output.append(str); + } + + /** Method for subclasses to provide their own string representation + * of the given internal node. + */ + protected abstract void writeInternalNode(BSPTree<S> node); + + /** Writes a leaf node. The default implementation here simply writes + * the node attribute as a string. + * @param node + */ + protected void writeLeafNode(BSPTree<S> node) { + write(String.valueOf(node.getAttribute())); + } + } + + /** Class for creating string representations of 1D {@link BSPTree}s. + */ + public static class TreePrinter1D extends TreePrinter<Euclidean1D> { + + /** {@inheritDoc} */ + @Override + protected void writeInternalNode(BSPTree<Euclidean1D> node) { + SubOrientedPoint cut = (SubOrientedPoint) node.getCut(); + + OrientedPoint hyper = (OrientedPoint) cut.getHyperplane(); + write("cut = { hyperplane: "); + if (hyper.isDirect()) { + write("[" + hyper.getLocation().getX() + ", inf)"); + } + else { + write("(-inf, " + hyper.getLocation().getX() + "]"); + } + + IntervalsSet remainingRegion = (IntervalsSet) cut.getRemainingRegion(); + if (remainingRegion != null) { + write(", remainingRegion: ["); + + boolean isFirst = true; + for (double[] interval : remainingRegion) { + if (isFirst) { + isFirst = false; + } + else { + write(", "); + } + write(Arrays.toString(interval)); + } + + write("]"); + } + + write("}"); + } + } + + /** Class for creating string representations of 2D {@link BSPTree}s. + */ + public static class TreePrinter2D extends TreePrinter<Euclidean2D> { + + /** {@inheritDoc} */ + @Override + protected void writeInternalNode(BSPTree<Euclidean2D> node) { + SubLine cut = (SubLine) node.getCut(); + Line line = (Line) cut.getHyperplane(); + IntervalsSet remainingRegion = (IntervalsSet) cut.getRemainingRegion(); + + write("cut = { angle: " + FastMath.toDegrees(line.getAngle()) + ", origin: " + line.toSpace(Cartesian1D.ZERO) + "}"); + write(", remainingRegion: ["); + + boolean isFirst = true; + for (double[] interval : remainingRegion) { + if (isFirst) { + isFirst = false; + } + else { + write(", "); + } + write(Arrays.toString(interval)); + } + + write("]"); + } + } + + /** Class for creating string representations of 3D {@link BSPTree}s. + */ + public static class TreePrinter3D extends TreePrinter<Euclidean3D> { + + /** {@inheritDoc} */ + @Override + protected void writeInternalNode(BSPTree<Euclidean3D> node) { + SubPlane cut = (SubPlane) node.getCut(); + Plane plane = (Plane) cut.getHyperplane(); + PolygonsSet polygon = (PolygonsSet) cut.getRemainingRegion(); + + write("cut = { normal: " + plane.getNormal() + ", origin: " + plane.getOrigin() + "}"); + write(", remainingRegion = ["); + + boolean isFirst = true; + for (Cartesian2D[] loop : polygon.getVertices()) { + // convert to 3-space for easier debugging + List<Cartesian3D> loop3 = new ArrayList<>(); + for (Cartesian2D vertex : loop) { + if (vertex != null) { + loop3.add(plane.toSpace(vertex)); + } + else { + loop3.add(null); + } + } + + if (isFirst) { + isFirst = false; + } + else { + write(", "); + } + + write(loop3.toString()); + } + + write("]"); + } + } +} http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Cartesian1DTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Cartesian1DTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Cartesian1DTest.java index a01c9ef..ebac525 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Cartesian1DTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/Cartesian1DTest.java @@ -22,198 +22,366 @@ import java.text.DecimalFormatSymbols; import java.text.NumberFormat; import java.util.Locale; -import org.apache.commons.math4.exception.DimensionMismatchException; import org.apache.commons.math4.exception.MathArithmeticException; +import org.apache.commons.math4.geometry.Point; import org.apache.commons.math4.geometry.Space; +import org.apache.commons.math4.geometry.Vector; import org.apache.commons.math4.util.FastMath; import org.apache.commons.numbers.core.Precision; import org.junit.Assert; import org.junit.Test; public class Cartesian1DTest { + + private static final double TEST_TOLERANCE = 1e-15; + + @Test + public void testConstants() { + // act/assert + checkVector(Cartesian1D.ZERO, 0.0); + checkVector(Cartesian1D.ONE, 1.0); + checkVector(Cartesian1D.NaN, Double.NaN); + checkVector(Cartesian1D.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY); + checkVector(Cartesian1D.POSITIVE_INFINITY, Double.POSITIVE_INFINITY); + } + + @Test + public void testConstructor_simple() { + // act/assert + checkVector(new Cartesian1D(2), 2); + checkVector(new Cartesian1D(-2), -2); + checkVector(new Cartesian1D(FastMath.PI), FastMath.PI); + } + + @Test + public void testConstructor_multiplicative() { + // act/assert + checkVector(new Cartesian1D(2, new Cartesian1D(3)), 6); + checkVector(new Cartesian1D(-2, new Cartesian1D(3)), -6); + } + + @Test + public void testConstructor_linear2() { + // act/assert + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + 5, new Cartesian1D(7)), 41); + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + -5, new Cartesian1D(7)),-29); + } + + @Test + public void testConstructor_linear3() { + // act/assert + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + 5, new Cartesian1D(7), + 11, new Cartesian1D(13)), 184); + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + 5, new Cartesian1D(7), + -11, new Cartesian1D(13)), -102); + } + @Test - public void testConstructors() throws DimensionMismatchException { - checkVector(new Cartesian1D(3, new Cartesian1D(FastMath.PI / 3)), - FastMath.PI); - checkVector(new Cartesian1D(2, Cartesian1D.ONE, -3, new Cartesian1D(2)), - -4); - checkVector(new Cartesian1D(2, Cartesian1D.ONE, - 5, new Cartesian1D(2), - -3, new Cartesian1D(3)), - 3); - checkVector(new Cartesian1D(2, Cartesian1D.ONE, - 5, new Cartesian1D(2), - 5, new Cartesian1D(-2), - -3, new Cartesian1D(-3)), - 11); + public void testConstructor_linear4() { + // act/assert + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + 5, new Cartesian1D(7), + 11, new Cartesian1D(13), + 17, new Cartesian1D(19)), 507); + checkVector(new Cartesian1D( + 2, new Cartesian1D(3), + 5, new Cartesian1D(7), + 11, new Cartesian1D(13), + -17, new Cartesian1D(19)), -139); } @Test public void testSpace() { + // act Space space = new Cartesian1D(1).getSpace(); + + // assert Assert.assertEquals(1, space.getDimension()); } @Test public void testZero() { - Assert.assertEquals(0, new Cartesian1D(1).getZero().getNorm(), 1.0e-15); + // act + Cartesian1D zero = new Cartesian1D(1).getZero(); + + // assert + Assert.assertEquals(0, zero.getX(), TEST_TOLERANCE); } @Test - public void testEquals() { - 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 Cartesian1D(1 + 10 * Precision.EPSILON))); - Assert.assertTrue(new Cartesian1D(Double.NaN).equals(new Cartesian1D(Double.NaN))); + public void testNorm1() { + // act/assert + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm1(), TEST_TOLERANCE); + Assert.assertEquals(6.0, new Cartesian1D(6).getNorm1(), TEST_TOLERANCE); + Assert.assertEquals(6.0, new Cartesian1D(-6).getNorm1(), TEST_TOLERANCE); } @Test - public void testHash() { - 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()); + public void testNorm() { + // act/assert + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm(), TEST_TOLERANCE); + Assert.assertEquals(3.0, new Cartesian1D(3).getNorm(), TEST_TOLERANCE); + Assert.assertEquals(3.0, new Cartesian1D(-3).getNorm(), TEST_TOLERANCE); } @Test - public void testInfinite() { - 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()); + public void testNormSq() { + // act/assert + Assert.assertEquals(0.0, new Cartesian1D(0).getNormSq(), TEST_TOLERANCE); + Assert.assertEquals(9.0, new Cartesian1D(3).getNormSq(), TEST_TOLERANCE); + Assert.assertEquals(9.0, new Cartesian1D(-3).getNormSq(), TEST_TOLERANCE); } @Test - public void testNaN() { - Assert.assertTrue(new Cartesian1D(Double.NaN).isNaN()); - Assert.assertFalse(new Cartesian1D(1).isNaN()); - Assert.assertFalse(new Cartesian1D(Double.NEGATIVE_INFINITY).isNaN()); + public void testNormInf() { + // act/assert + Assert.assertEquals(0.0, Cartesian1D.ZERO.getNormInf(), TEST_TOLERANCE); + Assert.assertEquals(3.0, new Cartesian1D(3).getNormInf(), TEST_TOLERANCE); + Assert.assertEquals(3.0, new Cartesian1D(-3).getNormInf(), TEST_TOLERANCE); } @Test - public void testToString() { - Assert.assertEquals("{3}", new Cartesian1D(3).toString()); - NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US)); - Assert.assertEquals("{3.000}", new Cartesian1D(3).toString(format)); + public void testAdd() { + // arrange + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-3); + + // act/assert + v1 = v1.add(v2); + checkVector(v1, -2); + + checkVector(v2.add(v1), -5); + checkVector(v2.add(3, v1), -9); } @Test - public void testCoordinates() { - Cartesian1D v = new Cartesian1D(1); - Assert.assertTrue(FastMath.abs(v.getX() - 1) < 1.0e-12); + public void testSubtract() { + // arrange + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-3); + + // act/assert + v1 = v1.subtract(v2); + checkVector(v1, 4); + + checkVector(v2.subtract(v1), -7); + checkVector(v2.subtract(3, v1), -15); } @Test - public void testNorm1() { - Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm1(), 0); - Assert.assertEquals(6.0, new Cartesian1D(6).getNorm1(), 0); + public void testNormalize() { + // act/assert + checkVector(new Cartesian1D(1).normalize(), 1); + checkVector(new Cartesian1D(-1).normalize(), -1); + checkVector(new Cartesian1D(5).normalize(), 1); + checkVector(new Cartesian1D(-5).normalize(), -1); + } + + @Test(expected = MathArithmeticException.class) + public void testNormalize_zeroNorm() { + // act + Cartesian1D.ZERO.normalize(); } @Test - public void testNorm() { - Assert.assertEquals(0.0, Cartesian1D.ZERO.getNorm(), 0); - Assert.assertEquals(3.0, new Cartesian1D(-3).getNorm(), 1.0e-12); + public void testNegate() { + // act/assert + checkVector(new Cartesian1D(0.1).negate(), -0.1); + checkVector(new Cartesian1D(-0.1).negate(), 0.1); } @Test - public void testNormSq() { - Assert.assertEquals(0.0, new Cartesian1D(0).getNormSq(), 0); - Assert.assertEquals(9.0, new Cartesian1D(-3).getNormSq(), 1.0e-12); + public void testScalarMultiply() { + // act/assert + checkVector(new Cartesian1D(1).scalarMultiply(3), 3); + checkVector(new Cartesian1D(1).scalarMultiply(-3), -3); + + checkVector(new Cartesian1D(1.5).scalarMultiply(7), 10.5); + checkVector(new Cartesian1D(-1.5).scalarMultiply(7), -10.5); } @Test - public void testNormInf() { - Assert.assertEquals(0.0, Cartesian1D.ZERO.getNormInf(), 0); - Assert.assertEquals(3.0, new Cartesian1D(-3).getNormInf(), 0); + public void testNaN() { + // act/assert + Assert.assertTrue(new Cartesian1D(Double.NaN).isNaN()); + Assert.assertFalse(new Cartesian1D(1).isNaN()); + Assert.assertFalse(new Cartesian1D(Double.NEGATIVE_INFINITY).isNaN()); + } + + @Test + public void testInfinite() { + // act/assert + 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 testDistance1() { + // arrange 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); + + // act/assert + Assert.assertEquals(0.0, v1.distance1(v1), TEST_TOLERANCE); + + Assert.assertEquals(5.0, v1.distance1(v2), TEST_TOLERANCE); + Assert.assertEquals(v1.subtract(v2).getNorm1(), v1.distance1(v2), TEST_TOLERANCE); + + Assert.assertEquals(0.0, new Cartesian1D(-1).distance1(new Cartesian1D(-1)), TEST_TOLERANCE); } @Test public void testDistance() { + // arrange 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); + + // act/assert + Assert.assertEquals(0.0, v1.distance(v1), TEST_TOLERANCE); + + Assert.assertEquals(5.0, v1.distance(v2), TEST_TOLERANCE); + Assert.assertEquals(5.0, v1.distance((Point<Euclidean1D>) v2), TEST_TOLERANCE); + Assert.assertEquals(5.0, v1.distance((Vector<Euclidean1D>) v2), TEST_TOLERANCE); + Assert.assertEquals(v1.subtract(v2).getNorm(), v1.distance(v2), TEST_TOLERANCE); + + Assert.assertEquals(0.0, new Cartesian1D(-1).distance(new Cartesian1D(-1)), TEST_TOLERANCE); } @Test - public void testDistanceSq() { + public void testDistance_static() { + // arrange 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); - } + + // act/assert + Assert.assertEquals(0.0, Cartesian1D.distance(v1, v1), TEST_TOLERANCE); + + Assert.assertEquals(5.0, Cartesian1D.distance(v1, v2), TEST_TOLERANCE); + Assert.assertEquals(v1.subtract(v2).getNorm(), Cartesian1D.distance(v1, v2), TEST_TOLERANCE); + + Assert.assertEquals(0.0, Cartesian1D.distance(new Cartesian1D(-1), new Cartesian1D(-1)), TEST_TOLERANCE); + } @Test public void testDistanceInf() { + // arrange 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); + + // act/assert + Assert.assertEquals(0.0, new Cartesian1D(-1).distanceInf(new Cartesian1D(-1)), TEST_TOLERANCE); + Assert.assertEquals(5.0, v1.distanceInf(v2), TEST_TOLERANCE); + + Assert.assertEquals(v1.subtract(v2).getNormInf(), v1.distanceInf(v2), TEST_TOLERANCE); } @Test - public void testSubtract() { + public void testDistanceInf_static() { + // arrange Cartesian1D v1 = new Cartesian1D(1); - Cartesian1D v2 = new Cartesian1D(-3); - v1 = v1.subtract(v2); - checkVector(v1, 4); + Cartesian1D v2 = new Cartesian1D(-4); - checkVector(v2.subtract(v1), -7); - checkVector(v2.subtract(3, v1), -15); + // act/assert + Assert.assertEquals(0.0, Cartesian1D.distanceInf(new Cartesian1D(-1), new Cartesian1D(-1)), TEST_TOLERANCE); + Assert.assertEquals(5.0, Cartesian1D.distanceInf(v1, v2), TEST_TOLERANCE); + + Assert.assertEquals(v1.subtract(v2).getNormInf(), Cartesian1D.distanceInf(v1, v2), TEST_TOLERANCE); } @Test - public void testAdd() { + public void testDistanceSq() { + // arrange Cartesian1D v1 = new Cartesian1D(1); - Cartesian1D v2 = new Cartesian1D(-3); - v1 = v1.add(v2); - checkVector(v1, -2); + Cartesian1D v2 = new Cartesian1D(-4); - checkVector(v2.add(v1), -5); - checkVector(v2.add(3, v1), -9); + // act/assert + Assert.assertEquals(0.0, new Cartesian1D(-1).distanceSq(new Cartesian1D(-1)), TEST_TOLERANCE); + Assert.assertEquals(25.0, v1.distanceSq(v2), TEST_TOLERANCE); + + Assert.assertEquals(Cartesian1D.distance(v1, v2) * Cartesian1D.distance(v1, v2), + v1.distanceSq(v2), TEST_TOLERANCE); } @Test - public void testScalarProduct() { - Cartesian1D v = new Cartesian1D(1); - v = v.scalarMultiply(3); - checkVector(v, 3); + public void testDistanceSq_static() { + // arrange + Cartesian1D v1 = new Cartesian1D(1); + Cartesian1D v2 = new Cartesian1D(-4); + + // act/assert + Assert.assertEquals(0.0, Cartesian1D.distanceSq(new Cartesian1D(-1), new Cartesian1D(-1)), TEST_TOLERANCE); + Assert.assertEquals(25.0, Cartesian1D.distanceSq(v1, v2), TEST_TOLERANCE); - checkVector(v.scalarMultiply(0.5), 1.5); + Assert.assertEquals(Cartesian1D.distance(v1, v2) * Cartesian1D.distance(v1, v2), + Cartesian1D.distanceSq(v1, v2), TEST_TOLERANCE); } @Test - public void testNormalize() throws MathArithmeticException { - Assert.assertEquals(1.0, new Cartesian1D(5).normalize().getNorm(), 1.0e-12); - try { - Cartesian1D.ZERO.normalize(); - Assert.fail("an exception should have been thrown"); - } catch (MathArithmeticException ae) { - // expected behavior - } + public void testDotProduct() { + // act/assert + Assert.assertEquals(6.0, new Cartesian1D(2).dotProduct(new Cartesian1D(3)), TEST_TOLERANCE); + Assert.assertEquals(-6.0, new Cartesian1D(2).dotProduct(new Cartesian1D(-3)), TEST_TOLERANCE); } @Test - public void testNegate() { - checkVector(new Cartesian1D(0.1).negate(), -0.1); + public void testEquals() { + // arrange + Cartesian1D u1 = new Cartesian1D(1); + Cartesian1D u2 = new Cartesian1D(1); + + // act/assert + Assert.assertFalse(u1.equals(null)); + Assert.assertFalse(u1.equals(new Object())); + + Assert.assertTrue(u1.equals(u1)); + Assert.assertTrue(u1.equals(u2)); + + Assert.assertFalse(u1.equals(new Cartesian1D(-1))); + 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() { + // arrange + Cartesian1D u = new Cartesian1D(1); + Cartesian1D v = new Cartesian1D(1 + 10 * Precision.EPSILON); + + // act/assert + Assert.assertTrue(u.hashCode() != v.hashCode()); + Assert.assertEquals(new Cartesian1D(Double.NaN).hashCode(), new Cartesian1D(Double.NaN).hashCode()); + } + + @Test + public void testToString() { + // act/assert + Assert.assertEquals("{3}", new Cartesian1D(3).toString()); + Assert.assertEquals("{-3}", new Cartesian1D(-3).toString()); + } + + @Test + public void testToString_numberFormat() { + // arrange + NumberFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(Locale.US)); + + // act/assert + Assert.assertEquals("{-1.000}", new Cartesian1D(-1).toString(format)); + Assert.assertEquals("{3.142}", new Cartesian1D(FastMath.PI).toString(format)); } private void checkVector(Cartesian1D v, double x) { - Assert.assertEquals(x, v.getX(), 1.0e-12); + Assert.assertEquals(x, v.getX(), TEST_TOLERANCE); } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalTest.java index e4a88d3..89e8590 100644 --- a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalTest.java +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/IntervalTest.java @@ -26,56 +26,158 @@ import org.junit.Test; public class IntervalTest { + private static final double TEST_TOLERANCE = 1e-10; + + @Test + public void testBasicProperties() { + // arrange + Interval interval = new Interval(2.3, 5.7); + + // act/assert + Assert.assertEquals(3.4, interval.getSize(), TEST_TOLERANCE); + Assert.assertEquals(4.0, interval.getBarycenter(), TEST_TOLERANCE); + Assert.assertEquals(2.3, interval.getInf(), TEST_TOLERANCE); + Assert.assertEquals(5.7, interval.getSup(), TEST_TOLERANCE); + } + + @Test + public void testBasicProperties_negativeValues() { + // arrange + Interval interval = new Interval(-5.7, -2.3); + + // act/assert + Assert.assertEquals(3.4, interval.getSize(), TEST_TOLERANCE); + Assert.assertEquals(-4.0, interval.getBarycenter(), TEST_TOLERANCE); + Assert.assertEquals(-5.7, interval.getInf(), TEST_TOLERANCE); + Assert.assertEquals(-2.3, interval.getSup(), TEST_TOLERANCE); + } + + // MATH-1256 + @Test(expected = NumberIsTooSmallException.class) + public void testStrictOrdering() { + new Interval(0, -1); + } + @Test - public void testInterval() { + public void testCheckPoint() { + // arrange Interval interval = new Interval(2.3, 5.7); - Assert.assertEquals(3.4, interval.getSize(), 1.0e-10); - Assert.assertEquals(4.0, interval.getBarycenter(), 1.0e-10); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.3, 1.0e-10)); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(5.7, 1.0e-10)); - Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(1.2, 1.0e-10)); - Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(8.7, 1.0e-10)); - Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(3.0, 1.0e-10)); - Assert.assertEquals(2.3, interval.getInf(), 1.0e-10); - Assert.assertEquals(5.7, interval.getSup(), 1.0e-10); + + // act/assert + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(1.2, TEST_TOLERANCE)); + + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(2.2, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.3, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(2.4, TEST_TOLERANCE)); + + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(3.0, TEST_TOLERANCE)); + + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(5.6, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(5.7, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(5.8, TEST_TOLERANCE)); + + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(8.7, TEST_TOLERANCE)); + + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(Double.NEGATIVE_INFINITY, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(Double.POSITIVE_INFINITY, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(Double.NaN, TEST_TOLERANCE)); } @Test - public void testTolerance() { + public void testCheckPoint_tolerance() { + // arrange Interval interval = new Interval(2.3, 5.7); - Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(1.2, 1.0)); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(1.2, 1.2)); - Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(8.7, 2.9)); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(8.7, 3.1)); - Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(3.0, 0.6)); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(3.0, 0.8)); + + // act/assert + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(2.29, 1e-3)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.29, 1e-2)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.29, 1e-1)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.29, 1)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(2.29, 2)); + + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(4.0, 1e-3)); + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(4.0, 1e-2)); + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(4.0, 1e-1)); + Assert.assertEquals(Region.Location.INSIDE, interval.checkPoint(4.0, 1)); + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(4.0, 2)); } @Test - public void testInfinite() { + public void testInfinite_inf() { + // act + Interval interval = new Interval(Double.NEGATIVE_INFINITY, 9); + + // assert + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(9.0, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(9.4, TEST_TOLERANCE)); + for (double e = 1.0; e <= 6.0; e += 1.0) { + Assert.assertEquals(Region.Location.INSIDE, + interval.checkPoint(-1 * FastMath.pow(10.0, e), TEST_TOLERANCE)); + } + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getSize(), TEST_TOLERANCE); + Assert.assertEquals(Double.NEGATIVE_INFINITY, interval.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, interval.getSup(), TEST_TOLERANCE); + } + + @Test + public void testInfinite_sup() { + // act Interval interval = new Interval(9.0, Double.POSITIVE_INFINITY); - Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(9.0, 1.0e-10)); - Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(8.4, 1.0e-10)); + + // assert + Assert.assertEquals(Region.Location.BOUNDARY, interval.checkPoint(9.0, TEST_TOLERANCE)); + Assert.assertEquals(Region.Location.OUTSIDE, interval.checkPoint(8.4, TEST_TOLERANCE)); for (double e = 1.0; e <= 6.0; e += 1.0) { Assert.assertEquals(Region.Location.INSIDE, - interval.checkPoint(FastMath.pow(10.0, e), 1.0e-10)); + interval.checkPoint(FastMath.pow(10.0, e), TEST_TOLERANCE)); } - Assert.assertTrue(Double.isInfinite(interval.getSize())); - Assert.assertEquals(9.0, interval.getInf(), 1.0e-10); - Assert.assertTrue(Double.isInfinite(interval.getSup())); + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getSize(), TEST_TOLERANCE); + Assert.assertEquals(9.0, interval.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getSup(), TEST_TOLERANCE); + } + + @Test + public void testInfinite_infAndSup() { + // act + Interval interval = new Interval(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY); + // assert + for (double e = 1.0; e <= 6.0; e += 1.0) { + Assert.assertEquals(Region.Location.INSIDE, + interval.checkPoint(FastMath.pow(10.0, e), TEST_TOLERANCE)); + } + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getSize(), TEST_TOLERANCE); + Assert.assertEquals(Double.NEGATIVE_INFINITY, interval.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getSup(), TEST_TOLERANCE); } @Test public void testSinglePoint() { + // act Interval interval = new Interval(1.0, 1.0); + + // assert Assert.assertEquals(0.0, interval.getSize(), Precision.SAFE_MIN); Assert.assertEquals(1.0, interval.getBarycenter(), Precision.EPSILON); } - // MATH-1256 - @Test(expected=NumberIsTooSmallException.class) - public void testStrictOrdering() { - new Interval(0, -1); + @Test + public void testSingleInfinitePoint_positive() { + // act + Interval interval = new Interval(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY); + + // assert + Assert.assertEquals(Double.NaN, interval.getSize(), Precision.SAFE_MIN); // inf - inf = NaN according to floating point spec + Assert.assertEquals(Double.POSITIVE_INFINITY, interval.getBarycenter(), Precision.EPSILON); + } + + @Test + public void testSingleInfinitePoint_negative() { + // act + Interval interval = new Interval(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY); + + // assert + Assert.assertEquals(Double.NaN, interval.getSize(), Precision.SAFE_MIN); // inf - inf = NaN according to floating point spec + Assert.assertEquals(Double.NEGATIVE_INFINITY, interval.getBarycenter(), Precision.EPSILON); } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/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 17b1ee3..20c8790 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 @@ -16,10 +16,15 @@ */ package org.apache.commons.math4.geometry.euclidean.oned; +import java.util.ArrayList; import java.util.List; +import org.apache.commons.math4.geometry.GeometryTestUtils; +import org.apache.commons.math4.geometry.partitioning.BSPTree; +import org.apache.commons.math4.geometry.partitioning.BoundaryProjection; import org.apache.commons.math4.geometry.partitioning.Region; import org.apache.commons.math4.geometry.partitioning.RegionFactory; +import org.apache.commons.math4.geometry.partitioning.SubHyperplane; import org.apache.commons.math4.util.FastMath; import org.apache.commons.numbers.core.Precision; import org.junit.Assert; @@ -27,6 +32,463 @@ import org.junit.Test; public class IntervalsSetTest { + private static final double TEST_TOLERANCE = 1e-15; + + @Test + public void testInterval_wholeNumberLine() { + // act + IntervalsSet set = new IntervalsSet(TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + BSPTree<Euclidean1D> tree = set.getTree(true); + Assert.assertEquals(Boolean.TRUE, tree.getAttribute()); + Assert.assertNull(tree.getCut()); + Assert.assertNull(tree.getMinus()); + Assert.assertNull(tree.getPlus()); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testInterval_doubleOpenInterval() { + // act + IntervalsSet set = new IntervalsSet(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + BSPTree<Euclidean1D> tree = set.getTree(true); + Assert.assertEquals(Boolean.TRUE, tree.getAttribute()); + Assert.assertNull(tree.getCut()); + Assert.assertNull(tree.getMinus()); + Assert.assertNull(tree.getPlus()); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testInterval_openInterval_positive() { + // act + IntervalsSet set = new IntervalsSet(9.0, Double.POSITIVE_INFINITY, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(9.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(9.0, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.INSIDE, set, 10.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testInterval_openInterval_negative() { + // act + IntervalsSet set = new IntervalsSet(Double.NEGATIVE_INFINITY, 9.0, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, 9.0, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 10.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testInterval_singleClosedInterval() { + // act + IntervalsSet set = new IntervalsSet(-1.0, 9.0, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(-1.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(10.0, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(new Cartesian1D(4.0), (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(-1.0, 9.0, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, -2.0); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 10.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testInterval_singlePoint() { + // act + IntervalsSet set = new IntervalsSet(1.0, 1.0, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(1.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(1.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(new Cartesian1D(1.0), (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(1.0, 1.0, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 1.0); + assertLocation(Region.Location.OUTSIDE, set, 2.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_wholeNumberLine() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + BSPTree<Euclidean1D> tree = set.getTree(true); + Assert.assertEquals(Boolean.TRUE, tree.getAttribute()); + Assert.assertNull(tree.getCut()); + Assert.assertNull(tree.getMinus()); + Assert.assertNull(tree.getPlus()); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_openInterval_positive() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(9.0, false)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(9.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(9.0, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.INSIDE, set, 10.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_openInterval_negative() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(9.0, true)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, 9.0, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 10.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_singleClosedInterval() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(-1.0, false)); + boundaries.add(subOrientedPoint(9.0, true)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(-1.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(10.0, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(new Cartesian1D(4.0), (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(-1.0, 9.0, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, -2.0); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 10.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_multipleClosedIntervals() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(-1.0, false)); + boundaries.add(subOrientedPoint(2.0, true)); + boundaries.add(subOrientedPoint(5.0, false)); + boundaries.add(subOrientedPoint(9.0, true)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(-1.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(9.0, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(7.0, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(new Cartesian1D(29.5 / 7.0), (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(2, intervals.size()); + assertInterval(-1.0, 2.0, intervals.get(0), TEST_TOLERANCE); + assertInterval(5.0, 9.0, intervals.get(1), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.OUTSIDE, set, -2.0); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.OUTSIDE, set, 3.0); + assertLocation(Region.Location.INSIDE, set, 6.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 10.0); + assertLocation(Region.Location.OUTSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_mixedOpenAndClosedIntervals() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(-2.0, true)); + boundaries.add(subOrientedPoint(-1.0, false)); + boundaries.add(subOrientedPoint(2.0, true)); + boundaries.add(subOrientedPoint(5.0, false)); + boundaries.add(subOrientedPoint(9.0, true)); + boundaries.add(subOrientedPoint(10.0, false)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // assert + Assert.assertEquals(TEST_TOLERANCE, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(new Cartesian1D(Double.NaN), (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(4, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, -2.0, intervals.get(0), TEST_TOLERANCE); + assertInterval(-1.0, 2.0, intervals.get(1), TEST_TOLERANCE); + assertInterval(5.0, 9.0, intervals.get(2), TEST_TOLERANCE); + assertInterval(10.0, Double.POSITIVE_INFINITY, intervals.get(3), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, Double.NEGATIVE_INFINITY); + assertLocation(Region.Location.INSIDE, set, -3); + assertLocation(Region.Location.OUTSIDE, set, -1.5); + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.OUTSIDE, set, 3.0); + assertLocation(Region.Location.INSIDE, set, 6.0); + assertLocation(Region.Location.BOUNDARY, set, 9.0 - 1e-16); + assertLocation(Region.Location.BOUNDARY, set, 9.0 + 1e-16); + assertLocation(Region.Location.OUTSIDE, set, 9.5); + assertLocation(Region.Location.INSIDE, set, 11.0); + assertLocation(Region.Location.INSIDE, set, Double.POSITIVE_INFINITY); + } + + @Test + public void testFromBoundaries_intervalEqualToTolerance_onlyFirstBoundaryUsed() { + // arrange + double tolerance = 1e-3; + double first = 1.0; + double second = 1.0 + tolerance; + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(first, true, tolerance)); + boundaries.add(subOrientedPoint(second, false, tolerance)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, tolerance); + + // assert + Assert.assertEquals(tolerance, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(first, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(Double.NEGATIVE_INFINITY, first, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.INSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 1.0); + assertLocation(Region.Location.OUTSIDE, set, 2.0); + } + + @Test + public void testFromBoundaries_intervalSmallerThanTolerance_onlyFirstBoundaryUsed() { + // arrange + double tolerance = 1e-3; + double first = 1.0; + double second = 1.0 - 1e-4; + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(first, false, tolerance)); + boundaries.add(subOrientedPoint(second, true, tolerance)); + + // act + IntervalsSet set = new IntervalsSet(boundaries, tolerance); + + // assert + Assert.assertEquals(tolerance, set.getTolerance(), Precision.SAFE_MIN); + Assert.assertEquals(first, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), TEST_TOLERANCE); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(0.0, set.getBoundarySize(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(Cartesian1D.NaN, (Cartesian1D) set.getBarycenter(), TEST_TOLERANCE); + + List<Interval> intervals = set.asList(); + Assert.assertEquals(1, intervals.size()); + assertInterval(first, Double.POSITIVE_INFINITY, intervals.get(0), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, 0.0); + assertLocation(Region.Location.BOUNDARY, set, 1.0); + assertLocation(Region.Location.INSIDE, set, 2.0); + } + + @Test + public void testProjectToBoundary() { + // arrange + List<SubHyperplane<Euclidean1D>> boundaries = new ArrayList<>(); + boundaries.add(subOrientedPoint(-2.0, true)); + boundaries.add(subOrientedPoint(-1.0, false)); + boundaries.add(subOrientedPoint(2.0, true)); + boundaries.add(subOrientedPoint(5.0, false)); + boundaries.add(subOrientedPoint(9.0, true)); + boundaries.add(subOrientedPoint(10.0, false)); + + IntervalsSet set = new IntervalsSet(boundaries, TEST_TOLERANCE); + + // act/assert + assertProjection(new Cartesian1D(-2), -1, set, new Cartesian1D(-3)); + assertProjection(new Cartesian1D(-2), 0, set, new Cartesian1D(-2)); + assertProjection(new Cartesian1D(-2), 0.1, set, new Cartesian1D(-1.9)); + + assertProjection(new Cartesian1D(-1), 0.5, set, new Cartesian1D(-1.5)); + assertProjection(new Cartesian1D(-1), 0.1, set, new Cartesian1D(-1.1)); + assertProjection(new Cartesian1D(-1), 0, set, new Cartesian1D(-1)); + assertProjection(new Cartesian1D(-1), -1, set, new Cartesian1D(0)); + + assertProjection(new Cartesian1D(2), -1, set, new Cartesian1D(1)); + assertProjection(new Cartesian1D(2), 0, set, new Cartesian1D(2)); + assertProjection(new Cartesian1D(2), 1, set, new Cartesian1D(3)); + + assertProjection(new Cartesian1D(5), 1, set, new Cartesian1D(4)); + assertProjection(new Cartesian1D(5), 0, set, new Cartesian1D(5)); + + assertProjection(new Cartesian1D(5), -1, set, new Cartesian1D(6)); + assertProjection(new Cartesian1D(5), -2, set, new Cartesian1D(7)); + + assertProjection(new Cartesian1D(9), -1, set, new Cartesian1D(8)); + assertProjection(new Cartesian1D(9), 0, set, new Cartesian1D(9)); + assertProjection(new Cartesian1D(9), 0.1, set, new Cartesian1D(9.1)); + + assertProjection(new Cartesian1D(10), 0, set, new Cartesian1D(10)); + assertProjection(new Cartesian1D(10), -1, set, new Cartesian1D(11)); + } + @Test public void testInterval() { IntervalsSet set = new IntervalsSet(2.3, 5.7, 1.0e-10); @@ -61,44 +523,65 @@ public class IntervalsSetTest { } @Test - public void testMultiple() { + public void testBooleanOperations() { + // arrange RegionFactory<Euclidean1D> factory = new RegionFactory<>(); + + // act IntervalsSet set = (IntervalsSet) - factory.intersection(factory.union(factory.difference(new IntervalsSet(1.0, 6.0, 1.0e-10), - new IntervalsSet(3.0, 5.0, 1.0e-10)), - 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, ((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); + factory.intersection(factory.union(factory.difference(new IntervalsSet(1.0, 6.0, TEST_TOLERANCE), + new IntervalsSet(3.0, 5.0, TEST_TOLERANCE)), + new IntervalsSet(9.0, Double.POSITIVE_INFINITY, TEST_TOLERANCE)), + new IntervalsSet(Double.NEGATIVE_INFINITY, 11.0, TEST_TOLERANCE)); + + // arrange + Assert.assertEquals(1.0, set.getInf(), TEST_TOLERANCE); + Assert.assertEquals(11.0, set.getSup(), TEST_TOLERANCE); + + Assert.assertEquals(5.0, set.getSize(), TEST_TOLERANCE); + Assert.assertEquals(5.9, ((Cartesian1D) set.getBarycenter()).getX(), TEST_TOLERANCE); + + assertLocation(Region.Location.OUTSIDE, set, 0.0); + assertLocation(Region.Location.OUTSIDE, set, 4.0); + assertLocation(Region.Location.OUTSIDE, set, 8.0); + assertLocation(Region.Location.OUTSIDE, set, 12.0); + assertLocation(Region.Location.INSIDE, set, 1.2); + assertLocation(Region.Location.INSIDE, set, 5.9); + assertLocation(Region.Location.INSIDE, set, 9.01); + assertLocation(Region.Location.BOUNDARY, set, 5.0); + assertLocation(Region.Location.BOUNDARY, set, 11.0); List<Interval> list = set.asList(); Assert.assertEquals(3, list.size()); - Assert.assertEquals( 1.0, list.get(0).getInf(), 1.0e-10); - Assert.assertEquals( 3.0, list.get(0).getSup(), 1.0e-10); - Assert.assertEquals( 5.0, list.get(1).getInf(), 1.0e-10); - Assert.assertEquals( 6.0, list.get(1).getSup(), 1.0e-10); - Assert.assertEquals( 9.0, list.get(2).getInf(), 1.0e-10); - Assert.assertEquals(11.0, list.get(2).getSup(), 1.0e-10); + assertInterval(1.0, 3.0, list.get(0), TEST_TOLERANCE); + assertInterval(5.0, 6.0, list.get(1), TEST_TOLERANCE); + assertInterval(9.0, 11.0, list.get(2), TEST_TOLERANCE); + } + private void assertLocation(Region.Location location, IntervalsSet set, double pt) { + Assert.assertEquals(location, set.checkPoint(new Cartesian1D(pt))); } - @Test - 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(0.0, set.getBoundarySize(), Precision.SAFE_MIN); - Assert.assertEquals(1.0, ((Cartesian1D) set.getBarycenter()).getX(), Precision.EPSILON); + private void assertInterval(double expectedInf, double expectedSup, Interval actual, double tolerance) { + Assert.assertEquals(expectedInf, actual.getInf(), tolerance); + Assert.assertEquals(expectedSup, actual.getSup(), tolerance); + } + + private void assertProjection(Cartesian1D expectedProjection, double expectedOffset, + IntervalsSet set, Cartesian1D toProject) { + BoundaryProjection<Euclidean1D> proj = set.projectToBoundary(toProject); + + GeometryTestUtils.assertVectorEquals(toProject, (Cartesian1D) proj.getOriginal(), TEST_TOLERANCE); + GeometryTestUtils.assertVectorEquals(expectedProjection, (Cartesian1D) proj.getProjected(), TEST_TOLERANCE); + Assert.assertEquals(expectedOffset, proj.getOffset(), TEST_TOLERANCE); } + private SubOrientedPoint subOrientedPoint(double location, boolean direct) { + return subOrientedPoint(location, direct, TEST_TOLERANCE); + } + + private SubOrientedPoint subOrientedPoint(double location, boolean direct, double tolerance) { + // the remaining region isn't necessary for creating 1D boundaries so we can set it to null here + return new SubOrientedPoint(new OrientedPoint(new Cartesian1D(location), direct, tolerance), null); + } } http://git-wip-us.apache.org/repos/asf/commons-math/blob/24d3dd8b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/OrientedPointTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/OrientedPointTest.java b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/OrientedPointTest.java new file mode 100644 index 0000000..4a07113 --- /dev/null +++ b/src/test/java/org/apache/commons/math4/geometry/euclidean/oned/OrientedPointTest.java @@ -0,0 +1,188 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.math4.geometry.euclidean.oned; + +import org.junit.Test; +import org.apache.commons.math3.util.Precision; +import org.apache.commons.math4.geometry.Point; +import org.apache.commons.math4.geometry.Vector; +import org.junit.Assert; + +public class OrientedPointTest { + + @Test + public void testConstructor() { + // act + OrientedPoint pt = new OrientedPoint(new Cartesian1D(2.0), true, 1e-5); + + // assert + Assert.assertEquals(2.0, pt.getLocation().getX(), Precision.EPSILON); + Assert.assertEquals(true, pt.isDirect()); + Assert.assertEquals(1e-5, pt.getTolerance(), Precision.EPSILON); + } + + @Test + public void testCopySelf() { + // arrange + OrientedPoint orig = new OrientedPoint(new Cartesian1D(2.0), true, 1e-5); + + // act + OrientedPoint copy = orig.copySelf(); + + // assert + Assert.assertSame(orig, copy); + Assert.assertEquals(2.0, copy.getLocation().getX(), Precision.EPSILON); + Assert.assertEquals(true, copy.isDirect()); + Assert.assertEquals(1e-5, copy.getTolerance(), Precision.EPSILON); + } + + @Test + public void testGetOffset_direct_point() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(-1.0), true, 1e-5); + + // act/assert + Assert.assertEquals(-99, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-100)), Precision.EPSILON); + Assert.assertEquals(-1, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-2)), Precision.EPSILON); + Assert.assertEquals(-0.01, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-1.01)), Precision.EPSILON); + Assert.assertEquals(0.0, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-1.0)), Precision.EPSILON); + Assert.assertEquals(0.01, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-0.99)), Precision.EPSILON); + Assert.assertEquals(1, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(0)), Precision.EPSILON); + Assert.assertEquals(101, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(100)), Precision.EPSILON); + } + + @Test + public void testGetOffset_notDirect_point() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(-1.0), false, 1e-5); + + // act/assert + Assert.assertEquals(99, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-100)), Precision.EPSILON); + Assert.assertEquals(1, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-2)), Precision.EPSILON); + Assert.assertEquals(0.01, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-1.01)), Precision.EPSILON); + Assert.assertEquals(0.0, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-1.0)), Precision.EPSILON); + Assert.assertEquals(-0.01, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(-0.99)), Precision.EPSILON); + Assert.assertEquals(-1, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(0)), Precision.EPSILON); + Assert.assertEquals(-101, pt.getOffset((Point<Euclidean1D>) new Cartesian1D(100)), Precision.EPSILON); + } + + @Test + public void testGetOffset_direct_vector() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(-1.0), true, 1e-5); + + // act/assert + Assert.assertEquals(-99, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-100)), Precision.EPSILON); + Assert.assertEquals(-1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-2)), Precision.EPSILON); + Assert.assertEquals(-0.01, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-1.01)), Precision.EPSILON); + Assert.assertEquals(-0.0, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-1.0)), Precision.EPSILON); + Assert.assertEquals(0.01, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-0.99)), Precision.EPSILON); + Assert.assertEquals(1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(0)), Precision.EPSILON); + Assert.assertEquals(101, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(100)), Precision.EPSILON); + } + + @Test + public void testGetOffset_notDirect_vector() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(-1.0), false, 1e-5); + + // act/assert + Assert.assertEquals(99, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-100)), Precision.EPSILON); + Assert.assertEquals(1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-2)), Precision.EPSILON); + Assert.assertEquals(0.01, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-1.01)), Precision.EPSILON); + Assert.assertEquals(0.0, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-1.0)), Precision.EPSILON); + Assert.assertEquals(-0.01, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(-0.99)), Precision.EPSILON); + Assert.assertEquals(-1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(0)), Precision.EPSILON); + Assert.assertEquals(-101, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(100)), Precision.EPSILON); + } + + @Test + public void testWholeHyperplane() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(1.0), false, 1e-5); + + // act + SubOrientedPoint subPt = pt.wholeHyperplane(); + + // assert + Assert.assertSame(pt, subPt.getHyperplane()); + Assert.assertNull(subPt.getRemainingRegion()); + } + + @Test + public void testWholeSpace() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(1.0), false, 1e-5); + + // act + IntervalsSet set = pt.wholeSpace(); + + // assert + Assert.assertEquals(Double.NEGATIVE_INFINITY, set.getInf(), Precision.EPSILON); + Assert.assertEquals(Double.POSITIVE_INFINITY, set.getSup(), Precision.EPSILON); + } + + @Test + public void testSameOrientationAs() { + // arrange + OrientedPoint notDirect1 = new OrientedPoint(new Cartesian1D(1.0), false, 1e-5); + OrientedPoint notDirect2 = new OrientedPoint(new Cartesian1D(1.0), false, 1e-5); + OrientedPoint direct1 = new OrientedPoint(new Cartesian1D(1.0), true, 1e-5); + OrientedPoint direct2 = new OrientedPoint(new Cartesian1D(1.0), true, 1e-5); + + // act/assert + Assert.assertEquals(true, notDirect1.sameOrientationAs(notDirect1)); + Assert.assertEquals(true, notDirect1.sameOrientationAs(notDirect2)); + Assert.assertEquals(true, notDirect2.sameOrientationAs(notDirect1)); + + Assert.assertEquals(true, direct1.sameOrientationAs(direct1)); + Assert.assertEquals(true, direct1.sameOrientationAs(direct2)); + Assert.assertEquals(true, direct2.sameOrientationAs(direct1)); + + Assert.assertEquals(false, notDirect1.sameOrientationAs(direct1)); + Assert.assertEquals(false, direct1.sameOrientationAs(notDirect1)); + } + + @Test + public void testProject() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(1.0), true, 1e-5); + + // act/assert + Assert.assertEquals(1.0, ((Cartesian1D) pt.project(new Cartesian1D(-1.0))).getX(), Precision.EPSILON); + Assert.assertEquals(1.0, ((Cartesian1D) pt.project(new Cartesian1D(0.0))).getX(), Precision.EPSILON); + Assert.assertEquals(1.0, ((Cartesian1D) pt.project(new Cartesian1D(1.0))).getX(), Precision.EPSILON); + Assert.assertEquals(1.0, ((Cartesian1D) pt.project(new Cartesian1D(100.0))).getX(), Precision.EPSILON); + } + + @Test + public void testRevertSelf() { + // arrange + OrientedPoint pt = new OrientedPoint(new Cartesian1D(2.0), true, 1e-5); + + // act + pt.revertSelf(); + + // assert + Assert.assertEquals(2.0, pt.getLocation().getX(), Precision.EPSILON); + Assert.assertEquals(false, pt.isDirect()); + Assert.assertEquals(1e-5, pt.getTolerance(), Precision.EPSILON); + + Assert.assertEquals(1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(1.0)), Precision.EPSILON); + Assert.assertEquals(-1, pt.getOffset((Vector<Euclidean1D>) new Cartesian1D(3.0)), Precision.EPSILON); + } +}
