open-space-toolkit-mathematics 4.5.2__py310-none-manylinux2014_aarch64.whl → 4.5.4__py310-none-manylinux2014_aarch64.whl

ostk/mathematics/object.pyi

@@ -52,41 +52,199 @@ class RealInterval:
     __hash__: typing.ClassVar[None] = None
     @staticmethod
     def clip(intervals: list[RealInterval], clipping_interval: RealInterval) -> list[RealInterval]:
-        ...
+        """
+                        Clip a list of intervals with a clipping interval.
+        
+                        Args:
+                            intervals (list): List of intervals to clip.
+                            clipping_interval (RealInterval): The interval to clip with.
+        
+                        Returns:
+                            list: List of clipped intervals.
+        
+                        Example:
+                            >>> intervals = [RealInterval.closed(0.0, 2.0), RealInterval.closed(3.0, 5.0)]
+                            >>> clipping = RealInterval.closed(1.0, 4.0)
+                            >>> clipped = RealInterval.clip(intervals, clipping)
+        """
     @staticmethod
     def closed(lower_bound: ostk.core.type.Real, upper_bound: ostk.core.type.Real) -> RealInterval:
-        ...
+        """
+                        Create a closed interval [a, b].
+        
+                        Args:
+                            lower_bound (float): The lower bound (inclusive).
+                            upper_bound (float): The upper bound (inclusive).
+        
+                        Returns:
+                            RealInterval: A closed interval.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)  # [0, 1]
+                            >>> interval.contains(0.0)  # True
+                            >>> interval.contains(1.0)  # True
+        """
     @staticmethod
     def get_gaps(intervals: list[RealInterval], bound: RealInterval = ...) -> list[RealInterval]:
-        ...
+        """
+                        Find gaps between intervals in a list.
+        
+                        Args:
+                            intervals (list): List of intervals to find gaps between.
+                            bound (RealInterval, optional): Bounding interval to consider gaps within. Defaults to undefined.
+        
+                        Returns:
+                            list: List of intervals representing gaps.
+        
+                        Example:
+                            >>> intervals = [RealInterval.closed(0.0, 1.0), RealInterval.closed(2.0, 3.0)]
+                            >>> gaps = RealInterval.get_gaps(intervals)  # Gap from 1.0 to 2.0
+        """
     @staticmethod
     def half_open_left(lower_bound: ostk.core.type.Real, upper_bound: ostk.core.type.Real) -> RealInterval:
-        ...
+        """
+                        Create a half-open interval (a, b].
+        
+                        Args:
+                            lower_bound (float): The lower bound (exclusive).
+                            upper_bound (float): The upper bound (inclusive).
+        
+                        Returns:
+                            RealInterval: A half-open left interval.
+        
+                        Example:
+                            >>> interval = RealInterval.half_open_left(0.0, 1.0)  # (0, 1]
+                            >>> interval.contains(0.0)  # False
+                            >>> interval.contains(1.0)  # True
+        """
     @staticmethod
     def half_open_right(lower_bound: ostk.core.type.Real, upper_bound: ostk.core.type.Real) -> RealInterval:
-        ...
+        """
+                        Create a half-open interval [a, b).
+        
+                        Args:
+                            lower_bound (float): The lower bound (inclusive).
+                            upper_bound (float): The upper bound (exclusive).
+        
+                        Returns:
+                            RealInterval: A half-open right interval.
+        
+                        Example:
+                            >>> interval = RealInterval.half_open_right(0.0, 1.0)  # [0, 1)
+                            >>> interval.contains(0.0)  # True
+                            >>> interval.contains(1.0)  # False
+        """
     @staticmethod
     def logical_and(intervals_1: list[RealInterval], intervals_2: list[RealInterval]) -> list[RealInterval]:
-        ...
+        """
+                        Perform logical AND operation on two lists of intervals.
+        
+                        Args:
+                            intervals_1 (list): First list of intervals.
+                            intervals_2 (list): Second list of intervals.
+        
+                        Returns:
+                            list: List of intervals representing the intersection of both lists.
+        
+                        Example:
+                            >>> intervals1 = [RealInterval.closed(0.0, 2.0)]
+                            >>> intervals2 = [RealInterval.closed(1.0, 3.0)]
+                            >>> result = RealInterval.logical_and(intervals1, intervals2)  # [1.0, 2.0]
+        """
     @staticmethod
     def logical_or(intervals_1: list[RealInterval], intervals_2: list[RealInterval]) -> list[RealInterval]:
