open-space-toolkit-astrodynamics 15.1.0__py39-none-manylinux2014_x86_64.whl → 15.2.0__py39-none-manylinux2014_x86_64.whl

{open_space_toolkit_astrodynamics-15.1.0.dist-info → open_space_toolkit_astrodynamics-15.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: open-space-toolkit-astrodynamics
-Version: 15.1.0
+Version: 15.2.0
 Summary: Orbit, attitude, access.
 Author: Open Space Collective
 Author-email: contact@open-space-collective.org

{open_space_toolkit_astrodynamics-15.1.0.dist-info → open_space_toolkit_astrodynamics-15.2.0.dist-info}/RECORD

@@ -1,17 +1,18 @@
 ostk/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
-ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-39-x86_64-linux-gnu.so,sha256=0LiCPg4duel3WdE9KPD655Ar-CudV02A1gVS9x5Kayw,2631776
+ostk/astrodynamics/OpenSpaceToolkitAstrodynamicsPy.cpython-39-x86_64-linux-gnu.so,sha256=2tntitVO7sOX8cHx1ksZyslSmx_JitAlXT17KKdBSz0,2779360
 ostk/astrodynamics/__init__.py,sha256=3gWyqFIbhAfcdeMhmfBPQPlPQTmaOzm-6flkJe745Zk,251
-ostk/astrodynamics/__init__.pyi,sha256=GUhsCMT_MyFezGzV2XZR8AF2lJQzJJFtcYibkQPUvhk,32231
-ostk/astrodynamics/access.pyi,sha256=0GAFCSoMHT3L8wWOxU1-3ELqR7YGyEkt6wlpaL7UXzI,25313
+ostk/astrodynamics/__init__.pyi,sha256=IBA_ElN21LRUmy5Kfv-sSfOwGTuTRC7BsHyan1lnKb8,32268
+ostk/astrodynamics/access.pyi,sha256=oZ8LyjNx6FurUUzFbUwGvdYJu1Li0Oy7MwIZu8erTLU,25841
 ostk/astrodynamics/converters.py,sha256=luPh30qMp9bzEkN7hUccmxlLf7zRp_AzqmBe8IUjPhU,3314
 ostk/astrodynamics/converters.pyi,sha256=HrZFyizkc6Hv_K38ZKZ80fX_bAxd6keA_NFWNQygvbs,1745
 ostk/astrodynamics/dataframe.py,sha256=9fXRk7sJl_OrBTCjZC_TFx6JMPE7IDGqv2JgEmGCdgM,18775
 ostk/astrodynamics/display.py,sha256=LZESZgx2wlrFO4cwAGMb3VPJfdtcjNgCgKFrqot0NYU,6339
 ostk/astrodynamics/dynamics.pyi,sha256=AUNsUSR5LqOYFt626k4FZDbCPZRGoZV82AwCC3CDH8s,13738
+ostk/astrodynamics/estimator.pyi,sha256=2y4I6GMBZynjlY8a8SxCAVCukGR1typDUZu0h_GX9QU,14336
 ostk/astrodynamics/event_condition.pyi,sha256=-Tq6cqr00lZPpoMnCPDRB0MB-MinM60oCNn1ZSA1Cik,25536
 ostk/astrodynamics/guidance_law.pyi,sha256=pEoAL9CDFWNulOLv6wea3xj1fJI3xFtgx-2eYMEftJI,12507
-ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.15,sha256=_YtpT-mc45lP9dFMoUZvxx5Hw8zQZs75QIwmFJS8VEU,101370512
-ostk/astrodynamics/solver.pyi,sha256=ugi73KdRXPKFvKXFMpYKIwxYUGC2KEMlBiLv0PFcigM,9746
+ostk/astrodynamics/libopen-space-toolkit-astrodynamics.so.15,sha256=Z7W1f17NZ6PBIocIzyb0oUPRcENtllt76T1EJvIbsC8,120954640
+ostk/astrodynamics/solver.pyi,sha256=tjFkzoxW6h6grMGpqKsgyXyYH9R6lLg6LEV2v5_X6yk,18238
 ostk/astrodynamics/utilities.py,sha256=mlKL3WrOASrY_pLt7bzUz0XZT7jagzLOZjMOIqjbQ1Y,6999
 ostk/astrodynamics/viewer.py,sha256=SpcvBqXx3CAZpk7UGOPT1ilxywmAmNpgqpuRY11Hwx0,16376
 ostk/astrodynamics/conjunction/__init__.pyi,sha256=HFvWl8bCmrq3cBkUh5X5RGIh8webmVGxaZdpsz3WN-E,79
@@ -41,7 +42,7 @@ ostk/astrodynamics/test/test_utilities.py,sha256=NNIyzqOxMdsNpK2z0wU0utX06iZNfbM
 ostk/astrodynamics/test/test_viewer.py,sha256=kDstRH_WKufN_0JPSXttzLMk3Afv_ylcEBfHxc35yrA,8946
 ostk/astrodynamics/test/access/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/access/test_generator.py,sha256=i7TnM80kF0Q_9KmyoqKt5n1ufg3ZjAIEMPVVds8ZDdI,10315
-ostk/astrodynamics/test/access/test_visibility_criterion.py,sha256=0Q_lcs6PZC_mTIHDuIPc8adKF02q2EM_ZR6jT5UhnDg,6353
+ostk/astrodynamics/test/access/test_visibility_criterion.py,sha256=VA6WDQTj3q-f2YGIIkrrNp8G23Nf_0g9nKmfZAgAlWQ,6568
 ostk/astrodynamics/test/conjunction/message/ccsds/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/conjunction/message/ccsds/conftest.py,sha256=xyTd24828Ue2HgOWY8UhizIc5mzgRgoH2VSOfVfKCdw,14632
 ostk/astrodynamics/test/conjunction/message/ccsds/test_cdm.py,sha256=ztpnOHI3ZiIV0QwijJ6Si_lIna8jLZF45r1KtPVK4ws,18514
@@ -57,6 +58,8 @@ ostk/astrodynamics/test/dynamics/test_third_body_gravity.py,sha256=7xBOKbVio-zZ2
 ostk/astrodynamics/test/dynamics/test_thruster.py,sha256=cCJtKWuNcRHmcreCv7BajwuJnHCat9m88OHh_o0cB7w,4383
 ostk/astrodynamics/test/dynamics/data/Tabulated_Earth_Gravity.csv,sha256=jJWOMJcQ83Vy1Wrb9PTh3ffOdoDF98kk6w5b-_E0uWg,47419
 ostk/astrodynamics/test/dynamics/data/Tabulated_Earth_Gravity_Truth.csv,sha256=f4x-zmxZADxD_doAbACt24k36VSTp3rSIJiSzuSroKs,8377
+ostk/astrodynamics/test/estimator/test_orbit_determination_solver.py,sha256=Vg_yN3DFLcwa-AfPX0zJaY70rFK1TB8xc3e9wZrKq6M,7493
+ostk/astrodynamics/test/estimator/test_tle_solver.py,sha256=hANdRtaVvlOShXeyUqMpDk7kJINxdwstZodxJzAAWwk,7277
 ostk/astrodynamics/test/event_condition/test_angular_condition.py,sha256=MDRwjU5zXIRBaIFZA3jG3hcnyIIFo_0QyBRtNIfH2aQ,3119
 ostk/astrodynamics/test/event_condition/test_boolean_condition.py,sha256=Ng6FLKD8XoUHUz6-gi3wvrYhSGNSB_iJ_n89ajN4O3s,1580
 ostk/astrodynamics/test/event_condition/test_coe_condition.py,sha256=AM0olK1s4jDRs_dJs0sk9raY9Nm1eZpdEEso6wyvipk,2580
@@ -75,6 +78,7 @@ ostk/astrodynamics/test/guidance_law/test_constant_thrust.py,sha256=YpMkMvat4YnE
 ostk/astrodynamics/test/guidance_law/test_qlaw.py,sha256=kZaBZeU_J8Qk2nFnnpSuu-2NXT_13g3vLamG--eZfeU,3634
 ostk/astrodynamics/test/solvers/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/solvers/test_finite_difference_solver.py,sha256=0tcarIg2HTpcdzItWlL5Kd6q2nHcDBA8ZE0D3ugUN_s,5953
+ostk/astrodynamics/test/solvers/test_least_squares_solver.py,sha256=fkJnaT8vPVDlndks3MhYiEmP6TgPCW0SddbXATcI3KU,8750
 ostk/astrodynamics/test/solvers/test_temporal_condition_solver.py,sha256=OUb7QDwe5WNAtzOLBk-9cBL56PzzadZhXuBo_MiJ2K4,5189
 ostk/astrodynamics/test/trajectory/__init__.py,sha256=epnVn2PwdQkUDZ1msqBRO5nEZIOUBIq-IfK3IlNPijE,21
 ostk/astrodynamics/test/trajectory/test_local_orbital_frame_direction.py,sha256=d72J50UGG9m0Atei0UQ8sITU1WdJmws5xgUiacLZMbw,2515
@@ -124,8 +128,8 @@ ostk/astrodynamics/trajectory/orbit/model/kepler.pyi,sha256=09xlx_7dTiivctFDyW_3
 ostk/astrodynamics/trajectory/orbit/model/sgp4.pyi,sha256=2rxyPPsSCtsEKAShuZQbhZSybK01Q9u1CMieGjwWxN4,14313
 ostk/astrodynamics/trajectory/state/__init__.pyi,sha256=-sq42oF9YgXSkP1LtPcSu7mmtpjUkEzjydD9VYdIQ6g,17672
 ostk/astrodynamics/trajectory/state/coordinate_subset.pyi,sha256=iqoM-8RqiLNIsyiQXLfosvGO7ZP_KdQxrUWqiV04E1c,10566
-open_space_toolkit_astrodynamics-15.1.0.dist-info/METADATA,sha256=52SOCFxHag6hxYwvZmHaYbAds9Sbi7efOiwqvUWHIj8,1913
-open_space_toolkit_astrodynamics-15.1.0.dist-info/WHEEL,sha256=YBJ2ZW-2Jsns4y8CrUTcNUwZdcKvmfwW0KSU35zO7J8,109
-open_space_toolkit_astrodynamics-15.1.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
-open_space_toolkit_astrodynamics-15.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-open_space_toolkit_astrodynamics-15.1.0.dist-info/RECORD,,
+open_space_toolkit_astrodynamics-15.2.0.dist-info/METADATA,sha256=TzYkV4BIJlExDZyzAQdsnsY4C4hP6l_uUdBc_6FpAuE,1913
+open_space_toolkit_astrodynamics-15.2.0.dist-info/WHEEL,sha256=YBJ2ZW-2Jsns4y8CrUTcNUwZdcKvmfwW0KSU35zO7J8,109
+open_space_toolkit_astrodynamics-15.2.0.dist-info/top_level.txt,sha256=zOR18699uDYnafgarhL8WU_LmTZY_5NVqutv-flp_x4,5
+open_space_toolkit_astrodynamics-15.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+open_space_toolkit_astrodynamics-15.2.0.dist-info/RECORD,,

ostk/astrodynamics/__init__.pyi

@@ -14,8 +14,8 @@ from ostk import mathematics as OpenSpaceToolkitMathematicsPy
 from ostk.mathematics import curve_fitting
 from ostk.mathematics import geometry
 from ostk.mathematics import object
-from ostk import physics as OpenSpaceToolkitPhysicsPy
 import ostk.physics
+from ostk import physics as OpenSpaceToolkitPhysicsPy
 from ostk.physics import Environment
 from ostk.physics import Manager
 from ostk.physics import Unit
@@ -24,23 +24,24 @@ import ostk.physics.coordinate
 import ostk.physics.coordinate.spherical
 from ostk.physics import environment
 import ostk.physics.environment.object
-import ostk.physics.time
 from ostk.physics import time
-import ostk.physics.unit
+import ostk.physics.time
 from ostk.physics import unit
+import ostk.physics.unit
 import typing
 from . import access
 from . import conjunction
 from . import converters
 from . import data
 from . import dynamics
+from . import estimator
 from . import event_condition
 from . import flight
 from . import guidance_law
 from . import pytrajectory
 from . import solver
 from . import trajectory
-__all__ = ['Access', 'Dynamics', 'Environment', 'EventCondition', 'GuidanceLaw', 'Manager', 'OpenSpaceToolkitAstrodynamicsPy', 'OpenSpaceToolkitCorePy', 'OpenSpaceToolkitIOPy', 'OpenSpaceToolkitMathematicsPy', 'OpenSpaceToolkitPhysicsPy', 'PyState', 'RootSolver', 'Trajectory', 'URL', 'Unit', 'access', 'conjunction', 'container', 'converters', 'coordinate', 'curve_fitting', 'data', 'dynamics', 'environment', 'event_condition', 'filesystem', 'flight', 'geometry', 'guidance_law', 'ip', 'object', 'pytrajectory', 'solver', 'time', 'trajectory', 'type', 'unit']
+__all__ = ['Access', 'Dynamics', 'Environment', 'EventCondition', 'GuidanceLaw', 'Manager', 'OpenSpaceToolkitAstrodynamicsPy', 'OpenSpaceToolkitCorePy', 'OpenSpaceToolkitIOPy', 'OpenSpaceToolkitMathematicsPy', 'OpenSpaceToolkitPhysicsPy', 'PyState', 'RootSolver', 'Trajectory', 'URL', 'Unit', 'access', 'conjunction', 'container', 'converters', 'coordinate', 'curve_fitting', 'data', 'dynamics', 'environment', 'estimator', 'event_condition', 'filesystem', 'flight', 'geometry', 'guidance_law', 'ip', 'object', 'pytrajectory', 'solver', 'time', 'trajectory', 'type', 'unit']
 class Access:
     """
     

ostk/astrodynamics/access.pyi

@@ -9,6 +9,7 @@ import ostk.physics.coordinate
 import ostk.physics.coordinate.spherical
 import ostk.physics.environment.object
 import ostk.physics.time
+import ostk.physics.unit
 import typing
 __all__ = ['AccessTarget', 'Generator', 'VisibilityCriterion']
 class AccessTarget:
@@ -423,6 +424,7 @@ class VisibilityCriterion:
                             Args:
                                 elevation_interval (RealInterval): The elevation interval in degrees.
             """
+        @typing.overload
         def is_satisfied(self, elevation: ostk.core.type.Real) -> bool:
             """
                             Checks if the given elevation angle satisfies the criterion.
@@ -430,6 +432,17 @@ class VisibilityCriterion:
                             Args:
                                 elevation (float): Elevation angle in radians.
             
+                            Returns:
+                                bool: True if the criterion is satisfied, False otherwise.
+            """
+        @typing.overload
+        def is_satisfied(self, elevation: ostk.physics.unit.Angle) -> bool:
+            """
+                            Checks if the given elevation angle satisfies the criterion.
+            
+                            Args:
+                                elevation (Angle): Elevation angle.
+            
                             Returns:
                                 bool: True if the criterion is satisfied, False otherwise.
             """

ostk/astrodynamics/estimator.pyi

@@ -0,0 +1,280 @@
+from __future__ import annotations
+import numpy
+import ostk.astrodynamics.solver
+import ostk.astrodynamics.trajectory
+import ostk.astrodynamics.trajectory.orbit.model.sgp4
+import ostk.astrodynamics.trajectory.state
+import ostk.core.type
+import ostk.physics
+import ostk.physics.coordinate
+import typing
+__all__ = ['OrbitDeterminationSolver', 'TLESolver']
+class OrbitDeterminationSolver:
+    """
+    
+                Orbit Determination solver.
+            
+    """
+    class Analysis:
+        """
+        
+                    Analysis results from the Orbit Determination.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, estimated_state: ostk.astrodynamics.trajectory.State, solver_analysis: ostk.astrodynamics.solver.LeastSquaresSolver.Analysis) -> None:
+            """
+                            Construct a new Analysis object.
+            
+                            Args:
+                                estimated_state (State): The estimated state. Matching the frame and expanded coordinates of the provided initial guess state.
+                                solver_analysis (LeastSquaresSolver.Analysis): The solver analysis.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def estimated_state(self) -> ostk.astrodynamics.trajectory.State:
+            """
+                            The estimated state.
+            
+                            :type: State
+            """
+        @property
+        def solver_analysis(self) -> ostk.astrodynamics.solver.LeastSquaresSolver.Analysis:
+            """
+                            The solver analysis.
+            
+                            :type: LeastSquaresSolver.Analysis
+            """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, environment: ostk.physics.Environment = ..., numerical_solver: ostk.astrodynamics.trajectory.state.NumericalSolver = ..., solver: ostk.astrodynamics.solver.LeastSquaresSolver = ..., estimation_frame: ostk.physics.coordinate.Frame = ...) -> None:
+        """
+                        Construct a new OrbitDeterminationSolver object.
+        
+                        Args:
+                            environment (Environment, optional): The environment. Defaults to Environment.default().
+                            numerical_solver (NumericalSolver, optional): The numerical solver. Defaults to NumericalSolver.default().
+                            solver (LeastSquaresSolver, optional): The Least Squares solver. Defaults to LeastSquaresSolver.default().
+                            estimation_frame (Frame, optional): The estimation frame. Defaults to Frame.GCRF().
+        """
+    def access_environment(self) -> ostk.physics.Environment:
+        """
+                        Access the environment.
+        
+                        Returns:
+                            Environment: The environment.
+        """
+    def access_estimation_frame(self) -> ostk.physics.coordinate.Frame:
+        """
+                        Access the estimation frame.
+        
+                        Returns:
+                            Frame: The estimation frame.
+        """
+    def access_propagator(self) -> ostk.astrodynamics.trajectory.Propagator:
+        """
+                        Access the propagator.
+        
+                        Returns:
+                            Propagator: The propagator.
+        """
+    def access_solver(self) -> ostk.astrodynamics.solver.LeastSquaresSolver:
+        """
+                        Access the solver.
+        
+                        Returns:
+                            LeastSquaresSolver: The Least Squares solver.
+        """
+    def estimate(self, initial_guess: ostk.astrodynamics.trajectory.State, observations: list[ostk.astrodynamics.trajectory.State], estimation_coordinate_subsets: list[ostk.astrodynamics.trajectory.state.CoordinateSubset] = [], initial_guess_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}) -> OrbitDeterminationSolver.Analysis:
+        """
+                        Estimate state from observations.
+        
+                        Args:
+                            initial_guess (State): Initial guess state.
+                            observations (list[State]): Observations to fit against.
+                            estimation_coordinate_subsets (list[CoordinateSubset], optional): Coordinate subsets to estimate. Defaults to empty list, in which case all the coordinate subsets from the initial guess state are estimated.
+                            initial_guess_sigmas (dict[CoordinateSubset, VectorXd], optional): Initial guess sigmas.
+                            observation_sigmas (dict[CoordinateSubset, VectorXd], optional): Observation sigmas.
+        
+                        Returns:
+                            OrbitDeterminationSolverAnalysis: The analysis results.
+        """
+    def estimate_orbit(self, initial_guess: ostk.astrodynamics.trajectory.State, observations: list[ostk.astrodynamics.trajectory.State], estimation_coordinate_subsets: list[ostk.astrodynamics.trajectory.state.CoordinateSubset] = [], initial_guess_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}) -> ostk.astrodynamics.trajectory.Orbit:
+        """
+                        Estimate Propagated Orbit from observations.
+        
+                        Args:
+                            initial_guess (State): Initial guess state.
+                            observations (list[State]): Observations to fit against.
+                            estimation_coordinate_subsets (list[CoordinateSubset], optional): Coordinate subsets to estimate. Defaults to empty list, in which case all the coordinate subsets from the initial guess state are estimated.
+                            initial_guess_sigmas (dict[CoordinateSubset, VectorXd], optional): Initial guess sigmas. Defaults to empty, in which case
+                            observation_sigmas (dict[CoordinateSubset, VectorXd], optional): Observation sigmas.
+        
+                        Returns:
+                            Orbit: The estimated orbit.
+        """
+class TLESolver:
+    """
+    
+                Solver for estimating TLE elements.
+            
+    """
+    class Analysis:
+        """
+        
+                    Analysis results from the TLE estimation solver.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, estimated_tle: ostk.astrodynamics.trajectory.orbit.model.sgp4.TLE, solver_analysis: ostk.astrodynamics.solver.LeastSquaresSolver.Analysis) -> None:
+            """
+                            Construct a new TLESolver::Analysis object.
+            
+                            Args:
+                                estimated_tle (TLE): The estimated TLE.
+                                solver_analysis (LeastSquaresSolver.Analysis): The solver analysis.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def estimated_tle(self) -> ostk.astrodynamics.trajectory.orbit.model.sgp4.TLE:
+            """
+                            The estimated TLE.
+            
+                            :type: TLE
+            """
+        @property
+        def solver_analysis(self) -> ostk.astrodynamics.solver.LeastSquaresSolver.Analysis:
+            """
+                            The solver analysis.
+            
+                            :type: LeastSquaresSolver.Analysis
+            """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, solver: ostk.astrodynamics.solver.LeastSquaresSolver = ..., satellite_number: ostk.core.type.Integer = 0, international_designator: ostk.core.type.String = '00001A', revolution_number: ostk.core.type.Integer = 0, estimate_b_star: bool = True, estimation_frame: ostk.physics.coordinate.Frame = ...) -> None:
+        """
+                        Construct a new TLESolver object.
+        
+                        Args:
+                            solver (LeastSquaresSolver, optional): The solver to use. Defaults to LeastSquaresSolver.default().
+                            satellite_number (int, optional): Satellite number for TLE. Defaults to 0.
+                            international_designator (str, optional): International designator for TLE. Defaults to "00001A".
+                            revolution_number (int, optional): Revolution number. Defaults to 0.
+                            estimate_b_star (bool, optional): Whether to also estimate the B* parameter. Defaults to True.
+                            estimation_frame (Frame, optional): Frame for estimation. Defaults to GCRF.
+        """
+    def access_default_b_star(self) -> ostk.core.type.Real:
+        """
+                        Access the default B* value.
+        
+                        Returns:
+                            float: The default B* value.
+        """
+    def access_element_set_number(self) -> ostk.core.type.Integer:
+        """
+                        Access the element set number.
+        
+                        Returns:
+                            int: The element set number.
+        """
+    def access_ephemeris_type(self) -> ostk.core.type.Integer:
+        """
+                        Access the ephemeris type.
+        
+                        Returns:
+                            int: The ephemeris type.
+        """
+    def access_estimate_b_star(self) -> bool:
+        """
+                        Access whether to estimate B*.
+        
+                        Returns:
+                            bool: whether to estimate B*.
+        """
+    def access_first_derivative_mean_motion_divided_by_2(self) -> ostk.core.type.Real:
+        """
+                        Access the first derivative of mean motion divided by 2.
+        
+                        Returns:
+                            float: The first derivative of mean motion divided by 2.
+        """
+    def access_international_designator(self) -> ostk.core.type.String:
+        """
+                        Access the international designator.
+        
+                        Returns:
+                            str: The international designator.
+        """
+    def access_revolution_number(self) -> ostk.core.type.Integer:
+        """
+                        Access the revolution number.
+        
+                        Returns:
+                            int: The revolution number.
+        """
+    def access_satellite_number(self) -> ostk.core.type.Integer:
+        """
+                        Access the satellite number.
+        
+                        Returns:
+                            int: The satellite number.
+        """
+    def access_second_derivative_mean_motion_divided_by_6(self) -> ostk.core.type.Real:
+        """
+                        Access the second derivative of mean motion divided by 6.
+        
+                        Returns:
+                            float: The second derivative of mean motion divided by 6.
+        """
+    def access_solver(self) -> ostk.astrodynamics.solver.LeastSquaresSolver:
+        """
+                        Access the solver.
+        
+                        Returns:
+                            LeastSquaresSolver: The Least Squares solver.
+        """
+    def access_tle_state_builder(self) -> ostk.astrodynamics.trajectory.StateBuilder:
+        """
+                        Access the TLE state builder.
+        
+                        Returns:
+                            StateBuilder: The TLE state builder.
+        """
+    def estimate(self, initial_guess: typing.Any, observations: list[ostk.astrodynamics.trajectory.State], initial_guess_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}) -> TLESolver.Analysis:
+        """
+                        Estimate TLE from observations.
+        
+                        Args:
+                            initial_guess (TLE | tuple[State, float] | State): Initial guess - can be a TLE, (cartesian State, B*) tuple, or cartesian State.
+                            observations (list[State]): State observations to fit against.
+                            initial_guess_sigmas (dict[CoordinateSubset, ndarray], optional): Initial guess sigmas.
+                            observation_sigmas (dict[CoordinateSubset, ndarray], optional): Observation sigmas.
+        
+                        Returns:
+                            TLESolver.Analysis: Analysis results containing the estimated TLE and solver analysis.
+        """
+    def estimate_orbit(self, initial_guess: typing.Any, observations: list[ostk.astrodynamics.trajectory.State], initial_guess_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[ostk.astrodynamics.trajectory.state.CoordinateSubset, numpy.ndarray[numpy.float64[m, 1]]] = {}) -> ostk.astrodynamics.trajectory.Orbit:
+        """
+                        Estimate an SGP4-based orbit from observations.
+        
+                        Args:
+                            initial_guess (TLE | tuple[State, float] | State): Initial guess - can be a TLE, (cartesian State, B*) tuple, or cartesian State.
+                            observations (list[State]): State observations to fit against.
+                            initial_guess_sigmas (dict[CoordinateSubset, ndarray], optional): Initial guess sigmas.
+                            observation_sigmas (dict[CoordinateSubset, ndarray], optional): Observation sigmas.
+        
+                        Returns:
+                            Orbit: The estimated SGP4 orbit.
+        """

