open-space-toolkit-mathematics 4.5.3__py311-none-manylinux2014_x86_64.whl → 4.5.4__py311-none-manylinux2014_x86_64.whl

{open_space_toolkit_mathematics-4.5.3.dist-info → open_space_toolkit_mathematics-4.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: open-space-toolkit-mathematics
-Version: 4.5.3
+Version: 4.5.4
 Summary: Geometry, curve fitting, optimization.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_mathematics-4.5.3.dist-info → open_space_toolkit_mathematics-4.5.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/mathematics/OpenSpaceToolkitMathematicsPy.cpython-311-x86_64-linux-gnu.so,sha256=iHJhqnv5C0Lq6L-80BGyiiTfsI6wGnnl_U7cmdqO60E,1775456
+ostk/mathematics/OpenSpaceToolkitMathematicsPy.cpython-311-x86_64-linux-gnu.so,sha256=Z6nlzuL8l68R9dmSD1Zk2ltCV226WqnFeBXgPQricRA,2271088
 ostk/mathematics/__init__.py,sha256=U81I6jh2hIPyuT4dtZjNcLi-CQ8yXIvtFn32tVK1YCY,92
 ostk/mathematics/__init__.pyi,sha256=J_InNBNyrZgyfVQ-r8PVZq37Wb9kM0acE4BZW2Jwo14,484
-ostk/mathematics/libopen-space-toolkit-mathematics.so.4,sha256=l8-OWPyou_STtXoOvQfqdtPYgEHCheiP4-85ERZhuUs,91672408
-ostk/mathematics/object.pyi,sha256=1EiliU2CC4y1wNHzK9VRCUVapd5tENdPbRvdQQil5hE,4177
-ostk/mathematics/solver.pyi,sha256=hlbvpJMw3YhgvzhxluDMnh3FhBsBmpddBzcYDfWdIiQ,5362
-ostk/mathematics/curve_fitting/__init__.pyi,sha256=OPDQN2eI7OkZ_kveRhsrdTUEFqXXuT5rMPn1qEgWTmE,2275
-ostk/mathematics/curve_fitting/interpolator.pyi,sha256=vU07Nn98zlI52LPnODRHGDRR9hL3LJ6hllj4I5pJh_E,2237
-ostk/mathematics/geometry/__init__.pyi,sha256=HwLUyaE_W-iNG_vsLkfg1b4-lKFmfo3NriXF6OoUF9c,5472
-ostk/mathematics/geometry/d2/__init__.pyi,sha256=2Revm1uTUsiCadyhybC4dm5Wm5Hu4J7srZK35XIPjio,9473
-ostk/mathematics/geometry/d2/object.pyi,sha256=D4peKQnoiORGnWNgYbkbWWayxHDsUnH3-cieHZFHj0E,12102
-ostk/mathematics/geometry/d3/__init__.pyi,sha256=NUg6ul3JV4l1NJbE2M5RjzzGzQEEF2QgcGNL_mkJDAU,10293
-ostk/mathematics/geometry/d3/object.pyi,sha256=XM6O1svrhoiugdSGfkPhSaxI-CB7RAAP_RsIqsodIoE,24770
+ostk/mathematics/libopen-space-toolkit-mathematics.so.4,sha256=bbMIUEJE6yug3B5T8JgHV8GwZaNRS_9l6yPQ1opTyvQ,91672408
+ostk/mathematics/object.pyi,sha256=LvzjdseOx-IFv9viLEk-HXZ0GvEiERm6IbACHsVlsIk,16911
+ostk/mathematics/solver.pyi,sha256=65dIAcfMVhWL-32ZeZI_Mb5VRqpDcjLkvrQElQZ04Ws,16067
+ostk/mathematics/curve_fitting/__init__.pyi,sha256=IwJimnlynre4O-6tuIOC_t0kYEWTHQGMN4K9e6nGOO0,6436
+ostk/mathematics/curve_fitting/interpolator.pyi,sha256=Pi50YICu9h8mCl9xRB2-OcsdI6NpGF-BnnqkePeHF6g,10800
+ostk/mathematics/geometry/__init__.pyi,sha256=MDlOaEflUrXapczgfBoVCNJfDmKshUqle_reFyqG8mU,19131
+ostk/mathematics/geometry/d2/__init__.pyi,sha256=N9AEvpz3sLOOYdCK3UrvpcbVnVzY9tRbiM1HBSsc3K4,32839
+ostk/mathematics/geometry/d2/object.pyi,sha256=2RCR6SY12bc0daKS7lfX6wspQYR-z6m7AOEwpH0QrdY,77633
+ostk/mathematics/geometry/d3/__init__.pyi,sha256=ivpeJQdCqEonp6nzEe6ttRz1Bd1iUD3OvceiUXpVIyk,39850
+ostk/mathematics/geometry/d3/object.pyi,sha256=5xN55Dy_nLlUwOI1vxl7-iVnRWtY5SErEF6fU8BXcZA,160470
 ostk/mathematics/geometry/d3/transformation/__init__.pyi,sha256=wjoTgfldZsg2a26-4iRZd_FyMFFWRYa2FfQmm55-4b0,81
-ostk/mathematics/geometry/d3/transformation/rotation.pyi,sha256=zG2pNzXlPlbRrUmkU5kmxPF0U01djhzYcOE1-biQPUI,13829
+ostk/mathematics/geometry/d3/transformation/rotation.pyi,sha256=qGrVLf5ZD9vajuCidEJ2WUCp6FKhXaWdqCLjXJCmpgM,54986
 ostk/mathematics/test/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/mathematics/test/test_object.py,sha256=WtksTu9zz8_UNkQYKLO64nNBFDBkRWM_DXFuAWTdKUM,1027
 ostk/mathematics/test/curve_fitting/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
@@ -61,8 +61,8 @@ ostk/mathematics/test/object/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-
 ostk/mathematics/test/object/test_interval.py,sha256=rf7tL-m76inO18rzxopkWrk-cSjKhoN5xXek6e53wAU,21708
 ostk/mathematics/test/object/test_vector.py,sha256=5MG3s8vhgoGKAIc5GzswlZObyIrJDIPNtsEd5wNORPU,76
 ostk/mathematics/test/solver/test_numerical_solver.py,sha256=NS9XS6Z2dBzeKnUBiIflObGzd5DM1KVAoH1SBd3DXDc,5700
-open_space_toolkit_mathematics-4.5.3.dist-info/METADATA,sha256=n_cGPcHG_D7lTh_nJVEY618k3BJAYJLKZ0uoQnf6210,1804
-open_space_toolkit_mathematics-4.5.3.dist-info/WHEEL,sha256=TGDbqQQZHBKkiqIWZs35YdYV5yssI9IDMgO6_kbBT10,110
-open_space_toolkit_mathematics-4.5.3.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_mathematics-4.5.3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_mathematics-4.5.3.dist-info/RECORD,,
+open_space_toolkit_mathematics-4.5.4.dist-info/METADATA,sha256=aOu9a6lgBpc0qYUcVQlQLYZ5gKrpWGcZ8jzqOaFsLsE,1804
+open_space_toolkit_mathematics-4.5.4.dist-info/WHEEL,sha256=TGDbqQQZHBKkiqIWZs35YdYV5yssI9IDMgO6_kbBT10,110
+open_space_toolkit_mathematics-4.5.4.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_mathematics-4.5.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_mathematics-4.5.4.dist-info/RECORD,,

ostk/mathematics/curve_fitting/__init__.pyi

@@ -46,20 +46,110 @@ class Interpolator:
             ...
     @staticmethod
     def generate_interpolator(interpolation_type: Interpolator.Type, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> Interpolator:
-        ...
+        """
+                        Generate an interpolator of specified type with data points.
+        
+                        Args:
+                            interpolation_type (Interpolator.Type): The type of interpolation.
+                            x (np.array): The x-coordinates of data points.
+                            y (np.array): The y-coordinates of data points.
+        
+                        Returns:
+                            Interpolator: The created interpolator.
+        
+                        Example:
+                            >>> x = np.array([0.0, 1.0, 2.0])
+                            >>> y = np.array([0.0, 2.0, 4.0])
+                            >>> interpolator = Interpolator.generate_interpolator(
+                            ...     Interpolator.Type.CubicSpline, x, y
+                            ... )
+        """
     def __init__(self, interpolation_type: Interpolator.Type) -> None:
-        ...
+        """
+                        Create an interpolator of specified type.
+        
+                        Args:
+                            interpolation_type (Interpolator.Type): The type of interpolation method.
+        
+                        Example:
+                            >>> interpolator = Interpolator(Interpolator.Type.Linear)
+        """
     @typing.overload
     def compute_derivative(self, x: float) -> float:
-        ...
+        """
+                        Compute the derivative of the interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to compute derivative at.
+        
+                        Returns:
+                            float: The derivative value.
+        
+                        Example:
+                            >>> interpolator = Interpolator.generate_interpolator(
+                            ...     Interpolator.Type.Linear, [0.0, 1.0], [0.0, 2.0]
+                            ... )
+                            >>> derivative = interpolator.compute_derivative(0.5)  # 2.0
+        """
     @typing.overload
     def compute_derivative(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Compute the derivative of the interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to compute derivatives at.
+        
+                        Returns:
+                            (np.array): The derivative values.
+        
+                        Example:
+                            >>> interpolator = Interpolator.generate_interpolator(
+                            ...     Interpolator.Type.Linear, [0.0, 1.0], [0.0, 2.0]
+                            ... )
+                            >>> derivatives = interpolator.compute_derivative([0.2, 0.8])
+        """
     @typing.overload
     def evaluate(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Evaluate the interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to evaluate at.
+        
+                        Returns:
+                            (np.array): The interpolated y-values.
+        
+                        Example:
+                            >>> interpolator = Interpolator.generate_interpolator(
+                            ...     Interpolator.Type.Linear, [0.0, 1.0], [0.0, 2.0]
+                            ... )
+                            >>> result = interpolator.evaluate([0.5, 1.5])
+        """
     @typing.overload
     def evaluate(self, x: float) -> float:
-        ...
+        """
+                        Evaluate the interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to evaluate at.
+        
+                        Returns:
+                            float: The interpolated y-value.
+        
+                        Example:
+                            >>> interpolator = Interpolator.generate_interpolator(
+                            ...     Interpolator.Type.Linear, [0.0, 1.0], [0.0, 2.0]
+                            ... )
+                            >>> result = interpolator.evaluate(0.5)  # 1.0
+        """
     def get_interpolation_type(self) -> Interpolator.Type:
-        ...
+        """
+                        Get the interpolation type of this interpolator.
+        
+                        Returns:
+                            Interpolator.Type: The interpolation type.
+        
+                        Example:
+                            >>> interpolator = Interpolator(Interpolator.Type.CubicSpline)
+                            >>> type = interpolator.get_interpolation_type()
+        """

ostk/mathematics/curve_fitting/interpolator.pyi

@@ -6,50 +6,238 @@ import typing
 __all__ = ['BarycentricRational', 'CubicSpline', 'Linear']
 class BarycentricRational(ostk.mathematics.curve_fitting.Interpolator):
     def __init__(self, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> None:
-        ...
+        """
+                        Create a barycentric rational interpolator with data points.
+        
+                        Args:
+                            x (np.array): The x-coordinates of data points.
+                            y (np.array): The y-coordinates of data points.
+        
+                        Example:
+                            >>> x = np.array([0.0, 1.0, 2.0, 3.0])
+                            >>> y = np.array([1.0, 2.0, 0.5, 3.0])
+                            >>> interpolator = BarycentricRational(x, y)
+        """
     @typing.overload
     def compute_derivative(self, x: float) -> float:
-        ...
+        """
+                        Compute the derivative of the barycentric rational interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to compute derivative at.
+        
+                        Returns:
+                            float: The derivative value.
+        
+                        Example:
+                            >>> interpolator = BarycentricRational([0.0, 1.0, 2.0], [1.0, 2.0, 0.5])
+                            >>> derivative = interpolator.compute_derivative(0.5)
+        """
     @typing.overload
     def compute_derivative(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Compute the derivative of the barycentric rational interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to compute derivatives at.
+        
+                        Returns:
+                            (np.array): The derivative values.
+        
+                        Example:
+                            >>> interpolator = BarycentricRational([0.0, 1.0, 2.0], [1.0, 2.0, 0.5])
+                            >>> derivatives = interpolator.compute_derivative([0.2, 0.8])
+        """
     @typing.overload
     def evaluate(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Evaluate the barycentric rational interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to evaluate at.
+        
+                        Returns:
+                            (np.array): The interpolated y-values.
+        
+                        Example:
+                            >>> interpolator = BarycentricRational([0.0, 1.0, 2.0], [1.0, 2.0, 0.5])
+                            >>> result = interpolator.evaluate([0.5, 1.5])
+        """
     @typing.overload
     def evaluate(self, x: float) -> float:
-        ...
+        """
+                        Evaluate the barycentric rational interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to evaluate at.
+        
+                        Returns:
+                            float: The interpolated y-value.
+        
+                        Example:
+                            >>> interpolator = BarycentricRational([0.0, 1.0, 2.0], [1.0, 2.0, 0.5])
+                            >>> result = interpolator.evaluate(0.5)
+        """
 class CubicSpline(ostk.mathematics.curve_fitting.Interpolator):
     @typing.overload
     def __init__(self, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> None:
-        ...
+        """
+                        Create a cubic spline interpolator with data points.
+        
+                        Args:
+                            x (np.array): The x-coordinates of data points.
+                            y (np.array): The y-coordinates of data points.
+        
+                        Example:
+                            >>> x = np.array([0.0, 1.0, 2.0, 3.0])
+                            >>> y = np.array([0.0, 1.0, 4.0, 9.0])
+                            >>> interpolator = CubicSpline(x, y)
+        """
     @typing.overload
     def __init__(self, y: numpy.ndarray[numpy.float64[m, 1]], x_0: ostk.core.type.Real, h: ostk.core.type.Real) -> None:
-        ...
+        """
+                        Create a cubic spline interpolator with uniform spacing.
+        
+                        Args:
+                            y (np.array): The y-coordinates of data points.
+                            x_0 (float): The starting x-coordinate.
+                            h (float): The uniform spacing between x-coordinates.
+        
+                        Example:
+                            >>> y = np.array([0.0, 1.0, 4.0, 9.0])
+                            >>> interpolator = CubicSpline(y, 0.0, 1.0)  # x = [0, 1, 2, 3]
+        """
     @typing.overload
     def compute_derivative(self, x: float) -> float:
-        ...
+        """
+                        Compute the derivative of the cubic spline at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to compute derivative at.
+        
+                        Returns:
+                            float: The derivative value.
+        
+                        Example:
+                            >>> interpolator = CubicSpline([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+                            >>> derivative = interpolator.compute_derivative(0.5)
+        """
     @typing.overload
     def compute_derivative(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Compute the derivative of the cubic spline at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to compute derivatives at.
+        
+                        Returns:
+                            (np.array): The derivative values.
+        
+                        Example:
+                            >>> interpolator = CubicSpline([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+                            >>> derivatives = interpolator.compute_derivative([0.2, 0.8])
+        """
     @typing.overload
     def evaluate(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Evaluate the cubic spline interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to evaluate at.
+        
+                        Returns:
+                            (np.array): The interpolated y-values.
+        
+                        Example:
+                            >>> interpolator = CubicSpline([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+                            >>> result = interpolator.evaluate([0.5, 1.5])
+        """
     @typing.overload
     def evaluate(self, x: float) -> float:
-        ...
+        """
+                        Evaluate the cubic spline interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to evaluate at.
+        
+                        Returns:
+                            float: The interpolated y-value.
+        
+                        Example:
+                            >>> interpolator = CubicSpline([0.0, 1.0, 2.0], [0.0, 1.0, 4.0])
+                            >>> result = interpolator.evaluate(0.5)
+        """
 class Linear(ostk.mathematics.curve_fitting.Interpolator):
     def __init__(self, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> None:
-        ...
+        """
+                        Create a linear interpolator with data points.
+        
+                        Args:
+                            x (np.array): The x-coordinates of data points.
+                            y (np.array): The y-coordinates of data points.
+        
+                        Example:
+                            >>> x = np.array([0.0, 1.0, 2.0])
+                            >>> y = np.array([0.0, 2.0, 4.0])
+                            >>> interpolator = Linear(x, y)
+        """
     @typing.overload
     def compute_derivative(self, x: float) -> float:
-        ...
+        """
+                        Compute the derivative of the linear interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to compute derivative at.
+        
+                        Returns:
+                            float: The derivative value.
+        
+                        Example:
+                            >>> interpolator = Linear([0.0, 1.0], [0.0, 2.0])
+                            >>> derivative = interpolator.compute_derivative(0.5)  # 2.0
+        """
     @typing.overload
     def compute_derivative(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Compute the derivative of the linear interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to compute derivatives at.
+        
+                        Returns:
+                            (np.array): The derivative values.
+        
+                        Example:
+                            >>> interpolator = Linear([0.0, 1.0], [0.0, 2.0])
+                            >>> derivatives = interpolator.compute_derivative([0.2, 0.8])
+        """
     @typing.overload
     def evaluate(self, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]:
-        ...
+        """
+                        Evaluate the linear interpolation at multiple points.
+        
+                        Args:
+                            x (np.array): The x-coordinates to evaluate at.
+        
+                        Returns:
+                            (np.array): The interpolated y-values.
+        
+                        Example:
+                            >>> interpolator = Linear([0.0, 1.0], [0.0, 2.0])
+                            >>> result = interpolator.evaluate([0.5, 1.5])
+        """
     @typing.overload
     def evaluate(self, x: float) -> float:
-        ...
+        """
+                        Evaluate the linear interpolation at a single point.
+        
+                        Args:
+                            x (float): The x-coordinate to evaluate at.
+        
+                        Returns:
+                            float: The interpolated y-value.
+        
+                        Example:
+                            >>> interpolator = Linear([0.0, 1.0], [0.0, 2.0])
+                            >>> result = interpolator.evaluate(0.5)  # 1.0
+        """