-        ...
+        """
+                        Perform logical OR operation on two lists of intervals.
+        
+                        Args:
+                            intervals_1 (list): First list of intervals.
+                            intervals_2 (list): Second list of intervals.
+        
+                        Returns:
+                            list: List of intervals representing the union of both lists.
+        
+                        Example:
+                            >>> intervals1 = [RealInterval.closed(0.0, 1.0)]
+                            >>> intervals2 = [RealInterval.closed(2.0, 3.0)]
+                            >>> result = RealInterval.logical_or(intervals1, intervals2)
+        """
     @staticmethod
     def merge(intervals: list[RealInterval]) -> list[RealInterval]:
-        ...
+        """
+                        Merge overlapping intervals in a list.
+        
+                        Args:
+                            intervals (list): List of intervals to merge.
+        
+                        Returns:
+                            list: List of merged intervals with no overlaps.
+        
+                        Example:
+                            >>> intervals = [RealInterval.closed(0.0, 2.0), RealInterval.closed(1.0, 3.0)]
+                            >>> merged = RealInterval.merge(intervals)  # [RealInterval.closed(0.0, 3.0)]
+        """
     @staticmethod
     def open(lower_bound: ostk.core.type.Real, upper_bound: ostk.core.type.Real) -> RealInterval:
-        ...
+        """
+                        Create an open interval (a, b).
+        
+                        Args:
+                            lower_bound (float): The lower bound (exclusive).
+                            upper_bound (float): The upper bound (exclusive).
+        
+                        Returns:
+                            RealInterval: An open interval.
+        
+                        Example:
+                            >>> interval = RealInterval.open(0.0, 1.0)  # (0, 1)
+                            >>> interval.contains(0.0)  # False
+                            >>> interval.contains(1.0)  # False
+                            >>> interval.contains(0.5)  # True
+        """
     @staticmethod
     def sort(intervals: list[RealInterval], by_lower_bound: bool = True, ascending: bool = True) -> list[RealInterval]:
-        ...
+        """
+                        Sort a list of intervals.
+        
+                        Args:
+                            intervals (list): List of intervals to sort.
+                            by_lower_bound (bool, optional): Sort by lower bound if True, upper bound if False. Defaults to True.
+                            ascending (bool, optional): Sort in ascending order if True, descending if False. Defaults to True.
+        
+                        Returns:
+                            list: Sorted list of intervals.
+        
+                        Example:
+                            >>> intervals = [RealInterval.closed(2.0, 3.0), RealInterval.closed(0.0, 1.0)]
+                            >>> sorted_intervals = RealInterval.sort(intervals)
+        """
     @staticmethod
     def undefined() -> RealInterval:
-        ...
+        """
+                        Create an undefined interval.
+        
+                        Returns:
+                            RealInterval: An undefined interval.
+        
+                        Example:
+                            >>> undefined_interval = RealInterval.undefined()
+                            >>> undefined_interval.is_defined()  # False
+        """
     def __eq__(self, arg0: RealInterval) -> bool:
         ...
     def __init__(self, lower_bound: ostk.core.type.Real, upper_bound: ostk.core.type.Real, type: typing.Any) -> None:
-        ...
+        """
+                        Create an interval with specified bounds and type.
+        
+                        Args:
+                            lower_bound (float): The lower bound of the interval.
+                            upper_bound (float): The upper bound of the interval.
+                            type (RealInterval.Type): The type of interval (Closed, Open, HalfOpenLeft, HalfOpenRight).
+        
+                        Example:
+                            >>> interval = RealInterval(0.0, 1.0, RealInterval.Type.Closed)  # [0, 1]
+                            >>> interval = RealInterval(0.0, 1.0, RealInterval.Type.Open)    # (0, 1)
+        """
     def __ne__(self, arg0: RealInterval) -> bool:
         ...
     def __repr__(self) -> str:
@@ -95,23 +253,135 @@ class RealInterval:
         ...
     @typing.overload
     def contains(self, real: ostk.core.type.Real) -> bool:
-        ...
+        """
+                        Check if the interval contains a real number.
+        
+                        Args:
+                            real (float): The real number to check.
+        
+                        Returns:
+                            bool: True if the interval contains the number, False otherwise.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)
+                            >>> interval.contains(0.5)  # True
+                            >>> interval.contains(1.5)  # False
+        """
     @typing.overload
     def contains(self, interval: RealInterval) -> bool:
