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

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

@@ -0,0 +1,138 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry import Angle
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationVector
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationMatrix
+from ostk.mathematics.geometry.d3.transformation.rotation import EulerAngle
+
+
+@pytest.fixture
+def euler_angle() -> EulerAngle:
+    return EulerAngle.unit()
+
+
+class TestEulerAngle:
+    def test_constructor_success(self):
+        EulerAngle(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+            axis_sequence=EulerAngle.AxisSequence.ZYX,
+        )
+
+        EulerAngle(
+            vector=(0.0, 0.0, 0.0),
+            angle_unit=Angle.Unit.Degree,
+            axis_sequence=EulerAngle.AxisSequence.ZYX,
+        )
+
+    def test_operators_success(self, euler_angle: EulerAngle):
+        assert (euler_angle == euler_angle) is True
+        assert (euler_angle != euler_angle) is False
+
+    def test_str_success(self, euler_angle: EulerAngle):
+        assert str(euler_angle) is not None
+
+    def test_repr_success(self, euler_angle: EulerAngle):
+        assert repr(euler_angle) is not None
+
+    def test_is_defined_success(self, euler_angle: EulerAngle):
+        assert euler_angle.is_defined()
+
+    def test_is_unitary_success(self, euler_angle: EulerAngle):
+        assert euler_angle.is_unitary()
+
+    def test_is_near_success(self, euler_angle: EulerAngle):
+        assert euler_angle.is_near(
+            euler_angle=euler_angle,
+            angular_tolerance=Angle.zero(),
+        )
+
+    def test_properties_success(self, euler_angle: EulerAngle):
+        assert euler_angle.phi == Angle.degrees(0.0)
+        assert euler_angle.theta == Angle.degrees(0.0)
+        assert euler_angle.psi == Angle.degrees(0.0)
+        assert euler_angle.axis_sequence == EulerAngle.AxisSequence.ZYX
+
+    def test_to_vector_success(self, euler_angle: EulerAngle):
+        assert np.array_equal(
+            euler_angle.to_vector(angle_unit=Angle.Unit.Degree), np.array((0.0, 0.0, 0.0))
+        )
+
+    def test_to_string_success(self, euler_angle: EulerAngle):
+        assert euler_angle.to_string() == "[0, 0, 0] (ZYX)"
+        assert euler_angle.to_string(angle_unit=Angle.Unit.Degree) == "[0, 0, 0] (ZYX)"
+
+    def test_undefined_success(self):
+        assert not EulerAngle.undefined().is_defined()
+
+    def test_unit_success(self, euler_angle: EulerAngle):
+        assert EulerAngle.unit() == euler_angle
+
+    def test_xyz_success(self):
+        assert EulerAngle.xyz(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+        ) == EulerAngle(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+            axis_sequence=EulerAngle.AxisSequence.XYZ,
+        )
+
+    def test_zxy_success(self):
+        assert EulerAngle.zxy(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+        ) == EulerAngle(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+            axis_sequence=EulerAngle.AxisSequence.ZXY,
+        )
+
+    def test_zyx_success(self):
+        assert EulerAngle.zyx(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+        ) == EulerAngle(
+            phi=Angle.zero(),
+            theta=Angle.zero(),
+            psi=Angle.zero(),
+            axis_sequence=EulerAngle.AxisSequence.ZYX,
+        )
+
+    def test_quaternion_success(self):
+        assert (
+            EulerAngle.quaternion(
+                quaternion=Quaternion.unit(),
+                axis_sequence=EulerAngle.AxisSequence.ZYX,
+            )
+            == EulerAngle.unit()
+        )
+
+    def test_rotation_vector_success(self):
+        assert (
+            EulerAngle.rotation_vector(
+                rotation_vector=RotationVector.unit(),
+                axis_sequence=EulerAngle.AxisSequence.ZYX,
+            )
+            == EulerAngle.unit()
+        )
+
+    def test_rotation_matrix_success(self):
+        assert (
+            EulerAngle.rotation_matrix(
+                rotation_matrix=RotationMatrix.unit(),
+                axis_sequence=EulerAngle.AxisSequence.ZYX,
+            )
+            == EulerAngle.unit()
+        )

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

