feat: bindings for physics data classes

bindings/python/src/OpenSpaceToolkitPhysicsPy.cxx

@@ -13,6 +13,7 @@
 #include <OpenSpaceToolkitPhysicsPy/Environment.cpp>
 #include <OpenSpaceToolkitPhysicsPy/Time.cpp>
 #include <OpenSpaceToolkitPhysicsPy/Unit.cpp>
+#include <OpenSpaceToolkitPhysicsPy/Data.cpp>
 
 PYBIND11_MODULE(OpenSpaceToolkitPhysicsPy, m)
 {
@@ -33,5 +34,6 @@ PYBIND11_MODULE(OpenSpaceToolkitPhysicsPy, m)
     OpenSpaceToolkitPhysicsPy_Unit(m);
     OpenSpaceToolkitPhysicsPy_Time(m);
     OpenSpaceToolkitPhysicsPy_Coordinate(m);
+    OpenSpaceToolkitPhysicsPy_Data(m);
     OpenSpaceToolkitPhysicsPy_Environment(m);
 }

bindings/python/src/OpenSpaceToolkitPhysicsPy/Data.cpp

@@ -0,0 +1,18 @@
+/// Apache License 2.0
+
+#include <OpenSpaceToolkitPhysicsPy/Data/Scalar.cpp>
+#include <OpenSpaceToolkitPhysicsPy/Data/Vector.cpp>
+#include <OpenSpaceToolkitPhysicsPy/Data/Direction.cpp>
+
+inline void OpenSpaceToolkitPhysicsPy_Data(pybind11::module& aModule)
+{
+    using namespace pybind11;
+
+    // Create "data" python submodule
+    auto data = aModule.def_submodule("data");
+
+    // Add objects to python "data" submodules
+    OpenSpaceToolkitPhysicsPy_Data_Scalar(data);
+    OpenSpaceToolkitPhysicsPy_Data_Vector(data);
+    OpenSpaceToolkitPhysicsPy_Data_Direction(data);
+}

bindings/python/src/OpenSpaceToolkitPhysicsPy/Data/Direction.cpp

@@ -0,0 +1,31 @@
+/// Apache License 2.0
+
+#include <OpenSpaceToolkit/Physics/Data/Direction.hpp>
+
+inline void OpenSpaceToolkitPhysicsPy_Data_Direction(pybind11::module& aModule)
+{
+    using namespace pybind11;
+
+    using ostk::core::type::Shared;
+
+    using ostk::mathematics::object::Vector3d;
+
+    using ostk::physics::Unit;
+    using ostk::physics::coordinate::Frame;
+    using ostk::physics::data::Direction;
+    using ostk::physics::data::Vector;
+
+    class_<Direction, Vector>(aModule, "Direction")
+
+        .def(init<const Vector3d&, const Shared<const Frame>&>(), arg("value"), arg("frame"))
+
+        .def(self == self)
+        .def(self != self)
+
+        .def("__str__", &(shiftToString<Direction>))
+        .def("__repr__", &(shiftToString<Direction>))
+
+        .def_static("undefined", &Direction::Undefined)
+
+        ;
+}

bindings/python/src/OpenSpaceToolkitPhysicsPy/Data/Scalar.cpp

@@ -0,0 +1,34 @@
+/// Apache License 2.0
+
+#include <OpenSpaceToolkit/Physics/Data/Scalar.hpp>
+
+inline void OpenSpaceToolkitPhysicsPy_Data_Scalar(pybind11::module& aModule)
+{
+    using namespace pybind11;
+
+    using ostk::core::type::Real;
+    using ostk::core::type::Integer;
+
+    using ostk::physics::Unit;
+    using ostk::physics::data::Scalar;
+
+    class_<Scalar>(aModule, "Scalar")
+
+        .def(init<const Real&, const Unit&>(), arg("value"), arg("unit"))
+
+        .def(self == self)
+        .def(self != self)
+
+        .def("__str__", &(shiftToString<Scalar>))
+        .def("__repr__", &(shiftToString<Scalar>))
+
+        .def("is_defined", &Scalar::isDefined)
+        .def("get_value", &Scalar::getValue)
+        .def("get_unit", &Scalar::getUnit)
+        .def("in_unit", &Scalar::inUnit, arg("unit"))
+        .def("to_string", &Scalar::toString, arg("precision") = Integer::Undefined())
+
+        .def_static("undefined", &Scalar::Undefined)
+
+        ;
+}