-        ...
+        """
+                        Check if this interval contains another interval.
+        
+                        Args:
+                            interval (RealInterval): The interval to check containment for.
+        
+                        Returns:
+                            bool: True if this interval contains the other interval, False otherwise.
+        
+                        Example:
+                            >>> interval1 = RealInterval.closed(0.0, 2.0)
+                            >>> interval2 = RealInterval.closed(0.5, 1.5)
+                            >>> interval1.contains(interval2)  # True
+        """
     def get_intersection_with(self, interval: RealInterval) -> RealInterval:
-        ...
+        """
+                        Get the intersection of this interval with another interval.
+        
+                        Args:
+                            interval (RealInterval): The interval to intersect with.
+        
+                        Returns:
+                            RealInterval: The intersection interval, or undefined if no intersection.
+        
+                        Example:
+                            >>> interval1 = RealInterval.closed(0.0, 2.0)
+                            >>> interval2 = RealInterval.closed(1.0, 3.0)
+                            >>> intersection = interval1.get_intersection_with(interval2)
+                            >>> # intersection represents [1.0, 2.0]
+        """
     def get_lower_bound(self) -> ostk.core.type.Real:
-        ...
+        """
+                        Get the lower bound of the interval.
+        
+                        Returns:
+                            float: The lower bound value.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)
+                            >>> interval.get_lower_bound()  # 0.0
+        """
     def get_union_with(self, interval: RealInterval) -> RealInterval:
-        ...
+        """
+                        Get the union of this interval with another interval.
+        
+                        Args:
+                            interval (RealInterval): The interval to union with.
+        
+                        Returns:
+                            RealInterval: The union interval.
+        
+                        Example:
+                            >>> interval1 = RealInterval.closed(0.0, 1.0)
+                            >>> interval2 = RealInterval.closed(0.5, 2.0)
+                            >>> union = interval1.get_union_with(interval2)
+                            >>> # union represents [0.0, 2.0]
+        """
     def get_upper_bound(self) -> ostk.core.type.Real:
-        ...
+        """
+                        Get the upper bound of the interval.
+        
+                        Returns:
+                            float: The upper bound value.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)
+                            >>> interval.get_upper_bound()  # 1.0
+        """
     def intersects(self, interval: RealInterval) -> bool:
-        ...
+        """
+                        Check if this interval intersects with another interval.
+        
+                        Args:
+                            interval (RealInterval): The interval to check intersection with.
+        
+                        Returns:
+                            bool: True if intervals intersect, False otherwise.
+        
+                        Example:
+                            >>> interval1 = RealInterval.closed(0.0, 2.0)
+                            >>> interval2 = RealInterval.closed(1.0, 3.0)
+                            >>> interval1.intersects(interval2)  # True
+        """
     def is_defined(self) -> bool:
-        ...
+        """
+                        Check if the interval is defined.
+        
+                        Returns:
+                            bool: True if the interval is defined, False otherwise.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)
+                            >>> interval.is_defined()  # True
+        """
     def is_degenerate(self) -> bool:
-        ...
+        """
+                        Check if the interval is degenerate (single point).
+        
+                        Returns:
+                            bool: True if the interval represents a single point, False otherwise.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(1.0, 1.0)
+                            >>> interval.is_degenerate()  # True
+        """
     def to_string(self) -> ostk.core.type.String:
-        ...
+        """
+                        Convert the interval to a string representation.
+        
+                        Returns:
+                            str: String representation of the interval.
+        
+                        Example:
+                            >>> interval = RealInterval.closed(0.0, 1.0)
+                            >>> interval.to_string()  # "[0, 1]"
+        """

ostk/mathematics/solver.pyi

@@ -90,20 +90,76 @@ class NumericalSolver:
     __hash__: typing.ClassVar[None] = None
     @staticmethod
     def default() -> NumericalSolver:
-        ...
+        """
+                            Create a default numerical solver.
+        
+                            Returns:
+                                NumericalSolver: A solver with default settings.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> solver.is_defined()  # True
+        """
     @staticmethod
     def string_from_log_type(log_type: typing.Any) -> ostk.core.type.String:
-        ...
+        """
+                            Get string representation of a log type.
+        
+                            Args:
+                                log_type (NumericalSolver.LogType): The log type.
+        
+                            Returns:
+                                str: String representation of the log type.
+        
+                            Example:
+                                >>> NumericalSolver.string_from_log_type(NumericalSolver.LogType.NoLog)
+        """
     @staticmethod
     def string_from_stepper_type(stepper_type: typing.Any) -> ostk.core.type.String:
-        ...
+        """
+                            Get string representation of a stepper type.
+        
+                            Args:
+                                stepper_type (NumericalSolver.StepperType): The stepper type.
+        
+                            Returns:
+                                str: String representation of the stepper type.
+        
+                            Example:
+                                >>> NumericalSolver.string_from_stepper_type(NumericalSolver.StepperType.RungeKutta4)
+        """
     @staticmethod
     def undefined() -> NumericalSolver:
-        ...
+        """
+                            Create an undefined numerical solver.
+        
+                            Returns:
+                                NumericalSolver: An undefined solver.
+        
+                            Example:
+                                >>> solver = NumericalSolver.undefined()
+                                >>> solver.is_defined()  # False
+        """
     def __eq__(self, arg0: NumericalSolver) -> bool:
         ...
     def __init__(self, log_type: typing.Any, stepper_type: typing.Any, time_step: ostk.core.type.Real, relative_tolerance: ostk.core.type.Real, absolute_tolerance: ostk.core.type.Real) -> None:
-        ...
+        """
+                            Create a numerical solver with specified parameters.
+        
+                            Args:
+                                log_type (NumericalSolver.LogType): The logging type for the solver.
+                                stepper_type (NumericalSolver.StepperType): The stepper algorithm to use.
+                                time_step (float): The time step for integration.
+                                relative_tolerance (float): The relative tolerance for adaptive steppers.
+                                absolute_tolerance (float): The absolute tolerance for adaptive steppers.
+        
+                            Example:
+                                >>> solver = NumericalSolver(
+                                ...     NumericalSolver.LogType.NoLog,
+                                ...     NumericalSolver.StepperType.RungeKutta4,
+                                ...     1.0, 1e-12, 1e-12
+                                ... )
+        """
     def __ne__(self, arg0: NumericalSolver) -> bool:
         ...
     def __repr__(self) -> str:
@@ -111,28 +167,176 @@ class NumericalSolver:
     def __str__(self) -> str:
         ...
     def get_absolute_tolerance(self) -> ostk.core.type.Real:
-        ...
+        """
+                            Get the absolute tolerance of the solver.
+        
+                            Returns:
+                                float: The absolute tolerance value.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> abs_tol = solver.get_absolute_tolerance()
+        """
     def get_log_type(self) -> ...:
-        ...
+        """
+                            Get the log type of the solver.
+        
+                            Returns:
+                                NumericalSolver.LogType: The log type.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> log_type = solver.get_log_type()
+        """
     def get_observed_state_vectors(self) -> list[tuple[numpy.ndarray[numpy.float64[m, 1]], float]]:
-        ...
+        """
+                            Get the observed state vectors from the last integration.
+        
+                            Returns:
+                                list: List of observed state vectors during integration.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> # After performing integration...
+                                >>> states = solver.get_observed_state_vectors()
+        """
     def get_relative_tolerance(self) -> ostk.core.type.Real:
-        ...
+        """
+                            Get the relative tolerance of the solver.
+        
+                            Returns:
+                                float: The relative tolerance value.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> rel_tol = solver.get_relative_tolerance()
+        """
     def get_stepper_type(self) -> ...:
-        ...
+        """
+                            Get the stepper type of the solver.
+        
+                            Returns:
+                                NumericalSolver.StepperType: The stepper type.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> stepper_type = solver.get_stepper_type()
+        """
     def get_time_step(self) -> ostk.core.type.Real:
-        ...
+        """
+                            Get the time step of the solver.
+        
+                            Returns:
+                                float: The time step value.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> time_step = solver.get_time_step()
+        """
     @typing.overload
     def integrate_duration(self, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: ostk.core.type.Real, arg2: typing.Any) -> tuple[numpy.ndarray[numpy.float64[m, 1]], float]:
-        ...
+        """
+                            Integrate a system of differential equations for a specified duration.
+        
+                            Args:
+                                state_vector (StateVector): Initial state vector.
+                                duration_in_seconds (float): Integration duration in seconds.
+                                system_of_equations (callable): Function defining the system of ODEs.
+                                                               Signature: f(x, dxdt, t) -> StateVector
+        
+                            Returns:
+                                StateVector: Final state vector after integration.
+        
+                            Example:
+                                >>> def equations(x, dxdt, t):
+                                ...     dxdt[0] = x[1]  # dx/dt = v
+                                ...     dxdt[1] = -x[0]  # dv/dt = -x (harmonic oscillator)
+                                ...     return dxdt
+                                >>> solver = NumericalSolver.default()
+                                >>> initial_state = [1.0, 0.0]  # x=1, v=0
+                                >>> final_state = solver.integrate_duration(initial_state, 1.0, equations)
+        """
     @typing.overload
     def integrate_duration(self, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: list[ostk.core.type.Real], arg2: typing.Any) -> list[tuple[numpy.ndarray[numpy.float64[m, 1]], float]]:
-        ...
+        """
+                            Integrate a system of differential equations at multiple duration points.
+        
+                            Args:
+                                state_vector (StateVector): Initial state vector.
+                                duration_array (list): Array of duration values in seconds.
+                                system_of_equations (callable): Function defining the system of ODEs.
+                                                               Signature: f(x, dxdt, t) -> StateVector
+        
+                            Returns:
+                                list: State vectors at each duration point.
+        
+                            Example:
+                                >>> def equations(x, dxdt, t):
+                                ...     dxdt[0] = x[1]  # dx/dt = v
+                                ...     dxdt[1] = -x[0]  # dv/dt = -x (harmonic oscillator)
+                                ...     return dxdt
+                                >>> solver = NumericalSolver.default()
+                                >>> initial_state = [1.0, 0.0]
+                                >>> durations = [0.5, 1.0, 1.5]
+                                >>> states = solver.integrate_duration(initial_state, durations, equations)
+        """
     @typing.overload
     def integrate_time(self, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: ostk.core.type.Real, arg2: ostk.core.type.Real, arg3: typing.Any) -> tuple[numpy.ndarray[numpy.float64[m, 1]], float]:
-        ...
+        """
+                            Integrate a system of differential equations from start to end time.
+        
+                            Args:
+                                state_vector (StateVector): Initial state vector.
+                                start_time (float): Integration start time.
+                                end_time (float): Integration end time.
+                                system_of_equations (callable): Function defining the system of ODEs.
+                                                               Signature: f(x, dxdt, t) -> StateVector
+        
+                            Returns:
+                                StateVector: Final state vector at end time.
+        
+                            Example:
+                                >>> def equations(x, dxdt, t):
+                                ...     dxdt[0] = x[1]  # dx/dt = v
+                                ...     dxdt[1] = -x[0]  # dv/dt = -x (harmonic oscillator)
+                                ...     return dxdt
+                                >>> solver = NumericalSolver.default()
+                                >>> initial_state = [1.0, 0.0]
+                                >>> final_state = solver.integrate_time(initial_state, 0.0, 2.0, equations)
+        """
     @typing.overload
     def integrate_time(self, arg0: numpy.ndarray[numpy.float64[m, 1]], arg1: ostk.core.type.Real, arg2: list[ostk.core.type.Real], arg3: typing.Any) -> list[tuple[numpy.ndarray[numpy.float64[m, 1]], float]]:
-        ...
+        """
+                            Integrate a system of differential equations at specified time points.
+        
+                            Args:
+                                state_vector (StateVector): Initial state vector.
+                                start_time (float): Integration start time.
+                                time_array (list): Array of time points to evaluate at.
+                                system_of_equations (callable): Function defining the system of ODEs.
+                                                               Signature: f(x, dxdt, t) -> StateVector
+        
+                            Returns:
+                                list: State vectors at each time point.
+        
+                            Example:
+                                >>> def equations(x, dxdt, t):
+                                ...     dxdt[0] = x[1]  # dx/dt = v
+                                ...     dxdt[1] = -x[0]  # dv/dt = -x (harmonic oscillator)
+                                ...     return dxdt
+                                >>> solver = NumericalSolver.default()
+                                >>> initial_state = [1.0, 0.0]
+                                >>> times = [0.5, 1.0, 1.5, 2.0]
+                                >>> states = solver.integrate_time(initial_state, 0.0, times, equations)
+        """
     def is_defined(self) -> bool:
-        ...
+        """
+                            Check if the numerical solver is defined.
+        
+                            Returns:
+                                bool: True if the solver is defined, False otherwise.
+        
+                            Example:
+                                >>> solver = NumericalSolver.default()
+                                >>> solver.is_defined()  # True
+        """