open-space-toolkit-mathematics 3.0.0__py39-none-manylinux2014_aarch64.whl

ostk/mathematics/test/geometry/d3/transformation/rotation/test_quaternion.py

@@ -0,0 +1,183 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics import geometry
+
+
+Angle = geometry.Angle
+Quaternion = geometry.d3.transformation.rotation.Quaternion
+RotationVector = geometry.d3.transformation.rotation.RotationVector
+RotationMatrix = geometry.d3.transformation.rotation.RotationMatrix
+
+
+@pytest.fixture
+def quaternion() -> Quaternion:
+    return Quaternion.xyzs(0.0, 0.0, 0.0, 1.0)
+
+
+class TestQuaternion:
+    def test_constructors_success(self, quaternion: Quaternion):
+        assert Quaternion(0.0, 0.0, 0.0, 1.0, Quaternion.Format.XYZS) == quaternion
+        assert (
+            Quaternion(np.array((0.0, 0.0, 0.0, 1.0)), Quaternion.Format.XYZS)
+            == quaternion
+        )
+        assert Quaternion(np.array((0.0, 0.0, 0.0)), 1.0) == quaternion
+        assert Quaternion(quaternion) == quaternion
+
+    def test_operators_success(self, quaternion: Quaternion):
+        assert (quaternion == quaternion) is True
+        assert (quaternion != quaternion) is False
+
+        assert (quaternion + quaternion) == Quaternion.xyzs(0.0, 0.0, 0.0, 2.0)
+
+        quaternion_2 = Quaternion(quaternion)
+        quaternion_2 += quaternion
+        assert quaternion_2 == Quaternion.xyzs(0.0, 0.0, 0.0, 2.0)
+
+        assert (quaternion * 1.0) == quaternion
+        assert (1.0 * quaternion) == quaternion
+
+        assert (quaternion**1.0) == quaternion
+
+    def test_is_defined_success(self, quaternion: Quaternion):
+        assert quaternion.is_defined() is True
+
+    def test_is_unitary_success(self, quaternion: Quaternion):
+        assert quaternion.is_unitary() is True
+
+    def test_is_near_success(self, quaternion: Quaternion):
+        assert quaternion.is_near(quaternion, Angle.zero()) is True
+
+    def test_getter_success(self, quaternion: Quaternion):
+        assert quaternion.x() == 0.0
+        assert quaternion.y() == 0.0
+        assert quaternion.z() == 0.0
+        assert quaternion.s() == 1.0
+
+    def test_get_vector_part_success(self, quaternion: Quaternion):
+        assert (
+            np.array_equal(quaternion.get_vector_part(), np.array((0.0, 0.0, 0.0)))
+            is True
+        )
+
+    def test_get_scalar_part_success(self, quaternion: Quaternion):
+        assert quaternion.get_scalar_part() == 1.0
+
+    def test_to_normalized_success(self, quaternion: Quaternion):
+        assert quaternion.to_normalized() == quaternion
+
+    def test_to_conjugate_success(self, quaternion: Quaternion):
+        assert quaternion.to_conjugate() == quaternion
+
+    def test_to_inverse_success(self, quaternion: Quaternion):
+        assert quaternion.to_inverse() == quaternion
+
+    def test_exp_success(self, quaternion: Quaternion):
+        assert quaternion.exp() == quaternion
+
+    def test_log_success(self, quaternion: Quaternion):
+        assert quaternion.log() == Quaternion.xyzs(0.0, 0.0, 0.0, 0.0)
+
+    def test_pow_success(self, quaternion: Quaternion):
+        assert quaternion.pow(1.0) == quaternion
+
+    def test_norm_success(self, quaternion: Quaternion):
+        assert quaternion.norm() == 1.0
+
+    def test_cross_multiply_success(self, quaternion: Quaternion):
+        assert quaternion.cross_multiply(quaternion) == quaternion
+
+    def test_dot_multiply_success(self, quaternion: Quaternion):
+        assert quaternion.dot_multiply(quaternion) == quaternion
+
+    def test_dot_product_success(self, quaternion: Quaternion):
+        assert quaternion.dot_product(quaternion) == 1.0
+
+    def test_rotate_vector_success(self, quaternion: Quaternion):
+        assert np.array_equal(
+            quaternion.rotate_vector(np.array((0.0, 0.0, 1.0))), np.array((0.0, 0.0, 1.0))
+        )
+
+    def test_to_vector_success(self, quaternion: Quaternion):
+        assert (
+            np.array_equal(
+                quaternion.to_vector(Quaternion.Format.XYZS),
+                np.array((0.0, 0.0, 0.0, 1.0)),
+            )
+            is True
+        )
+
+    def test_to_string_success(self, quaternion: Quaternion):
+        assert quaternion.to_string() == "[0.0, 0.0, 0.0, 1.0]"
+
+    def test_to_string_success_with_format(self, quaternion: Quaternion):
+        assert quaternion.to_string(Quaternion.Format.XYZS) == "[0.0, 0.0, 0.0, 1.0]"
+
+    def test_normalize_success(self, quaternion: Quaternion):
+        quaternion_2 = Quaternion(quaternion)
+        quaternion_2.normalize()
+        assert quaternion_2 == quaternion
+
+    def test_conjugate_success(self, quaternion: Quaternion):
+        quaternion_2 = Quaternion(quaternion)
+        quaternion_2.conjugate()
+        assert quaternion_2 == quaternion
+
+    def test_inverse_success(self, quaternion: Quaternion):
+        quaternion_2 = Quaternion(quaternion)
+        quaternion_2.inverse()
+        assert quaternion_2 == quaternion
+
+    def test_rectify_success(self, quaternion: Quaternion):
+        quaternion_2 = Quaternion(quaternion)
+        quaternion_2.rectify()
+        assert quaternion_2 == quaternion
+
+    def test_angular_difference_with_success(self, quaternion: Quaternion):
+        assert quaternion.angular_difference_with(quaternion) == Angle.zero()
+
+    def test_undefined_success(self):
+        assert Quaternion.undefined().is_defined() is False
+
+    def test_unit_success(self, quaternion: Quaternion):
+        assert Quaternion.unit() == quaternion
+
+    def test_xyzs_success(self, quaternion: Quaternion):
+        assert Quaternion.xyzs(0.0, 0.0, 0.0, 1.0) == quaternion
+
+    def test_rotation_vector_success(self, quaternion: Quaternion):
+        assert (
+            Quaternion.rotation_vector(
+                RotationVector(np.array((0.0, 0.0, 1.0)), Angle.zero())
+            )
+            == quaternion
+        )
+
+    def test_rotation_matrix_success(self, quaternion: Quaternion):
+        assert Quaternion.rotation_matrix(RotationMatrix.rz(Angle.zero())) == quaternion
+
+    def test_parse_success(self, quaternion: Quaternion):
+        assert (
+            Quaternion.parse("[0.0, 0.0, 0.0, 1.0]", Quaternion.Format.XYZS) == quaternion
+        )
+
+    def test_shortest_rotation_success(self, quaternion: Quaternion):
+        assert (
+            Quaternion.shortest_rotation(
+                np.array((1.0, 0.0, 0.0)), np.array((1.0, 0.0, 0.0))
+            )
+            == quaternion
+        )
+
+    def test_lerp_success(self, quaternion: Quaternion):
+        assert Quaternion.lerp(quaternion, quaternion, 0.0) == quaternion
+
+    def test_nlerp_success(self, quaternion: Quaternion):
+        assert Quaternion.nlerp(quaternion, quaternion, 0.0) == quaternion
+
+    def test_slerp_success(self, quaternion: Quaternion):
+        assert Quaternion.slerp(quaternion, quaternion, 0.0) == quaternion

