WIP

crates/lox-bodies/src/dynamic.rs

@@ -13,13 +13,16 @@ pub struct UnknownOriginName(String);
 #[error("no origin with NAIF ID `{0}` is known")]
 pub struct UnknownOriginId(i32);
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, FromPrimitive, ToPrimitive, PartialOrd, Ord)]
+#[derive(
+    Debug, Copy, Clone, Default, Eq, PartialEq, Hash, FromPrimitive, ToPrimitive, PartialOrd, Ord,
+)]
 pub enum DynOrigin {
     Sun = 10,
 
     // Planets.
     Mercury = 199,
     Venus = 299,
+    #[default]
     Earth = 399,
     Mars = 499,
     Jupiter = 599,
@@ -215,12 +218,6 @@ pub enum DynOrigin {
     Bennu = 2101955,
 }
 
-impl Default for DynOrigin {
-    fn default() -> Self {
-        DynOrigin::Earth
-    }
-}
-
 impl Origin for DynOrigin {
     fn id(&self) -> NaifId {
         NaifId(self.to_i32().unwrap())

crates/lox-bodies/src/python.rs

@@ -25,7 +25,7 @@ impl From<UnknownOriginName> for PyErr {
 }
 
 #[pyclass(name = "Origin", module = "lox_space", frozen, eq)]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct PyOrigin(pub DynOrigin);
 
 #[pymethods]
@@ -63,9 +63,3 @@ impl PyOrigin {
         self.0.name()
     }
 }
-
-impl Default for PyOrigin {
-    fn default() -> Self {
-        Self(DynOrigin::default())
-    }
-}

crates/lox-math/src/linear_algebra/tridiagonal.rs

@@ -67,7 +67,7 @@ impl<'a> Tridiagonal<'a> {
     }
 }
 
-impl<'a> Index<Idx> for Tridiagonal<'a> {
+impl Index<Idx> for Tridiagonal<'_> {
     type Output = f64;
 
     fn index(&self, (i, j): Idx) -> &Self::Output {

crates/lox-math/src/math.rs

@@ -1,9 +1,9 @@
+//! Module math provides common mathematical functions shared by many parts of the library.
+
 use std::f64::consts::{PI, TAU};
 
 use crate::types::units::{Arcseconds, Radians};
 
-/// Module math provides common mathematical functions shared by many parts of the library.
-
 /// Normalizes an angle `a` to the range [center-π, center+π).
 pub fn normalize_two_pi(a: Radians, center: Radians) -> Radians {
     a - 2.0 * PI * ((a + PI - center) / (2.0 * PI)).floor()

crates/lox-orbits/src/analysis.rs

@@ -12,15 +12,14 @@ use lox_math::roots::Brent;
 use lox_math::series::{Series, SeriesError};
 use lox_math::types::units::Radians;
 use lox_time::deltas::TimeDelta;
-use lox_time::julian_dates::JulianDate;
 use lox_time::time_scales::Tdb;
 use lox_time::transformations::TryToScale;
 use lox_time::TimeLike;
 use thiserror::Error;
 
 use crate::events::{find_windows, Window};
 use crate::frames::{
-    BodyFixed, DynFrame, FrameTransformationProvider, Icrf, ReferenceFrame, TryRotateTo, TryToFrame,
+    BodyFixed, DynFrame, FrameTransformationProvider, Icrf, TryRotateTo, TryToFrame,
 };
 use crate::ground::{DynGroundLocation, GroundLocation};
 use crate::states::State;

crates/lox-orbits/src/elements.rs

@@ -11,7 +11,7 @@ use std::f64::consts::TAU;
 use float_eq::float_eq;
 use glam::{DMat3, DVec3};
 
-use lox_bodies::{DynOrigin, MaybePointMass, Origin, PointMass};
+use lox_bodies::{DynOrigin, MaybePointMass, PointMass};
 use lox_time::deltas::TimeDelta;
 use lox_time::TimeLike;
 

crates/lox-orbits/src/frames.rs

@@ -12,10 +12,9 @@ use crate::frames::iau::icrf_to_bodyfixed;
 use crate::frames::iers::{cirf_to_tirf, icrf_to_cirf, tirf_to_itrf};
 use crate::rotations::Rotation;
 use glam::{DMat3, DVec3};
-use lox_bodies::{DynOrigin, MaybeRotationalElements, Origin, RotationalElements, Spheroid};
+use lox_bodies::{DynOrigin, MaybeRotationalElements, Origin, RotationalElements};
 use lox_math::types::units::Seconds;
-use lox_time::prelude::Tdb;
-use lox_time::transformations::{OffsetProvider, TryToScale};
+use lox_time::transformations::OffsetProvider;
 use lox_time::TimeLike;
 use thiserror::Error;
 
@@ -153,21 +152,16 @@ impl<T: RotationalElements> ReferenceFrame for BodyFixed<T> {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
 pub enum DynFrame {
+    #[default]
     Icrf,
     Cirf,
     Tirf,
     Itrf,
     BodyFixed(DynOrigin),
 }
 
-impl Default for DynFrame {
-    fn default() -> Self {
-        DynFrame::Icrf
-    }
-}
-
 impl ReferenceFrame for DynFrame {
     fn name(&self) -> String {
         match self {

crates/lox-orbits/src/frames/iau.rs

@@ -10,7 +10,6 @@ use crate::rotations::Rotation;
 use glam::{DMat3, DVec3};
 use lox_bodies::{MaybeRotationalElements, RotationalElements};
 use lox_math::types::units::Seconds;
-use lox_time::prelude::Tdb;
 use lox_time::TimeLike;
 
 pub(crate) fn icrf_to_bodyfixed<T: MaybeRotationalElements>(
@@ -38,7 +37,7 @@ impl<O: RotationalElements, P: FrameTransformationProvider> TryRotateTo<BodyFixe
         &self,
         frame: &BodyFixed<O>,
         time: T,
-        provider: &P,
+        _provider: &P,
     ) -> Result<Rotation, Self::Error> {
         // FIXME
         let seconds = time.seconds_since_j2000();

crates/lox-orbits/src/python.rs

@@ -27,19 +27,13 @@ use lox_time::python::time_scales::PyTimeScale;
 use lox_time::python::ut1::{PyNoOpOffsetProvider, PyUt1Provider};
 use lox_time::time_scales::Tai;
 use lox_time::transformations::TryToScale;
-use lox_time::{python::time::PyTime, ut1::DeltaUt1Tai, Time};
+use lox_time::{python::time::PyTime, ut1::DeltaUt1Tai};
 
 use crate::analysis::{ElevationMask, ElevationMaskError};
 use crate::elements::{DynKeplerian, Keplerian};
 use crate::events::{Event, FindEventError, Window};
-use crate::frames::{
-    BodyFixed, CoordinateSystem, DynFrame, ReferenceFrame, TryRotateTo, TryToFrame,
-    UnknownFrameError,
-};
-use crate::ground::{
-    DynGroundLocation, DynGroundPropagator, GroundLocation, GroundPropagator,
-    GroundPropagatorError, Observables,
-};
+use crate::frames::{CoordinateSystem, DynFrame, ReferenceFrame, TryRotateTo, UnknownFrameError};
+use crate::ground::{DynGroundLocation, DynGroundPropagator, GroundPropagatorError, Observables};
 use crate::propagators::semi_analytical::{Vallado, ValladoError};
 use crate::propagators::sgp4::{Sgp4, Sgp4Error};
 use crate::propagators::Propagator;
@@ -123,7 +117,7 @@ impl From<UnknownFrameError> for PyErr {
 
 #[pyclass(name = "Frame", module = "lox_space", frozen)]
 #[pyo3(eq)]
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
+#[derive(Debug, Clone, Default, Eq, PartialEq, Ord, PartialOrd)]
 pub struct PyFrame(DynFrame);
 
 #[pymethods]
@@ -146,12 +140,6 @@ impl PyFrame {
     }
 }
 
-impl Default for PyFrame {
-    fn default() -> Self {
-        Self(DynFrame::default())
-    }
-}
-
 impl FrameTransformationProvider for DeltaUt1Tai {}
 
 impl FrameTransformationProvider for PyNoOpOffsetProvider {}
@@ -258,9 +246,7 @@ impl PyState {
             ));
         }
         Ok(PyKeplerian(
-            self.0
-                .try_to_keplerian()
-                .map_err(|err| PyValueError::new_err(err))?,
+            self.0.try_to_keplerian().map_err(PyValueError::new_err)?,
         ))
     }
 
@@ -270,15 +256,12 @@ impl PyState {
                 "only inertial frames are supported for the LVLH rotation matrix",
             ));
         }
-        let rot = self
-            .0
-            .try_rotation_lvlh()
-            .map_err(|err| PyValueError::new_err(err))?;
+        let rot = self.0.try_rotation_lvlh().map_err(PyValueError::new_err)?;
         let rot: Vec<Vec<f64>> = rot.to_cols_array_2d().iter().map(|v| v.to_vec()).collect();
         Ok(PyArray2::from_vec2_bound(py, &rot)?)
     }
 
-    fn to_ground_location(&self, py: Python<'_>) -> PyResult<PyGroundLocation> {
+    fn to_ground_location(&self) -> PyResult<PyGroundLocation> {
         Ok(PyGroundLocation(
             self.0
                 .to_dyn_ground_location()
@@ -407,7 +390,7 @@ impl PyTrajectory {
         }
         let mut states: Vec<DynState<PyTime>> = Vec::with_capacity(array.nrows());
         for row in array.rows() {
-            let time = PyTime(start_time.0 + TimeDelta::from_decimal_seconds(row[0]).unwrap());
+            let time = PyTime(start_time.0 + TimeDelta::from_decimal_seconds(row[0])?);
             let position = DVec3::new(row[1], row[2], row[3]);
             let velocity = DVec3::new(row[4], row[5], row[6]);
             states.push(State::new(time, position, velocity, origin.0, frame.0));
@@ -594,7 +577,7 @@ impl PyGroundLocation {
     fn new(origin: PyOrigin, longitude: f64, latitude: f64, altitude: f64) -> PyResult<Self> {
         Ok(PyGroundLocation(
             DynGroundLocation::with_dynamic(longitude, latitude, altitude, origin.0)
-                .map_err(|err| PyValueError::new_err(err))?,
+                .map_err(PyValueError::new_err)?,
         ))
     }
 
@@ -662,11 +645,7 @@ impl PyGroundPropagator {
         if let Ok(time) = steps.extract::<PyTime>() {
             return Ok(Bound::new(
                 py,
-                PyState(
-                    self.0
-                        .propagate_dyn(time)
-                        .map_err(|err| PyValueError::new_err(err))?,
-                ),
+                PyState(self.0.propagate_dyn(time).map_err(PyValueError::new_err)?),
             )?
             .into_any());
         }
@@ -676,7 +655,7 @@ impl PyGroundPropagator {
                 PyTrajectory(
                     self.0
                         .propagate_all_dyn(steps)
-                        .map_err(|err| PyValueError::new_err(err))?,
+                        .map_err(PyValueError::new_err)?,
                 ),
             )?
             .into_any());

crates/lox-orbits/src/states.rs

@@ -208,25 +208,6 @@ fn eccentricity_vector(r: DVec3, v: DVec3, mu: f64) -> DVec3 {
     ((v2 - mu / rm) * r - rv * v) / mu
 }
 
-impl<T, O, R> State<T, O, R>
-where
-    T: TimeLike,
-    O: PointMass,
-    R: ReferenceFrame,
-{
-    fn eccentricity_vector(&self) -> DVec3 {
-        let r = self.position();
-        let v = self.velocity();
-        let mu = self.origin.gravitational_parameter();
-
-        let rm = r.length();
-        let v2 = v.dot(v);
-        let rv = r.dot(v);
-
-        ((v2 - mu / rm) * r - rv * v) / mu
-    }
-}
-
 impl<T, O, R> CoordinateSystem<R> for State<T, O, R>
 where
     T: TimeLike,