open-space-toolkit-mathematics 4.4.0__py311-none-manylinux2014_x86_64.whl

ostk/mathematics/test/curve_fitting/interpolator/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/test/curve_fitting/interpolator/test_barycentric_rational.py

@@ -0,0 +1,34 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.mathematics.curve_fitting import Interpolator
+from ostk.mathematics.curve_fitting.interpolator import BarycentricRational
+
+
+@pytest.fixture
+def interpolator() -> BarycentricRational:
+    return BarycentricRational(
+        x=[0.0, 1.0, 2.0, 4.0, 5.0, 6.0], y=[0.0, 3.0, 6.0, 9.0, 17.0, 5.0]
+    )
+
+
+class TestBarycentricRational:
+    def test_constructor_success(self, interpolator: BarycentricRational):
+        assert interpolator is not None
+        assert isinstance(interpolator, Interpolator)
+        assert isinstance(interpolator, BarycentricRational)
+
+    def test_evaluate(self, interpolator: BarycentricRational):
+
+        assert interpolator.evaluate(0.0) == 0.0
+        assert interpolator.evaluate(1.0) == 3.0
+        assert interpolator.evaluate(2.0) == 6.0
+        assert interpolator.evaluate(4.0) == 9.0
+        assert interpolator.evaluate(5.0) == 17.0
+        assert interpolator.evaluate(6.0) == 5.0
+
+        assert (
+            interpolator.evaluate(x=[0.0, 1.0, 2.0, 4.0, 5.0, 6.0])
+            == [0.0, 3.0, 6.0, 9.0, 17.0, 5.0]
+        ).all()

ostk/mathematics/test/curve_fitting/interpolator/test_cubic_spline.py

@@ -0,0 +1,45 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.curve_fitting import Interpolator
+from ostk.mathematics.curve_fitting.interpolator import CubicSpline
+
+
+@pytest.fixture
+def interpolator() -> CubicSpline:
+    return CubicSpline(
+        x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], y=[0.0, 3.0, 6.0, 9.0, 17.0, 5.0]
+    )
+
+
+class TestCubicSpline:
+    def test_constructor_success(self, interpolator: CubicSpline):
+        assert interpolator is not None
+        assert isinstance(interpolator, Interpolator)
+        assert isinstance(interpolator, CubicSpline)
+
+    def test_default_constructor_2(self):
+        CubicSpline(y=[0.0, 3.0, 6.0, 9.0, 17.0, 5.0], x_0=0.0, h=1.0)
+
+    def test_evaluate(self):
+        y: list[float] = [
+            -4.632122947015880607e06,
+            -4.638362755234977230e06,
+            -4.644761115514834411e06,
+            -4.650595795951002277e06,
+            -4.655866062354639173e06,
+            -4.660571249500595033e06,
+            -4.664710761221675202e06,
+            -4.668284070493859239e06,
+            -4.671290719512360170e06,
+            -4.673730319758670405e06,
+        ]
+        interpolator = CubicSpline(y, 0.0, 10.0)
+
+        for i in range(10):
+            assert pytest.approx(interpolator.evaluate(i * 10.0)) == y[i]
+
+        assert pytest.approx(interpolator.evaluate(np.linspace(0.0, 90.0, 10))) == y

ostk/mathematics/test/curve_fitting/interpolator/test_interpolator.py