bindings/python/src/OpenSpaceToolkitPhysicsPy/Data/Vector.cpp

@@ -0,0 +1,38 @@
+/// Apache License 2.0
+
+#include <OpenSpaceToolkit/Physics/Data/Vector.hpp>
+
+inline void OpenSpaceToolkitPhysicsPy_Data_Vector(pybind11::module& aModule)
+{
+    using namespace pybind11;
+
+    using ostk::core::type::Shared;
+
+    using ostk::mathematics::object::Vector3d;
+
+    using ostk::physics::Unit;
+    using ostk::physics::data::Vector;
+    using ostk::physics::coordinate::Frame;
+
+    class_<Vector>(aModule, "Vector")
+
+        .def(init<const Vector3d&, const Unit&, const Shared<const Frame>&>(), arg("value"), arg("unit"), arg("frame"))
+
+        .def(self == self)
+        .def(self != self)
+
+        .def("__str__", &(shiftToString<Vector>))
+        .def("__repr__", &(shiftToString<Vector>))
+
+        .def("is_defined", &Vector::isDefined)
+        .def("get_value", &Vector::getValue)
+        .def("get_unit", &Vector::getUnit)
+        .def("get_frame", &Vector::getFrame)
+        .def("in_unit", &Vector::inUnit, arg("unit"))
+        .def("in_frame", &Vector::inFrame, arg("frame"), arg("instant"))
+        .def("to_string", &Vector::toString, arg("precision") = 6)
+
+        .def_static("undefined", &Vector::Undefined)
+
+        ;
+}

bindings/python/src/OpenSpaceToolkitPhysicsPy/Unit.cpp

