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

open_space_toolkit_mathematics-4.6.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.2
+Name: open-space-toolkit-mathematics
+Version: 4.6.0
+Summary: Geometry, curve fitting, optimization.
+Author: Open Space Collective
+Author-email: contact@open-space-collective.org
+License: Apache License 2.0
+Keywords: open-space-collective,open-space-toolkit mathematics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Description-Content-Type: text/markdown
+Requires-Dist: numpy<3.0,>=1.0
+Requires-Dist: open-space-toolkit-core~=5.0
+
+# Open Space Toolkit ▸ Mathematics
+
+Geometry, curve fitting, optimization.
+
+[![Build and Test](https://github.com/open-space-collective/open-space-toolkit-mathematics/actions/workflows/build-test.yml/badge.svg?branch=main)](https://github.com/open-space-collective/open-space-toolkit-mathematics/actions/workflows/build-test.yml)
+[![Code Coverage](https://codecov.io/gh/open-space-collective/open-space-toolkit-mathematics/branch/main/graph/badge.svg)](https://codecov.io/gh/open-space-collective/open-space-toolkit-mathematics)
+[![Documentation](https://img.shields.io/readthedocs/pip/stable.svg)](https://open-space-collective.github.io/open-space-toolkit-mathematics)
+[![GitHub version](https://badge.fury.io/gh/open-space-collective%2Fopen-space-toolkit-mathematics.svg)](https://badge.fury.io/gh/open-space-collective%2Fopen-space-toolkit-mathematics)
+[![PyPI version](https://badge.fury.io/py/open-space-toolkit-mathematics.svg)](https://badge.fury.io/py/open-space-toolkit-mathematics)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+[GitHub](https://github.com/open-space-collective/open-space-toolkit-mathematics)

open_space_toolkit_mathematics-4.6.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/OpenSpaceToolkitMathematicsPy.cpython-39-aarch64-linux-gnu.so,sha256=l2tTwcc4z4QqOgJEtT8vZ3wJi92uaStgzAIG7VfZ1Ec,2070232
+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=E2_XxUqmg3wD7laoCPA7WAaIiFWOg7RcIKzHocXlsN4,2442368
+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=P2P5ecrRyusAQWCh6fVGvuIKAsAuUDS0Yx51HO-5lgQ,57269
+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
+ostk/mathematics/test/curve_fitting/interpolator/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/curve_fitting/interpolator/test_barycentric_rational.py,sha256=Gk4QGPozj21b5zdYtCliChxBazqxaL2tG12TDjOaR8o,1436
+ostk/mathematics/test/curve_fitting/interpolator/test_cubic_spline.py,sha256=Pnd7Y6n-7_MOcSw3Vi5WxgsVDrmzzE41S5QOcyhUxso,1689
+ostk/mathematics/test/curve_fitting/interpolator/test_interpolator.py,sha256=46px5NKN8TJO9L9KbopsK9pixq0j3_Xu7PchDQTSEPQ,2093
+ostk/mathematics/test/curve_fitting/interpolator/test_linear.py,sha256=JNGUrBtaN6mCTeVO_bVEU5-BHmgtxLts3Lgj2890lcw,1417
+ostk/mathematics/test/geometry/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/test_angle.py,sha256=HOzlWUApgN6LN0g0Zts0cFQ6In_nmbYpFb3CnWWHVR0,10136
+ostk/mathematics/test/geometry/d2/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d2/conftest.py,sha256=YmbYbVERGClW1ICbGDiMG3d0XYgtH8JNQbOVjlgXh8o,1762
+ostk/mathematics/test/geometry/d2/test_object.py,sha256=JwyeSL4JIR8LY2is0SJKdoTeKiJINDv4b8uFd6dY75c,546
+ostk/mathematics/test/geometry/d2/test_transformation.py,sha256=WEG_qVZFx-0wZB6Qn3uHKBGdEJ04fq5Vds2Kqx_YkO0,2095
+ostk/mathematics/test/geometry/d2/object/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d2/object/test_composite.py,sha256=t_ap8UXmvRK7vgyHIXh36Oym_UJa6bHmJFFBr3O6kfM,2751
+ostk/mathematics/test/geometry/d2/object/test_line.py,sha256=Dr0uHk-gFLJcsC69W1DBCvvipLlAbTVPBxigJGKXORQ,1433
+ostk/mathematics/test/geometry/d2/object/test_linestring.py,sha256=EucjDiSSQ2Ab3-huWtfanE6Cb0Jazb78LUuiFnpe8Mo,5933
+ostk/mathematics/test/geometry/d2/object/test_multipolygon.py,sha256=qjgX71axIqKPUGCazdYgv0rbJTJfq-LcEDjnDEhfaok,3469
+ostk/mathematics/test/geometry/d2/object/test_point.py,sha256=Eoq1FAYB6W4yrjpassgG9PRb3Zdg2DOjpmTZZuNiQ9M,6457
+ostk/mathematics/test/geometry/d2/object/test_point_set.py,sha256=sM8P1SWoNL8lNw1kZdSQbD_5WkGGRwiRtgpmnolHvzk,3319
+ostk/mathematics/test/geometry/d2/object/test_polygon.py,sha256=fHEJDXmzgl24-eQ3gMGIBwNZsEa-3F6_8T6eLzaVgFI,12621
+ostk/mathematics/test/geometry/d2/object/test_segment.py,sha256=M1QTkseGo1ADeslcEl5JzlQEc_1-1LpBV4av_FuPX7E,3072
+ostk/mathematics/test/geometry/d3/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d3/test_intersection.py,sha256=7QrduhVXyTHG0lGLEHNgv4olvFrR6TR0MNgu9acmRd4,61
+ostk/mathematics/test/geometry/d3/test_object.py,sha256=7QrduhVXyTHG0lGLEHNgv4olvFrR6TR0MNgu9acmRd4,61
+ostk/mathematics/test/geometry/d3/test_transformation.py,sha256=7QrduhVXyTHG0lGLEHNgv4olvFrR6TR0MNgu9acmRd4,61
+ostk/mathematics/test/geometry/d3/object/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d3/object/test_composite.py,sha256=03wi6k35a2lwyM29q5STjqX4CHL1IofYm2hBzERQlzU,7710
+ostk/mathematics/test/geometry/d3/object/test_cuboid.py,sha256=xJp6ImRnkNw_k6Tt8RaSXlsGnSqM-SlQSBfbm7SwJuA,470
+ostk/mathematics/test/geometry/d3/object/test_line.py,sha256=d-CvDjXeH1WQcleCU2yt4FdHLhWgy45NGzn3mEwy6xE,1690
+ostk/mathematics/test/geometry/d3/object/test_linestring.py,sha256=L2gEJGDOaP17RgbLbX0-kBjskW_MrPLxVyf_l9yyxag,5938
+ostk/mathematics/test/geometry/d3/object/test_point.py,sha256=-5Cjy3Pru3UWbMO7vBDNiJYfUkqVVxxZtDgsMYYaosc,6611
+ostk/mathematics/test/geometry/d3/object/test_point_set.py,sha256=nE20GLaghjPqAB9EuCd66wsYX4KC2Gs_CSWcsmqaCQM,3587
+ostk/mathematics/test/geometry/d3/object/test_polygon.py,sha256=7ZjucWMsNzppN3pptxHgGgOtOGv1grseT7VnctgOJP4,4262
+ostk/mathematics/test/geometry/d3/object/test_segment.py,sha256=HWg-BCJoa74EgWlvUPd85v_qR2p9THi0ejhtG0EQNEA,4027
+ostk/mathematics/test/geometry/d3/objects/test_cuboid.py,sha256=uIDwPbkygXFIopKc2kayKYgadNfOKD_zxf3w2J4DfTY,471
+ostk/mathematics/test/geometry/d3/transformation/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d3/transformation/rotation/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+ostk/mathematics/test/geometry/d3/transformation/rotation/test_euler_angle.py,sha256=eTIxAqUfCQj6eZfoQgNu-1xFg0O4sbKk4n8XHQwXD2E,4393
+ostk/mathematics/test/geometry/d3/transformation/rotation/test_quaternion.py,sha256=hYsEWbZIp4eSpZ9EWtWOl3iau58AH2btloIkXP9zUuw,7050
+ostk/mathematics/test/geometry/d3/transformation/rotation/test_rotation_matrix.py,sha256=zG3lQlelSIBTCPOPbYmh6CAmbuLtM1E5hJwVR4hOu2M,1479
+ostk/mathematics/test/geometry/d3/transformation/rotation/test_rotation_vector.py,sha256=ngzrvqH_0QRGwNsWc2RupUkpsTU5vZI-eoh5q2BkKRQ,1568
+ostk/mathematics/test/object/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
+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.6.0.dist-info/METADATA,sha256=JZjUY_m8rtrUwbPjJkabvh8jscu5kdpg9NfhirRIgzI,1804
+open_space_toolkit_mathematics-4.6.0.dist-info/WHEEL,sha256=HKTDQRaBjeful1LuAej8fX2VXGhDWeCDzK_M-yn2ypk,110
+open_space_toolkit_mathematics-4.6.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_mathematics-4.6.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_mathematics-4.6.0.dist-info/RECORD,,

open_space_toolkit_mathematics-4.6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.1)
+Root-Is-Purelib: true
+Tag: py39-none-manylinux2014_aarch64
+

open_space_toolkit_mathematics-4.6.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ostk

open_space_toolkit_mathematics-4.6.0.dist-info/zip-safe

@@ -0,0 +1 @@
+

ostk/__init__.py

@@ -0,0 +1 @@
+# Apache License 2.0

ostk/mathematics/__init__.py

@@ -0,0 +1,5 @@
+# Apache License 2.0
+
+from ostk.core import *
+
+from .OpenSpaceToolkitMathematicsPy import *

ostk/mathematics/__init__.pyi

@@ -0,0 +1,11 @@
+from __future__ import annotations
+from ostk import core as OpenSpaceToolkitCorePy
+from ostk.core import container
+from ostk.core import filesystem
+from ostk.core import type
+from ostk import mathematics as OpenSpaceToolkitMathematicsPy
+from . import curve_fitting
+from . import geometry
+from . import object
+from . import solver
+__all__ = ['OpenSpaceToolkitCorePy', 'OpenSpaceToolkitMathematicsPy', 'container', 'curve_fitting', 'filesystem', 'geometry', 'object', 'solver', 'type']

ostk/mathematics/curve_fitting/__init__.pyi

@@ -0,0 +1,155 @@
+from __future__ import annotations
+import numpy
+import typing
+from . import interpolator
+__all__ = ['Interpolator', 'interpolator']
+class Interpolator:
+    class Type:
+        """
+        Members:
+        
+          BarycentricRational
+        
+          CubicSpline
+        
+          Linear
+        """
+        BarycentricRational: typing.ClassVar[Interpolator.Type]  # value = <Type.BarycentricRational: 0>
+        CubicSpline: typing.ClassVar[Interpolator.Type]  # value = <Type.CubicSpline: 1>
+        Linear: typing.ClassVar[Interpolator.Type]  # value = <Type.Linear: 2>
+        __members__: typing.ClassVar[dict[str, Interpolator.Type]]  # value = {'BarycentricRational': <Type.BarycentricRational: 0>, 'CubicSpline': <Type.CubicSpline: 1>, 'Linear': <Type.Linear: 2>}
+        def __eq__(self, other: typing.Any) -> bool:
+            ...
+        def __getstate__(self) -> int:
+            ...
+        def __hash__(self) -> int:
+            ...
+        def __index__(self) -> int:
+            ...
+        def __init__(self, value: int) -> None:
+            ...
+        def __int__(self) -> int:
+            ...
+        def __ne__(self, other: typing.Any) -> bool:
+            ...
+        def __repr__(self) -> str:
+            ...
+        def __setstate__(self, state: int) -> None:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def name(self) -> str:
+            ...
+        @property
+        def value(self) -> int:
+            ...
+    @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

@@ -0,0 +1,243 @@
+from __future__ import annotations
+import numpy
+import ostk.core.type
+import ostk.mathematics.curve_fitting
+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
+        """