@@ -0,0 +1,71 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.mathematics.curve_fitting import Interpolator
+
+
+@pytest.fixture
+def interpolation_type() -> Interpolator.Type:
+    return Interpolator.Type.Linear
+
+
+@pytest.fixture
+def interpolator(interpolation_type: Interpolator.Type) -> Interpolator:
+    class MyInterpolator(Interpolator):
+        def evaluate(self, x: list[float]) -> list[float]:
+            return x
+
+        def evaluate(self, x: float) -> float:
+            return x
+
+    return MyInterpolator(interpolation_type=interpolation_type)
+
+
+class TestInterpolator:
+    def test_subclass(self, interpolator: Interpolator):
+        assert interpolator is not None
+        assert isinstance(interpolator, Interpolator)
+
+    def test_get_interpolation_type(
+        self,
+        interpolator: Interpolator,
+        interpolation_type: Interpolator.Type,
+    ):
+        assert interpolator.get_interpolation_type() == interpolation_type
+
+    @pytest.mark.parametrize(
+        "parametrized_interpolation_type, x, y",
+        [
+            (
+                Interpolator.Type.BarycentricRational,
+                [0.0, 1.0, 2.0, 4.0, 5.0, 6.0],
+                [0.0, 3.0, 6.0, 9.0, 17.0, 5.0],
+            ),
+            (
+                Interpolator.Type.CubicSpline,
+                [0.0, 1.0, 2.0, 3.0, 4.0, 5.0],
+                [0.0, 3.0, 6.0, 9.0, 17.0, 5.0],
+            ),
+            (
+                Interpolator.Type.Linear,
+                [0.0, 1.0, 2.0, 4.0, 5.0, 6.0],
+                [0.0, 3.0, 6.0, 9.0, 17.0, 5.0],
+            ),
+        ],
+    )
+    def test_generate_interpolators(
+        self,
+        parametrized_interpolation_type: Interpolator.Type,
+        x: list[float],
+        y: list[float],
+    ):
+        interpolator: Interpolator = Interpolator.generate_interpolator(
+            interpolation_type=parametrized_interpolation_type,
+            x=x,
+            y=y,
+        )
+
+        assert interpolator is not None
+        assert isinstance(interpolator, Interpolator)
+        assert interpolator.get_interpolation_type() == parametrized_interpolation_type

ostk/mathematics/test/curve_fitting/interpolator/test_linear.py

@@ -0,0 +1,35 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.mathematics.curve_fitting import Interpolator
+from ostk.mathematics.curve_fitting.interpolator import Linear
+
+
+@pytest.fixture
+def interpolator() -> Linear:
+    return Linear(x=[0.0, 1.0, 2.0, 4.0, 5.0, 6.0], y=[0.0, 3.0, 6.0, 9.0, 17.0, 5.0])
+
+
+class TestLinear:
+    def test_constructor_success(self, interpolator: Linear):
+        assert interpolator is not None
+        assert isinstance(interpolator, Interpolator)
+        assert isinstance(interpolator, Linear)
+
+    def test_evaluate(self):
+        interpolator = Linear(
+            x=[0.0, 1.0, 2.0, 4.0, 5.0, 6.0], y=[0.0, 3.0, 6.0, 9.0, 17.0, 5.0]
+        )
+
+        assert interpolator.evaluate(0.0) == 0.0
+        assert interpolator.evaluate(1.0) == 3.0
+        assert interpolator.evaluate(2.0) == 6.0
+        assert interpolator.evaluate(4.0) == 9.0
+        assert interpolator.evaluate(5.0) == 17.0
+        assert interpolator.evaluate(6.0) == 5.0
+
+        assert (
+            interpolator.evaluate(x=[0.0, 1.0, 2.0, 4.0, 5.0, 6.0])
+            == [0.0, 3.0, 6.0, 9.0, 17.0, 5.0]
+        ).all()

ostk/mathematics/test/geometry/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/test/geometry/d2/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/test/geometry/d2/conftest.py

@@ -0,0 +1,82 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+
+Point = mathematics.geometry.d2.object.Point
+PointSet = mathematics.geometry.d2.object.PointSet
+Line = mathematics.geometry.d2.object.Line
+Segment = mathematics.geometry.d2.object.Segment
+Polygon = mathematics.geometry.d2.object.Polygon
+Composite = mathematics.geometry.d2.object.Composite
+
+
+@pytest.fixture
+def point() -> Point:
+    return Point(-2.0, 5.0)
+
+
+@pytest.fixture
+def point_set() -> PointSet:
+    return PointSet([Point(1.0, 2.0), Point(2.0, 3.0)])
+
+
+@pytest.fixture
+def line() -> Line:
+    return Line(Point(1.0, 2.0), np.array((1.0, 1.0)))
+
+
+@pytest.fixture
+def segment() -> Segment:
+    return Segment(Point(0.0, 0.0), Point(0.0, 2.0))
+
+
+@pytest.fixture
+def polygon() -> Polygon:
+    point_1: Point = Point(-1.0, 1.0)
+    point_2: Point = Point(1.0, 1.0)
+    point_3: Point = Point(1.0, -1.0)
+    point_4: Point = Point(-1.0, -1.0)
+
+    return Polygon([point_1, point_2, point_3, point_4])
+
+
+def square(center: Point) -> Polygon:
+    point_1: Point = center + [0.5, 0.5]
+    point_2: Point = center + [0.5, -0.5]
+    point_3: Point = center + [-0.5, -0.5]
+    point_4: Point = center + [-0.5, 0.5]
+
+    return Polygon([point_1, point_2, point_3, point_4])
+
+
+@pytest.fixture
+def square_1() -> Polygon:
+    return square(Point(0.0, 0.0))
+
+
+@pytest.fixture
+def square_2() -> Polygon:
+    return square(Point(0.0, 10.0))
+
+
+@pytest.fixture
+def square_3() -> Polygon:
+    return square(Point(0.5, 0.0))
+
+
+@pytest.fixture
+def square_4() -> Polygon:
+    return square(Point(1.0, 0.0))
+
+
+@pytest.fixture
+def composite(polygon: Polygon, point: Point) -> Composite:
+    composite = Composite(polygon)
+    composite += Composite(point)
+
+    return composite