@@ -9,10 +9,40 @@
 
 inline void OpenSpaceToolkitPhysicsPy_Unit(pybind11::module& aModule)
 {
+    using namespace pybind11;
+
+    using ostk::physics::Unit;
+
+    class_<Unit> unit_class(aModule, "Unit");
+
+    enum_<Unit::Type>(unit_class, "Type")
+        .value("Undefined", Unit::Type::Undefined)
+        .value("None", Unit::Type::None)
+        .value("Length", Unit::Type::Length)
+        .value("Mass", Unit::Type::Mass)
+        .value("Time", Unit::Type::Time)
+        .value("Temperature", Unit::Type::Temperature)
+        .value("ElectricCurrent", Unit::Type::ElectricCurrent)
+        .value("LuminousIntensity", Unit::Type::LuminousIntensity)
+        .value("Derived", Unit::Type::Derived)
+
+        ;
+
+    unit_class
+        .def("is_defined", &Unit::isDefined)
+        .def("is_none", &Unit::isNone)
+        .def("get_type", &Unit::getType)
+        .def("ratio_to", &Unit::ratioTo, arg("unit"))
+        .def("to_string", &Unit::toString)
+        .def_static("undefined", &Unit::Undefined)
+        .def_static("none", &Unit::None)
+        .def_static("length", &Unit::Length, arg("length_unit"))
+        .def_static("derived", &Unit::Derived, arg("derived_unit"))
+        .def_static("string_from_type", &Unit::StringFromType, arg("type"));
+
     // Create "unit" python submodule
     auto unit = aModule.def_submodule("unit");
 
-
     // Add objects to python "unit" submodules
     OpenSpaceToolkitPhysicsPy_Unit_Length(unit);
     OpenSpaceToolkitPhysicsPy_Unit_Mass(unit);

bindings/python/test/data/test_direction.py

@@ -0,0 +1,37 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics.data import Direction
+from ostk.physics.coordinate import Frame
+
+
+@pytest.fixture
+def value() -> np.ndarray:
+    return np.array([1.0, 0.0, 0.0])
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def direction(value: float, frame: Frame) -> Direction:
+    return Direction(
+        value=value,
+        frame=frame,
+    )
+
+
+class TestDirection:
+    def test_equals(self, direction: Direction):
+        assert direction == direction
+
+    def test_not_equals(self, direction: Direction):
+        assert (direction != direction) is False
+
+    def test_undefined(self):
+        assert Direction.undefined() is not None

bindings/python/test/data/test_scalar.py

@@ -0,0 +1,48 @@
+# Apache License 2.0
+
+import pytest
+
+from ostk.physics import Unit
+from ostk.physics.data import Scalar
+from ostk.physics.unit import Length
+
+
+@pytest.fixture
+def unit() -> Unit:
+    return Unit.length(Length.Unit.Meter)
+
+
+@pytest.fixture
+def value() -> float:
+    return 5.0
+
+
+@pytest.fixture
+def scalar(value: float, unit: Unit) -> Scalar:
+    return Scalar(
+        value=value,
+        unit=unit,
+    )
+
+
+class TestScalar:
+    def test_equals(self, scalar: Scalar):
+        assert scalar == scalar
+
+    def test_not_equals(self, scalar: Scalar):
+        assert (scalar != scalar) is False
+
+    def test_is_defined(self, scalar: Scalar):
+        assert scalar.is_defined()
+
+    def test_get_value(self, scalar: Scalar, value: float):
+        assert scalar.get_value() == value
+
+    def test_get_unit(self, scalar: Scalar):
+        assert scalar.get_unit().is_defined()
+
+    def test_in_unit(self, scalar: Scalar):
+        assert scalar.in_unit(Unit.length(Length.Unit.Foot)) is not None
+
+    def test_to_string(self, scalar: Scalar):
+        assert scalar.to_string() is not None

bindings/python/test/data/test_vector.py

@@ -0,0 +1,64 @@
+# Apache License 2.0
+
+import pytest
+
+import numpy as np
+
+from ostk.physics import Unit
+from ostk.physics.data import Vector
+from ostk.physics.unit import Length
+from ostk.physics.time import Instant
+from ostk.physics.coordinate import Frame
+
+
+@pytest.fixture
+def unit() -> Unit:
+    return Unit.length(Length.Unit.Meter)
+
+
+@pytest.fixture
+def value() -> np.ndarray:
+    return np.array([1.0, 2.0, 3.0])
+
+
+@pytest.fixture
+def frame() -> Frame:
+    return Frame.GCRF()
+
+
+@pytest.fixture
+def vector(value: float, unit: Unit, frame: Frame) -> Vector:
+    return Vector(
+        value=value,
+        unit=unit,
+        frame=frame,
+    )
+
+
+class TestVector:
+    def test_equals(self, vector: Vector):
+        assert vector == vector
+
+    def test_not_equals(self, vector: Vector):
+        assert (vector != vector) is False
+
+    def test_is_defined(self, vector: Vector):
+        assert vector.is_defined()
+
+    def test_get_value(self, vector: Vector, value: float):
+        assert np.all(vector.get_value() == value)
+
+    def test_get_unit(self, vector: Vector):
+        assert vector.get_unit().is_defined()
+
+    def test_get_frame(self, vector: Vector, frame: Frame):
+        assert vector.get_frame() == frame
+
+    def test_in_unit(self, vector: Vector):
+        assert vector.in_unit(Unit.length(Length.Unit.Foot)) is not None
+
+    def test_in_frame(self, vector: Vector):
+        assert vector.in_frame(Frame.ITRF(), Instant.J2000()) is not None
+
+    def test_to_string(self, vector: Vector):
+        assert vector.to_string() is not None