@@ -0,0 +1,189 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry import Angle
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationVector
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationMatrix
+from ostk.mathematics.geometry.d3.transformation.rotation import EulerAngle
+
+
+@pytest.fixture
+def quaternion() -> Quaternion:
+    return Quaternion.xyzs(0.0, 0.0, 0.0, 1.0)
+
+
+class TestQuaternion:
+    def test_constructor_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
+        assert quaternion.is_unitary(0.0001) 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_to_rectify_success(self, quaternion: Quaternion):
+        assert quaternion.to_rectify() == 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_euler_angle_success(self, quaternion: Quaternion):
+        assert Quaternion.euler_angle(EulerAngle.unit()) == 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,40 @@
+# Apache License 2.0
+
+import pytest
+import numpy as np
+
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationMatrix
+from ostk.mathematics.geometry.d3.transformation.rotation import EulerAngle
+
+
+@pytest.fixture
+def rotation_matrix() -> RotationMatrix:
+    return RotationMatrix.unit()
+
+
+class TestRotationMatrix:
+    def test_is_defined_success(self, rotation_matrix: RotationMatrix):
+        assert rotation_matrix.is_defined() is True
+
+    def test_quaternion_success(self, rotation_matrix: RotationMatrix):
+        assert RotationMatrix.quaternion(Quaternion.unit()) == rotation_matrix
+
+    def test_euler_angle_success(self, rotation_matrix: RotationMatrix):
+        assert RotationMatrix.euler_angle(EulerAngle.unit()) == rotation_matrix
+
+    def test_getters(self, rotation_matrix: RotationMatrix):
+        assert rotation_matrix.get_column_at(0) is not None
+        assert rotation_matrix.get_row_at(1) is not None
+        assert rotation_matrix.get_matrix() is not None
+
+    def test_vector_basis_identity(self, rotation_matrix: RotationMatrix):
+        first_vector = np.array([1.0, 0.0, 0.0])
+        second_vector = np.array([0.0, 1.0, 0.0])
+
+        rotation_matrix = RotationMatrix.vector_basis(
+            source_vectors=(first_vector, second_vector),
+            destination_vectors=(first_vector, second_vector),
+        )
+
+        assert rotation_matrix is not None

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

@@ -0,0 +1,47 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.mathematics.geometry import Angle
+from ostk.mathematics.geometry.d3.transformation.rotation import Quaternion
+from ostk.mathematics.geometry.d3.transformation.rotation import RotationVector
+from ostk.mathematics.geometry.d3.transformation.rotation import EulerAngle
+
+
+@pytest.fixture
+def rotation_vector() -> RotationVector:
+    return RotationVector.unit()
+
+
+class TestRotationVector:
+    def test_constructor_success(self):
+        RotationVector(
+            axis=(0.0, 0.0, 1.0),
+            angle=Angle.zero(),
+        )
+
+        RotationVector(
+            vector=(0.0, 0.0, 1.0),
+            angle_unit=Angle.Unit.Degree,
+        )
+
+    def test_operators_success(self, rotation_vector: RotationVector):
+        assert (rotation_vector == rotation_vector) is True
+        assert (rotation_vector != rotation_vector) is False
+
+    def test_get_angle_success(self, rotation_vector: RotationVector):
+        assert rotation_vector.get_angle() == Angle.zero()
+
+    def test_is_defined_success(self, rotation_vector: RotationVector):
+        assert rotation_vector.is_defined() is True
+
+    def test_is_defined_success(self, rotation_vector: RotationVector):
+        rotation_vector.rectify()
+
+    def test_quaternion_success(self, rotation_vector: RotationVector):
+        assert RotationVector.quaternion(Quaternion.unit()) == rotation_vector
+
+    def test_euler_angle_success(self, rotation_vector: RotationVector):
+        assert RotationVector.euler_angle(EulerAngle.unit()) == rotation_vector