ostk/mathematics/test/geometry/d2/object/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/test/geometry/d2/object/test_composite.py

@@ -0,0 +1,96 @@
+# Apache License 2.0
+
+import pytest
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+Polygon = mathematics.geometry.d2.object.Polygon
+Composite = mathematics.geometry.d2.object.Composite
+
+
+class TestComposite:
+    def test_constructor_success(self, polygon: Polygon):
+        composite: Composite = Composite(polygon)
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+
+    def test_empty_success(self):
+        composite: Composite = Composite.empty()
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert isinstance(composite, Object)
+        assert composite.is_defined()
+        assert composite.is_empty()
+
+    def test_is_defined_success(self):
+        composite: Composite = Composite.undefined()
+
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert isinstance(composite, Object)
+        assert composite.is_defined() is False
+
+    def test_comparators_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        other_composite: Composite = Composite(polygon)
+
+        assert composite == composite
+        assert composite != other_composite
+        assert other_composite != composite
+
+    def test_addition_operator_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        assert composite is not None
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+        assert composite.get_object_count() == 2
+
+        with pytest.raises(RuntimeError):
+            other_composite = Composite.undefined() + composite
+
+        with pytest.raises(RuntimeError):
+            other_composite = composite + Composite.undefined()
+
+        composite += composite
+
+        assert isinstance(composite, Composite)
+        assert composite.is_defined()
+        assert composite.get_object_count() == 4
+
+        with pytest.raises(RuntimeError):
+            composite += Composite.undefined()
+
+    def test_is_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+    ):
+        assert composite.is_point() is False
+        assert composite.is_polygon() is False
+
+        assert Composite(polygon).is_polygon()
+
+    def test_access_object_at_success(
+        self,
+        composite: Composite,
+        polygon: Polygon,
+        point: Point,
+    ):
+        assert composite.get_object_count() == 2
+        assert composite.access_object_at(0) == polygon
+        assert composite.access_object_at(1) == point
+
+        with pytest.raises(RuntimeError):
+            composite.access_object_at(2)

ostk/mathematics/test/geometry/d2/object/test_line.py

@@ -0,0 +1,57 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+PointSet = mathematics.geometry.d2.object.PointSet
+Line = mathematics.geometry.d2.object.Line
+
+
+class TestLine:
+    def test_constructor_success(self):
+        line = Line(
+            Point(1.0, 2.0),
+            np.array((3.4, 1.0)),
+        )
+
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined()
+
+    def test_contains_success_point_set(
+        self,
+        line: Line,
+        point_set: PointSet,
+    ):
+        assert line.contains(point_set) is True
+
+    def test_distance_to_success_point(
+        self,
+        line: Line,
+    ):
+        assert float(line.distance_to(Point(2.0, 3.0))) == pytest.approx(0.0, 1e-5)
+        assert float(line.distance_to(Point(1.0, 5.0))) == pytest.approx(2.12132, 1e-5)
+
+    def test_undefined_success(self):
+        line = Line.undefined()
+
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined() is False
+
+    def test_points_success(
+        self,
+        line: Line,
+    ):
+        assert line is not None
+        assert isinstance(line, Line)
+        assert isinstance(line, Object)
+        assert line.is_defined() is True

ostk/mathematics/test/geometry/d2/object/test_linestring.py