ostk/mathematics/test/geometry/d3/transformation/rotation/test_rotation_matrix.py

@@ -0,0 +1,24 @@
+# Apache License 2.0
+
+from ostk.mathematics import geometry
+
+
+Angle = geometry.Angle
+Quaternion = geometry.d3.transformation.rotation.Quaternion
+RotationMatrix = geometry.d3.transformation.rotation.RotationMatrix
+
+
+# isDefined
+# getRowAt
+# getColumnAt
+# toTransposed
+# transpose
+# Undefined
+# Unit
+# RX
+# RY
+# RZ
+# Rows
+# Columns
+# Quaternion
+# RotationVector

ostk/mathematics/test/geometry/d3/transformation/rotation/test_rotation_vector.py

@@ -0,0 +1,34 @@
+# Apache License 2.0
+
+import numpy
+
+from ostk.mathematics import geometry
+
+
+Angle = geometry.Angle
+Quaternion = geometry.d3.transformation.rotation.Quaternion
+RotationVector = geometry.d3.transformation.rotation.RotationVector
+
+
+def test_geometry_d3_transformation_rotation_rotation_vector():
+    rv: RotationVector = RotationVector(
+        numpy.array([[0.0], [0.0], [1.0]], dtype=float), Angle.zero()
+    )
+
+    assert (rv == rv) is True
+    assert (rv != rv) is False
+
+    assert rv.is_defined() is True
+
+    # assert numpy.array_equal(rv.get_axis(), numpy.array([[0.0], [0.0], [1.0]], dtype=float))
+    assert rv.get_angle() == Angle.zero()
+
+    assert RotationVector.undefined().is_defined() is False
+    assert RotationVector.unit().is_defined() is True
+    assert (
+        RotationVector.quaternion(
+            Quaternion(0.0, 0.0, 0.0, 1.0, Quaternion.Format.XYZS)
+        ).is_defined()
+        is True
+    )
+    # assert RotationVector.RotationMatrix().is_defined() is True