ostk/astrodynamics/solver.pyi

@@ -3,7 +3,7 @@ import numpy
 import ostk.core.type
 import ostk.physics.time
 import typing
-__all__ = ['FiniteDifferenceSolver', 'TemporalConditionSolver']
+__all__ = ['FiniteDifferenceSolver', 'LeastSquaresSolver', 'TemporalConditionSolver']
 class FiniteDifferenceSolver:
     """
     
@@ -166,6 +166,214 @@ class FiniteDifferenceSolver:
                         Returns:
                             FiniteDifferenceSolver.Type: The type.
         """
+class LeastSquaresSolver:
+    """
+    
+                Class to solve non-linear least squares problems.
+            
+    """
+    class Analysis:
+        """
+        
+                    Class representing the analysis of the least squares solver.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, termination_criteria: ostk.core.type.String, estimated_state: typing.Any, estimated_covariance: numpy.ndarray[numpy.float64[m, n]], estimated_frisbee_covariance: numpy.ndarray[numpy.float64[m, n]], computed_observations: list[...], steps: list[LeastSquaresSolver.Step]) -> None:
+            """
+                            Constructor.
+            
+                            Args:
+                                termination_criteria (str): The termination criteria.
+                                estimated_state (State): The estimated state.
+                                estimated_covariance (np.ndarray): The estimated covariance matrix.
+                                estimated_frisbee_covariance (np.ndarray): The estimated Frisbee covariance matrix.
+                                computed_observations (list[State]): The computed observations of the final iteration.
+                                steps (list[LeastSquaresSolver.Step]): The steps.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        def compute_residual_states(self, observations: list[...]) -> list[...]:
+            """
+                        Compute the residual states.
+            
+                        Args:
+                            observations (list[State]): The observations.
+            
+                        Returns:
+                            list[State]: The residuals.
+            """
+        @property
+        def computed_observations(self) -> list[...]:
+            """
+                            The computed observations of the final iteration.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_covariance(self) -> numpy.ndarray[numpy.float64[m, n]]:
+            """
+                            The estimated covariance matrix.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_frisbee_covariance(self) -> numpy.ndarray[numpy.float64[m, n]]:
+            """
+                            The estimated Frisbee covariance matrix.
+            
+                            :type: np.ndarray
+            """
+        @property
+        def estimated_state(self) -> ...:
+            """
+                            The estimated state.
+            
+                            :type: State
+            """
+        @property
+        def iteration_count(self) -> int:
+            """
+                            The iteration count.
+            
+                            :type: int
+            """
+        @property
+        def observation_count(self) -> int:
+            """
+                            The observation count.
+            
+                            :type: int
+            """
+        @property
+        def rms_error(self) -> ostk.core.type.Real:
+            """
+                            The RMS error.
+            
+                            :type: float
+            """
+        @property
+        def steps(self) -> list[LeastSquaresSolver.Step]:
+            """
+                            The steps.
+            
+                            :type: list[LeastSquaresSolver.Step]
+            """
+        @property
+        def termination_criteria(self) -> ostk.core.type.String:
+            """
+                            The termination criteria.
+            
+                            :type: str
+            """
+    class Step:
+        """
+        
+                    Class representing a step in the least squares solver.
+                
+        """
+        @staticmethod
+        def _pybind11_conduit_v1_(*args, **kwargs):
+            ...
+        def __init__(self, rms_error: ostk.core.type.Real, x_hat: numpy.ndarray[numpy.float64[m, 1]]) -> None:
+            """
+                            Constructor.
+            
+                            Args:
+                                rms_error (float): The RMS error.
+                                x_hat (np.ndarray): The X hat vector.
+            """
+        def __repr__(self) -> str:
+            ...
+        def __str__(self) -> str:
+            ...
+        @property
+        def rms_error(self) -> ostk.core.type.Real:
+            """
+                            The RMS error.
+            
+                            :type: float
+            """
+        @property
+        def x_hat(self) -> numpy.ndarray[numpy.float64[m, 1]]:
+            """
+                            The X hat vector.
+            
+                            :type: np.ndarray
+            """
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def calculate_empirical_covariance(residuals: list[...]) -> numpy.ndarray[numpy.float64[m, n]]:
+        """
+                        Calculate the empirical covariance matrix from an array of state residuals.
+        
+                        Args:
+                            residuals (list[State]): A list of state residuals.
+        
+                        Returns:
+                            np.ndarray: The empirical covariance matrix.
+        
+                        Throws:
+                            ostk::core::error::runtime::Undefined: If the residual array is empty.
+        """
+    @staticmethod
+    def default() -> LeastSquaresSolver:
+        """
+                        Create a default instance of LeastSquaresSolver.
+        
+                        Returns:
+                            LeastSquaresSolver: A default instance of LeastSquaresSolver.
+        """
+    def __init__(self, maximum_iteration_count: int, rms_update_threshold: ostk.core.type.Real, finite_difference_solver: FiniteDifferenceSolver = ...) -> None:
+        """
+                        Constructor.
+        
+                        Args:
+                            maximum_iteration_count (int): Maximum number of iterations.
+                            rms_update_threshold (float): Minimum RMS threshold.
+                            finite_difference_solver (FiniteDifferenceSolver): Finite difference solver. Defaults to FiniteDifferenceSolver.Default().
+        """
+    def get_finite_difference_solver(self) -> FiniteDifferenceSolver:
+        """
+                        Get the finite difference solver.
+        
+                        Returns:
+                            FiniteDifferenceSolver: The finite difference solver.
+        """
+    def get_max_iteration_count(self) -> int:
+        """
+                        Get the maximum iteration count.
+        
+                        Returns:
+                            int: The maximum iteration count.
+        """
+    def get_rms_update_threshold(self) -> ostk.core.type.Real:
+        """
+                        Get the RMS update threshold.
+        
+                        Returns:
+                            float: The RMS update threshold.
+        """
+    def solve(self, initial_guess: typing.Any, observations: list[...], state_generator: typing.Callable[[..., list[ostk.physics.time.Instant]], list[...]], initial_guess_sigmas: dict[..., numpy.ndarray[numpy.float64[m, 1]]] = {}, observation_sigmas: dict[..., numpy.ndarray[numpy.float64[m, 1]]] = {}) -> LeastSquaresSolver.Analysis:
+        """
+                        Solve the non-linear least squares problem.
+        
+                        Args:
+                            initial_guess (State): Initial guess state (the Estimated State is of the same domain as this state).
+                            observations (list[State]): List of observations.
+                            state_generator (callable[list[State],[State, list[Instant]]]): Function to generate states.
+                            initial_guess_sigmas (dict[CoordinateSubset, np.ndarray], optional): Dictionary of sigmas for initial guess.
+                            observation_sigmas (dict[CoordinateSubset, np.ndarray], optional): Dictionary of sigmas for observations.
+        
+                        Returns:
+                            LeastSquaresSolver::Analysis: The analysis of the estimate.
+        """
 class TemporalConditionSolver:
     """