@@ -0,0 +1,174 @@
+# Apache License 2.0
+
+from collections.abc import Iterator, Iterable
+
+import numpy as np
+
+import pytest
+
+from ostk.core.type import String
+
+import ostk.mathematics as mathematics
+
+
+Object = mathematics.geometry.d2.Object
+Point = mathematics.geometry.d2.object.Point
+LineString = mathematics.geometry.d2.object.LineString
+
+
+class TestLineString:
+    def test_constructor_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+        point_3: Point = Point(1.0, -1.0)
+        point_4: Point = Point(-1.0, -1.0)
+
+        # Construction with Array of Points using python list
+        linestring: LineString = LineString([point_1, point_2, point_3, point_4])
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+        # Construction with Array of Points using python tuple
+        linestring: LineString = LineString((point_1, point_2, point_3, point_4))
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+        # Construction with Array of Points using python numpy array
+        linestring: LineString = LineString(
+            np.array((point_1, point_2, point_3, point_4))
+        )
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined()
+
+    def test_empty_constructor_success(self):
+        linestring: LineString = LineString.empty()
+
+        assert linestring is not None
+        assert isinstance(linestring, LineString)
+        assert isinstance(linestring, Object)
+        assert linestring.is_defined() is False
+        assert linestring.is_empty()
+
+    def test_comparators_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring_1: LineString = LineString([point_1, point_2])
+        linestring_2: LineString = LineString((point_1, point_2))
+        linestring_3: LineString = LineString(np.array([point_1, point_2]))
+        linestring_4: LineString = LineString([point_1])
+
+        assert linestring_1 == linestring_1
+        assert linestring_1 == linestring_2
+        assert linestring_1 == linestring_3
+        assert linestring_1 != linestring_4
+        assert linestring_2 != linestring_4
+        assert linestring_3 != linestring_4
+
+    def test_is_near_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        point_3: Point = Point(-0.996, 0.9995)
+        point_4: Point = Point(0.997, 0.996)
+
+        linestring_1: LineString = LineString([point_1, point_2])
+        linestring_2: LineString = LineString([point_3, point_4])
+
+        assert linestring_1.is_near(linestring_1, 10.0)
+        assert linestring_1.is_near(linestring_1, 0.1)
+        assert linestring_1.is_near(linestring_1, 1e-9)
+
+        assert linestring_2.is_near(linestring_2, 10.0)
+        assert linestring_2.is_near(linestring_2, 0.1)
+        assert linestring_2.is_near(linestring_2, 1e-9)
+
+        assert linestring_1.is_near(linestring_2, 1e-1)
+        assert linestring_1.is_near(linestring_2, 1e-2)
+
+        assert linestring_2.is_near(linestring_1, 1e-1)
+        assert linestring_2.is_near(linestring_1, 1e-2)
+
+    def test_getters_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring_1: LineString = LineString([point_1])
+        linestring_2: LineString = LineString([point_1, point_2])
+
+        assert LineString.empty().get_point_count() == 0
+        assert linestring_1.get_point_count() == 1
+        assert linestring_2.get_point_count() == 2
+
+        assert linestring_1.get_point_closest_to(Point(0.0, 0.0)) == point_1
+
+        assert linestring_2.get_point_closest_to(Point(0.0, 0.0)) == point_1
+        assert linestring_2.get_point_closest_to(Point(-0.9, 1.0)) == point_1
+        assert linestring_2.get_point_closest_to(Point(0.9, 1.0)) == point_2
+
+    def test_get_point_count_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert len(linestring) == 2
+        assert len(linestring) == linestring.get_point_count()
+        assert len(LineString.empty()) == 0
+
+    def test_len_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert len(linestring) == 2
+        assert len(LineString.empty()) == 0
+
+    def test_getitem_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        assert linestring[0] == point_1
+        assert linestring[1] == point_2
+
+        assert isinstance(linestring[0], Point)
+        assert isinstance(linestring[1], Point)
+
+        with pytest.raises(RuntimeError):
+            point = linestring[2]
+
+        linestring_list = list(linestring)
+
+        assert isinstance(linestring_list, list)
+        assert isinstance(linestring_list[0], Point)
+        assert isinstance(linestring_list[1], Point)
+        assert len(linestring_list) == 2
+
+    def test_iter_success(self):
+        point_1: Point = Point(-1.0, 1.0)
+        point_2: Point = Point(1.0, 1.0)
+
+        linestring: LineString = LineString([point_1, point_2])
+
+        for point in linestring:
+            assert isinstance(point, Point)
+
+        assert iter(linestring) is not None
+        assert isinstance(iter(linestring), Iterator)
+        assert isinstance(iter(linestring), Iterable)
+
+    # def test_to_string_success(self):
+
+    # def test_apply_transformation_success(self):