ostk/mathematics/test/geometry/test_angle.py

@@ -0,0 +1,345 @@
+# Apache License 2.0
+
+import pytest
+
+import math
+
+import ostk.mathematics as mathematics
+
+
+Angle = mathematics.geometry.Angle
+Unit = Angle.Unit
+
+
+def test_angle_unit():
+    enum_members = Unit.__members__
+
+    list_keys = ["Undefined", "Radian", "Degree", "Arcminute", "Arcsecond", "Revolution"]
+
+    list_values = [
+        Unit.Undefined,
+        Unit.Radian,
+        Unit.Degree,
+        Unit.Arcminute,
+        Unit.Arcsecond,
+        Unit.Revolution,
+    ]
+
+    assert list(enum_members.keys()) == list_keys
+    assert list(enum_members.values()) == list_values
+
+
+def test_angle_default_constructor():
+    # Default constructor with Degree Unit
+    angle: Angle = Angle(12.34, Unit.Degree)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_degrees() == 12.34
+
+    angle: Angle = Angle(-12.34, Unit.Degree)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_degrees() == -12.34
+
+    angle: Angle = Angle(365.34, Unit.Degree)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_degrees() == 365.34
+
+    angle: Angle = Angle(-4000.34, Unit.Degree)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_degrees() == -4000.34
+
+    # Default constructor with Radian Unit
+    angle: Angle = Angle(3.4, Unit.Radian)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_radians() == 3.4
+
+    # Default constructor with Arcminute Unit
+    angle: Angle = Angle(3600.0, Unit.Arcminute)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_arcminutes() == 3600.0
+
+    # Default constructor with Arcsecond Unit
+    angle: Angle = Angle(3600.0, Unit.Arcsecond)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_arcseconds() == 3600.0
+
+    # Default constructor with Revolution Unit
+    angle: Angle = Angle(18.0, Unit.Revolution)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.in_revolutions() == 18.0
+
+    # Invalid construction
+    with pytest.raises(TypeError):
+        angle: Angle = Angle(45, Unit.Degree)
+
+
+def test_angle_undefined_constructor():
+    angle: Angle = Angle.undefined()
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined() is False
+
+
+def test_angle_zero_constructor():
+    angle: Angle = Angle.zero()
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined() is True
+    assert angle.get_unit() == Unit.Radian
+    assert angle.is_zero() is True
+    assert angle.in_radians() == 0.0
+    assert angle.in_degrees() == 0.0
+    assert angle.in_arcminutes() == 0.0
+    assert angle.in_arcseconds() == 0.0
+    assert angle.in_revolutions() == 0.0
+
+
+def test_angle_pi_constructors():
+    angle: Angle = Angle.half_pi()
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Radian
+    assert angle.in_radians() == math.pi / 2
+
+    angle: Angle = Angle.pi()
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Radian
+    assert angle.in_radians() == math.pi
+
+    angle: Angle = Angle.two_pi()
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Radian
+    assert angle.in_radians() == 2 * math.pi
+
+
+def test_angle_unit_constructors():
+    # Radian
+    angle: Angle = Angle.radians(3.4)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Radian
+    assert angle.in_radians() == 3.4
+
+    # Degree
+    angle: Angle = Angle.degrees(-45.0)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Degree
+    assert angle.in_degrees() == -45.0
+
+    # Arcminutes
+    angle: Angle = Angle.arcminutes(60.5)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Arcminute
+    assert angle.in_arcminutes() == 60.5
+
+    # Arcseconds
+    angle: Angle = Angle.arcseconds(60.5)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Arcsecond
+    assert angle.in_arcseconds() == 60.5
+
+    # Revolutions
+    angle: Angle = Angle.revolutions(3.9)
+
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.is_defined()
+    assert angle.get_unit() == Unit.Revolution
+    assert angle.in_revolutions() == 3.9
+
+
+def test_angle_unit_conversion():
+    angle: Angle = Angle(60.0, Unit.Degree)
+
+    assert angle.in_degrees() == 60.0
+    assert angle.in_radians() == (math.pi * 60.0 / 180.0)
+    assert angle.in_arcminutes() == 60.0 * 60.0
+    assert (angle.in_arcseconds() - 60.0 * 3600.0) <= 1e-10
+
+
+def test_angle_comparators():
+    angle_deg: Angle = Angle(60.0, Unit.Degree)
+    angle_rad: Angle = Angle(60.0 * math.pi / 180.0, Unit.Radian)
+
+    assert angle_deg == angle_deg
+    assert angle_rad == angle_rad
+    assert angle_deg == angle_rad
+    assert angle_deg != Angle(59.0, Unit.Degree)
+
+
+def test_angle_operators():
+    angle: Angle = Angle(30.0, Unit.Degree)
+    half_angle: Angle = angle / 2.0
+    double_angle: Angle = angle * 2.0
+    sum_angle: Angle = angle + angle
+    diff_angle: Angle = angle - angle
+    positive_angle: Angle = +angle
+    negative_angle: Angle = -angle
+
+    assert half_angle is not None
+    assert isinstance(half_angle, Angle)
+    assert double_angle is not None
+    assert isinstance(double_angle, Angle)
+    assert sum_angle is not None
+    assert isinstance(sum_angle, Angle)
+    assert diff_angle is not None
+    assert isinstance(diff_angle, Angle)
+    assert positive_angle is not None
+    assert isinstance(positive_angle, Angle)
+    assert negative_angle is not None
+    assert isinstance(negative_angle, Angle)
+
+    assert half_angle.in_degrees() == 15.0
+    assert double_angle.in_degrees() == 60.0
+    assert sum_angle.in_degrees() == 60.0
+    assert diff_angle.in_degrees() == 0.0
+    assert diff_angle.is_zero()
+    assert positive_angle.in_degrees() == +30.0
+    assert negative_angle.in_degrees() == -30.0
+
+    angle_deg: Angle = Angle(90.0, Unit.Degree)
+    angle_rad: Angle = Angle(math.pi / 2, Unit.Radian)
+
+    sum_angle: Angle = angle_rad + angle_deg
+    assert sum_angle is not None
+    assert isinstance(sum_angle, Angle)
+    assert (sum_angle.in_degrees() - 180.0) <= 1e-10
+
+    angle: Angle = Angle(90.0, Unit.Degree)
+
+    angle *= 3.0
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.get_unit() == Unit.Degree
+    assert angle.in_degrees() == 270.0
+
+    angle /= 3.0
+    assert angle is not None
+    assert isinstance(angle, Angle)
+    assert angle.get_unit() == Unit.Degree
+    assert angle.in_degrees() == 90.0
+
+
+# def test_angle_between_vector2d ():
+
+# def test_angle_between_vector3d ():
+
+# def test_angle_to_string ():
+
+
+def test_angle_string_from_unit():
+    assert Angle.string_from_unit(Unit.Degree) == "Degree"
+    assert Angle.string_from_unit(Unit.Radian) == "Radian"
+    assert Angle.string_from_unit(Unit.Arcminute) == "Arcminute"
+    assert Angle.string_from_unit(Unit.Arcsecond) == "Arcsecond"
+    assert Angle.string_from_unit(Unit.Revolution) == "Revolution"
+
+
+def test_angle_string_symbol_from_unit():
+    assert Angle.symbol_from_unit(Unit.Degree) == "deg"
+    assert Angle.symbol_from_unit(Unit.Radian) == "rad"
+    assert Angle.symbol_from_unit(Unit.Arcminute) == "amin"
+    assert Angle.symbol_from_unit(Unit.Arcsecond) == "asec"
+    assert Angle.symbol_from_unit(Unit.Revolution) == "rev"
+
+
+def test_angle_in_radians_reduction():
+    angle: Angle = Angle(math.pi * 3 / 2, Unit.Radian)
+    assert angle.in_radians(lower_bound=-math.pi, upper_bound=math.pi) == -math.pi / 2
+
+    angle: Angle = Angle(math.pi / 2, Unit.Radian)
+    assert angle.in_radians(lower_bound=-math.pi, upper_bound=math.pi) == math.pi / 2
+
+    angle: Angle = Angle(-math.pi, Unit.Radian)
+    assert angle.in_radians(-math.pi, math.pi) == -math.pi
+
+    angle: Angle = Angle(math.pi, Unit.Radian)
+    assert angle.in_radians(-math.pi, math.pi) == -math.pi
+
+
+def test_angle_in_degrees_reduction():
+    angle: Angle = Angle(359.0, Unit.Degree)
+    assert angle.in_degrees(lower_bound=-180.0, upper_bound=180.0) == -1.0
+
+    angle: Angle = Angle(1.0, Unit.Degree)
+    assert angle.in_degrees(lower_bound=-180.0, upper_bound=180.0) == 1.0
+
+    angle: Angle = Angle(-180.0, Unit.Degree)
+    assert angle.in_degrees(-180.0, 180.0) == -180.0
+
+    angle: Angle = Angle(180.0, Unit.Degree)
+    assert angle.in_degrees(-180.0, 180.0) == -180.0
+
+
+def test_angle_in_arcminutes_reduction():
+    angle: Angle = Angle(359.0 * 60.0, Unit.Arcminute)
+    assert (
+        angle.in_arcminutes(lower_bound=-180.0 * 60.0, upper_bound=180.0 * 60.0) == -60.0
+    )
+
+    angle: Angle = Angle(60.0, Unit.Arcminute)
+    assert (
+        angle.in_arcminutes(lower_bound=-180.0 * 60.0, upper_bound=180.0 * 60.0) == 60.0
+    )
+
+    angle: Angle = Angle(-180.0 * 60.0, Unit.Arcminute)
+    assert angle.in_arcminutes(-180.0 * 60.0, 180.0 * 60.0) == -180.0 * 60.0
+
+    angle: Angle = Angle(180.0 * 60.0, Unit.Arcminute)
+    assert angle.in_arcminutes(-180.0 * 60.0, 180.0 * 60.0) == -180.0 * 60.0
+
+
+def test_angle_in_arcseconds_reduction():
+    angle: Angle = Angle(359.0 * 3600.0, Unit.Arcsecond)
+    assert (
+        angle.in_arcseconds(lower_bound=-180.0 * 3600.0, upper_bound=180.0 * 3600.0)
+        == -3600.0
+    )
+
+    angle: Angle = Angle(3600.0, Unit.Arcsecond)
+    assert (
+        angle.in_arcseconds(lower_bound=-180.0 * 3600.0, upper_bound=180.0 * 3600.0)
+        == 3600.0
+    )
+
+    angle: Angle = Angle(-180 * 3600.0, Unit.Arcsecond)
+    assert angle.in_arcseconds(-180.0 * 3600.0, 180.0 * 3600.0) == -180.0 * 3600.0
+
+    angle: Angle = Angle(180.0 * 3600.0, Unit.Arcsecond)
+    assert angle.in_arcseconds(-180.0 * 3600.0, 180.0 * 3600.0) == -180.0 * 3600.0

ostk/mathematics/test/object/__init__.py

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