keplerian 0.2.1

Domain-agnostic Keplerian dynamics: typed anomaly solvers, elements, propagation, Lambert, and transfer search.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Vallés Puig, Ramon

//! Top-level error aggregation for crate workflows.
//!
//! ## Scientific scope
//! This module does not add new orbital mechanics. It only bundles the error
//! taxonomies of anomaly conversion, element conversion, propagation, and
//! Lambert solving.
//!
//! ## Technical scope
//! [`KeplerError`] is a convenience enum for callers that want one top-level
//! error type across multiple subsystems.
//!
//! ## References
//! - This module aggregates the references documented by the submodules it wraps.

use crate::{anomaly, elements, lambert, problem};

/// Unified error type for high-level Keplerian workflows.
#[derive(Debug, thiserror::Error)]
pub enum KeplerError {
    /// An anomaly conversion or solver failed.
    #[error(transparent)]
    Anomaly(anomaly::AnomalyError),
    /// Cartesian/element conversion failed.
    #[error(transparent)]
    Conversion(elements::ConversionError),
    /// Two-body propagation failed.
    #[error(transparent)]
    Propagation(problem::PropagationError),
    /// Lambert solving failed.
    #[error(transparent)]
    Lambert(lambert::LambertError),
}

impl From<anomaly::AnomalyError> for KeplerError {
    fn from(value: anomaly::AnomalyError) -> Self {
        Self::Anomaly(value)
    }
}

impl From<elements::ConversionError> for KeplerError {
    fn from(value: elements::ConversionError) -> Self {
        Self::Conversion(value)
    }
}

impl From<problem::PropagationError> for KeplerError {
    fn from(value: problem::PropagationError) -> Self {
        Self::Propagation(value)
    }
}

impl From<lambert::LambertError> for KeplerError {
    fn from(value: lambert::LambertError) -> Self {
        Self::Lambert(value)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn kepler_error_from_anomaly() {
        let inner = anomaly::AnomalyError::InvalidEccentricity(1.5);
        let e = KeplerError::from(inner);
        assert!(matches!(e, KeplerError::Anomaly(_)));
    }

    #[test]
    fn kepler_error_from_conversion() {
        let inner = elements::ConversionError::InvalidEccentricity(-1.0);
        let e = KeplerError::from(inner);
        assert!(matches!(e, KeplerError::Conversion(_)));
    }

    #[test]
    fn kepler_error_from_propagation() {
        let inner = problem::PropagationError::ParabolicUnsupported;
        let e = KeplerError::from(inner);
        assert!(matches!(e, KeplerError::Propagation(_)));
    }

    #[test]
    fn kepler_error_from_lambert() {
        let inner = lambert::LambertError::ZeroPosition;
        let e = KeplerError::from(inner);
        assert!(matches!(e, KeplerError::Lambert(_)));
    }
}