refactor: apply MR suggestions

Author: Pau Hebrero

bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/Flight/Profile.cpp

@@ -191,7 +191,7 @@ inline void OpenSpaceToolkitAstrodynamicsPy_Flight_Profile(pybind11::module& aMo
                 Constructor.
 
                 Args:
-                    orientation_profile (list[Tuple[Instant, Vector3d]]): The orientation profile.
+                    orientation_profile (list[tuple[Instant, Vector3d]]): The orientation profile.
                     axis (Profile.Axis): The axis.
                     anti_direction (bool): True if the direction is flipped, False otherwise. Defaults to False.
             )doc",

bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw.cpp

@@ -3,8 +3,8 @@
 #include <OpenSpaceToolkit/Astrodynamics/GuidanceLaw.hpp>
 
 #include <OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/ConstantThrust.cpp>
+#include <OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/HeterogeneousGuidanceLaw.cpp>
 #include <OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/QLaw.cpp>
-#include <OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/SequentialGuidanceLaw.cpp>
 
 using namespace pybind11;
 
@@ -121,5 +121,5 @@ void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw(pybind11::module& aModule)
     // Add objects to "guidance_law" submodule
     OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_ConstantThrust(guidance_law);
     OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_QLaw(guidance_law);
-    OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(guidance_law);
+    OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_HeterogeneousGuidanceLaw(guidance_law);
 }

bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/SequentialGuidanceLaw.cpp renamed to bindings/python/src/OpenSpaceToolkitAstrodynamicsPy/GuidanceLaw/HeterogeneousGuidanceLaw.cpp

@@ -1,13 +1,12 @@
 /// Apache License 2.0
 
-#include <OpenSpaceToolkit/Astrodynamics/GuidanceLaw/SequentialGuidanceLaw.hpp>
+#include <OpenSpaceToolkit/Astrodynamics/GuidanceLaw/HeterogeneousGuidanceLaw.hpp>
 
 using namespace pybind11;
 
 using ostk::core::container::Array;
-using ostk::core::type::Real;
+using ostk::core::container::Pair;
 using ostk::core::type::Shared;
-using ostk::core::type::String;
 
 using ostk::mathematics::object::Vector3d;
 
@@ -16,13 +15,13 @@ using ostk::physics::time::Instant;
 using ostk::physics::time::Interval;
 
 using ostk::astrodynamics::GuidanceLaw;
-using ostk::astrodynamics::guidancelaw::SequentialGuidanceLaw;
+using ostk::astrodynamics::guidancelaw::HeterogeneousGuidanceLaw;
 
-inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(pybind11::module& aModule)
+inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_HeterogeneousGuidanceLaw(pybind11::module& aModule)
 {
-    class_<SequentialGuidanceLaw, GuidanceLaw, Shared<SequentialGuidanceLaw>>(
+    class_<HeterogeneousGuidanceLaw, GuidanceLaw, Shared<HeterogeneousGuidanceLaw>>(
         aModule,
-        "SequentialGuidanceLaw",
+        "HeterogeneousGuidanceLaw",
         R"doc(
             A guidance law that sequences multiple guidance laws over specific time intervals.
             
@@ -34,13 +33,13 @@ inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(py
     )
 
         .def(
-            init<const Array<Tuple<Shared<GuidanceLaw>, Interval>>&>(),
-            arg_v("guidance_laws_with_intervals", Array<Tuple<Shared<GuidanceLaw>, Interval>>::Empty(), "[]"),
+            init<const Array<Pair<Shared<GuidanceLaw>, Interval>>&>(),
+            arg_v("guidance_laws_with_intervals", Array<Pair<Shared<GuidanceLaw>, Interval>>::Empty(), "[]"),
             R"doc(
                 Constructor.
 
                 Args:
-                    guidance_laws_with_intervals (List[Tuple[GuidanceLaw, Interval]], optional): Array of tuples containing the guidance laws and their corresponding intervals. Defaults to empty array.
+                    guidance_laws_with_intervals (list[tuple[GuidanceLaw, Interval]], optional): Array of tuples containing the guidance laws and their corresponding intervals. Defaults to empty array.
 
                 Raises:
                     RuntimeError: If any interval is undefined, if the guidance law is null or if the interval intersects with an existing interval.
@@ -49,18 +48,18 @@ inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(py
 
         .def(
             "get_guidance_laws_with_intervals",
-            &SequentialGuidanceLaw::getGuidanceLawsWithIntervals,
+            &HeterogeneousGuidanceLaw::getGuidanceLawsWithIntervals,
             R"doc(
                 Get the guidance laws with their corresponding intervals.
 
                 Returns:
-                    List[Tuple[GuidanceLaw, Interval]]: Array of tuples containing the guidance laws and their corresponding intervals.
+                    list[tuple[GuidanceLaw, Interval]]: Array of tuples containing the guidance laws and their corresponding intervals.
             )doc"
         )
 
         .def(
             "add_guidance_law",
-            &SequentialGuidanceLaw::addGuidanceLaw,
+            &HeterogeneousGuidanceLaw::addGuidanceLaw,
             arg("guidance_law"),
             arg("interval"),
             R"doc(
@@ -77,7 +76,7 @@ inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(py
 
         .def(
             "calculate_thrust_acceleration_at",
-            &SequentialGuidanceLaw::calculateThrustAccelerationAt,
+            &HeterogeneousGuidanceLaw::calculateThrustAccelerationAt,
             arg("instant"),
             arg("position_coordinates"),
             arg("velocity_coordinates"),
@@ -98,8 +97,8 @@ inline void OpenSpaceToolkitAstrodynamicsPy_GuidanceLaw_SequentialGuidanceLaw(py
             )doc"
         )
 
-        .def("__str__", &(shiftToString<SequentialGuidanceLaw>))
-        .def("__repr__", &(shiftToString<SequentialGuidanceLaw>))
+        .def("__str__", &(shiftToString<HeterogeneousGuidanceLaw>))
+        .def("__repr__", &(shiftToString<HeterogeneousGuidanceLaw>))
 
         ;
 }

bindings/python/test/guidance_law/test_sequential_guidance_law.py renamed to bindings/python/test/guidance_law/test_heterogeneous_guidance_law.py

@@ -9,7 +9,7 @@
 from ostk.physics.time import Duration
 from ostk.physics.time import Interval
 from ostk.astrodynamics import GuidanceLaw
-from ostk.astrodynamics.guidance_law import SequentialGuidanceLaw
+from ostk.astrodynamics.guidance_law import HeterogeneousGuidanceLaw
 
 
 @pytest.fixture
@@ -75,37 +75,37 @@ def calculate_thrust_acceleration_at(
 
 
 @pytest.fixture
-def sequential_guidance_law(
+def heterogeneous_guidance_law(
     interval_1: Interval,
     guidance_law_1: GuidanceLaw,
     interval_2: Interval,
     guidance_law_2: GuidanceLaw,
-) -> SequentialGuidanceLaw:
-    return SequentialGuidanceLaw(
+) -> HeterogeneousGuidanceLaw:
+    return HeterogeneousGuidanceLaw(
         guidance_laws_with_intervals=[
             (guidance_law_1, interval_1),
             (guidance_law_2, interval_2),
         ],
     )
 
 
-class TestSequentialGuidanceLaw:
+class TestHeterogeneousGuidanceLaw:
     def test_constructor_and_getters(
         self,
         interval_1: Interval,
         guidance_law_1: GuidanceLaw,
         interval_2: Interval,
         guidance_law_2: GuidanceLaw,
     ):
-        sequential_guidance_law = SequentialGuidanceLaw(
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw(
             guidance_laws_with_intervals=[
                 (guidance_law_1, interval_1),
                 (guidance_law_2, interval_2),
             ],
         )
-        assert sequential_guidance_law is not None
-        assert isinstance(sequential_guidance_law, SequentialGuidanceLaw)
-        assert sequential_guidance_law.get_guidance_laws_with_intervals() == [
+        assert heterogeneous_guidance_law is not None
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
             (guidance_law_1, interval_1),
             (guidance_law_2, interval_2),
         ]
@@ -117,18 +117,18 @@ def test_add_guidance_law(
         interval_2: Interval,
         guidance_law_2: GuidanceLaw,
     ):
-        sequential_guidance_law = SequentialGuidanceLaw()
+        heterogeneous_guidance_law = HeterogeneousGuidanceLaw()
 
-        assert isinstance(sequential_guidance_law, SequentialGuidanceLaw)
-        assert sequential_guidance_law.get_guidance_laws_with_intervals() == []
+        assert isinstance(heterogeneous_guidance_law, HeterogeneousGuidanceLaw)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == []
 
-        sequential_guidance_law.add_guidance_law(guidance_law_1, interval_1)
-        assert sequential_guidance_law.get_guidance_laws_with_intervals() == [
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_1, interval_1)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
             (guidance_law_1, interval_1),
         ]
 
-        sequential_guidance_law.add_guidance_law(guidance_law_2, interval_2)
-        assert sequential_guidance_law.get_guidance_laws_with_intervals() == [
+        heterogeneous_guidance_law.add_guidance_law(guidance_law_2, interval_2)
+        assert heterogeneous_guidance_law.get_guidance_laws_with_intervals() == [
             (guidance_law_1, interval_1),
             (guidance_law_2, interval_2),
         ]
@@ -148,12 +148,12 @@ def test_add_guidance_law(
     )
     def test_calculate_thrust_acceleration_at(
         self,
-        sequential_guidance_law: SequentialGuidanceLaw,
+        heterogeneous_guidance_law: HeterogeneousGuidanceLaw,
         instant: Instant,
         expected_thrust_acceleration: np.array,
     ):
         assert np.array_equal(
-            sequential_guidance_law.calculate_thrust_acceleration_at(
+            heterogeneous_guidance_law.calculate_thrust_acceleration_at(
                 instant=instant,
                 position_coordinates=np.array([0.0, 0.0, 0.0]),
                 velocity_coordinates=np.array([0.0, 0.0, 0.0]),

include/OpenSpaceToolkit/Astrodynamics/GuidanceLaw/SequentialGuidanceLaw.hpp renamed to include/OpenSpaceToolkit/Astrodynamics/GuidanceLaw/HeterogeneousGuidanceLaw.hpp

@@ -1,10 +1,10 @@
 /// Apache License 2.0
 
-#ifndef __OpenSpaceToolkit_Astrodynamics_GuidanceLaw_SequentialGuidanceLaw__
-#define __OpenSpaceToolkit_Astrodynamics_GuidanceLaw_SequentialGuidanceLaw__
+#ifndef __OpenSpaceToolkit_Astrodynamics_GuidanceLaw_HeterogeneousGuidanceLaw__
+#define __OpenSpaceToolkit_Astrodynamics_GuidanceLaw_HeterogeneousGuidanceLaw__
 
 #include <OpenSpaceToolkit/Core/Container/Array.hpp>
-#include <OpenSpaceToolkit/Core/Container/Tuple.hpp>
+#include <OpenSpaceToolkit/Core/Container/Pair.hpp>
 #include <OpenSpaceToolkit/Core/Type/Real.hpp>
 #include <OpenSpaceToolkit/Core/Type/Shared.hpp>
 
@@ -23,7 +23,7 @@ namespace guidancelaw
 {
 
 using ostk::core::container::Array;
-using ostk::core::container::Tuple;
+using ostk::core::container::Pair;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 
@@ -33,27 +33,27 @@ using ostk::physics::coordinate::Frame;
 using ostk::physics::time::Instant;
 using ostk::physics::time::Interval;
 
-/// @brief    The Sequential Guidance Law encompasses a sequence of one or more guidance laws to be used over specific
-/// time intervals.
+/// @brief    The Heterogeneous Guidance Law encompasses a sequence of one or more guidance laws to be used over
+/// specific time intervals.
 ///    At each point in time, the applicable guidance law is selected and used to calculate the thrust acceleration.
 ///    Guidance laws don't need to be contiguous, and can be added in any order. If the instant does not fall within any
 ///    of the intervals, the thrust acceleration is zero. The guidance law intervals must not intersect each other.
-class SequentialGuidanceLaw : public GuidanceLaw
+class HeterogeneousGuidanceLaw : public GuidanceLaw
 {
    public:
     /// @brief Default constructor
     ///
     /// @param aGuidanceLawWithIntervalArray Array of tuples containing the guidance law and their corresponding
     /// interval. Defaults to empty.
-    SequentialGuidanceLaw(
-        const Array<Tuple<Shared<GuidanceLaw>, Interval>>& aGuidanceLawWithIntervalArray =
-            Array<Tuple<Shared<GuidanceLaw>, Interval>>::Empty()
+    HeterogeneousGuidanceLaw(
+        const Array<Pair<Shared<GuidanceLaw>, Interval>>& aGuidanceLawWithIntervalArray =
+            Array<Pair<Shared<GuidanceLaw>, Interval>>::Empty()
     );
 
     /// @brief Get guidance laws with their corresponding intervals
     ///
     /// @return Array of tuples containing the guidance laws and their corresponding intervals
-    Array<Tuple<Shared<GuidanceLaw>, Interval>> getGuidanceLawsWithIntervals() const;
+    Array<Pair<Shared<GuidanceLaw>, Interval>> getGuidanceLawsWithIntervals() const;
 
     /// @brief Add a guidance law with its corresponding interval
     ///

src/OpenSpaceToolkit/Astrodynamics/GuidanceLaw/SequentialGuidanceLaw.cpp renamed to src/OpenSpaceToolkit/Astrodynamics/GuidanceLaw/HeterogeneousGuidanceLaw.cpp

@@ -4,7 +4,7 @@
 #include <OpenSpaceToolkit/Core/Type/Size.hpp>
 #include <OpenSpaceToolkit/Core/Utility.hpp>
 
-#include <OpenSpaceToolkit/Astrodynamics/GuidanceLaw/SequentialGuidanceLaw.hpp>
+#include <OpenSpaceToolkit/Astrodynamics/GuidanceLaw/HeterogeneousGuidanceLaw.hpp>
 
 namespace ostk
 {
@@ -14,7 +14,7 @@ namespace guidancelaw
 {
 
 using ostk::core::container::Array;
-using ostk::core::container::Tuple;
+using ostk::core::container::Pair;
 using ostk::core::type::Real;
 using ostk::core::type::Shared;
 using ostk::core::type::Size;
@@ -27,31 +27,31 @@ using ostk::physics::time::Interval;
 
 using ostk::astrodynamics::GuidanceLaw;
 
-SequentialGuidanceLaw::SequentialGuidanceLaw(
-    const Array<Tuple<Shared<GuidanceLaw>, Interval>>& aGuidanceLawWithIntervalArray
+HeterogeneousGuidanceLaw::HeterogeneousGuidanceLaw(
+    const Array<Pair<Shared<GuidanceLaw>, Interval>>& aGuidanceLawWithIntervalArray
 )
-    : GuidanceLaw("Sequential Guidance Law"),
+    : GuidanceLaw("Heterogeneous Guidance Law"),
       intervals_(Array<Interval>::Empty()),
       guidanceLaws_(Array<Shared<GuidanceLaw>>::Empty())
 {
-    for (const Tuple<Shared<GuidanceLaw>, Interval>& guidanceLawWithInterval : aGuidanceLawWithIntervalArray)
+    for (const Pair<Shared<GuidanceLaw>, Interval>& guidanceLawWithInterval : aGuidanceLawWithIntervalArray)
     {
-        this->addGuidanceLaw(std::get<0>(guidanceLawWithInterval), std::get<1>(guidanceLawWithInterval));
+        this->addGuidanceLaw(guidanceLawWithInterval.first, guidanceLawWithInterval.second);
     }
 }
 
-Array<Tuple<Shared<GuidanceLaw>, Interval>> SequentialGuidanceLaw::getGuidanceLawsWithIntervals() const
+Array<Pair<Shared<GuidanceLaw>, Interval>> HeterogeneousGuidanceLaw::getGuidanceLawsWithIntervals() const
 {
-    Array<Tuple<Shared<GuidanceLaw>, Interval>> guidanceLawsWithIntervals =
-        Array<Tuple<Shared<GuidanceLaw>, Interval>>::Empty();
+    Array<Pair<Shared<GuidanceLaw>, Interval>> guidanceLawsWithIntervals =
+        Array<Pair<Shared<GuidanceLaw>, Interval>>::Empty();
     for (Size i = 0; i < intervals_.getSize(); ++i)
     {
-        guidanceLawsWithIntervals.add(Tuple<Shared<GuidanceLaw>, Interval>(guidanceLaws_[i], intervals_[i]));
+        guidanceLawsWithIntervals.add(Pair<Shared<GuidanceLaw>, Interval>(guidanceLaws_[i], intervals_[i]));
     }
     return guidanceLawsWithIntervals;
 }
 
-void SequentialGuidanceLaw::addGuidanceLaw(const Shared<GuidanceLaw>& aGuidanceLawSPtr, const Interval& anInterval)
+void HeterogeneousGuidanceLaw::addGuidanceLaw(const Shared<GuidanceLaw>& aGuidanceLawSPtr, const Interval& anInterval)
 {
     if (aGuidanceLawSPtr == nullptr)
     {
@@ -77,7 +77,7 @@ void SequentialGuidanceLaw::addGuidanceLaw(const Shared<GuidanceLaw>& aGuidanceL
     guidanceLaws_.add(aGuidanceLawSPtr);
 }
 
-Vector3d SequentialGuidanceLaw::calculateThrustAccelerationAt(
+Vector3d HeterogeneousGuidanceLaw::calculateThrustAccelerationAt(
     const Instant& anInstant,
     const Vector3d& aPositionCoordinates,
     const Vector3d& aVelocityCoordinates,