lambert_izzo 2.0.0

Izzo's revisited Lambert solver (single & multi-rev, short & long way), no_std-friendly
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Input-validation error variants. Each test exercises one structured
//! error variant and asserts the typed payload (no string parsing).

use lambert_izzo_test_support::bodies::MU_EARTH;

use crate::{
    LambertError, LambertInput, NonFiniteParameter, Position, RevolutionBudget, TransferWay,
    constants, lambert,
};

fn valid() -> LambertInput {
    LambertInput {
        r1: [7000.0, 0.0, 0.0],
        r2: [0.0, 7000.0, 0.0],
        tof: 1000.0,
        mu: MU_EARTH,
        way: TransferWay::Short,
        revolutions: RevolutionBudget::SingleOnly,
    }
}

#[test]
fn errors_on_non_positive_tof() {
    let input = LambertInput { tof: 0.0, ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(matches!(err, LambertError::NonPositiveTimeOfFlight { tof } if tof == 0.0));
}

#[test]
fn errors_on_zero_position_vector() {
    let input = LambertInput { r1: [0.0, 0.0, 0.0], ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(matches!(
        err,
        LambertError::DegeneratePositionVector {
            position: Position::R1,
            ..
        }
    ));
}

#[test]
fn errors_on_colinear_geometry() {
    let input = LambertInput { r2: [14_000.0, 0.0, 0.0], ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(matches!(err, LambertError::CollinearGeometry { .. }));
}

#[test]
fn errors_on_transfer_angle_exactly_zero() {
    // r1 ∥ r2, same direction — sin(θ) = 0 exactly, contract is
    // |sin_angle| < COLINEARITY_TOL.
    let input = LambertInput { r2: [21_000.0, 0.0, 0.0], ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(
        matches!(
            err,
            LambertError::CollinearGeometry { sin_angle }
                if sin_angle.abs() < constants::COLINEARITY_TOL
        ),
        "expected CollinearGeometry near 0, got {err:?}",
    );
}

#[test]
fn errors_on_transfer_angle_exactly_pi() {
    // r1 anti-parallel to r2 — sin(θ) = 0 exactly, θ = π. Contract is
    // |sin_angle| < COLINEARITY_TOL.
    let input = LambertInput { r2: [-7000.0, 0.0, 0.0], ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(
        matches!(
            err,
            LambertError::CollinearGeometry { sin_angle }
                if sin_angle.abs() < constants::COLINEARITY_TOL
        ),
        "expected CollinearGeometry near π, got {err:?}",
    );
}

#[test]
fn errors_on_non_positive_mu() {
    let input = LambertInput { mu: 0.0, ..valid() };
    let err = lambert(&input).unwrap_err();
    assert!(matches!(err, LambertError::NonPositiveMu { mu } if mu == 0.0));
}

#[test]
fn errors_on_non_finite_inputs() {
    let bad_tof = LambertInput { tof: f64::NAN, ..valid() };
    let err = lambert(&bad_tof).unwrap_err();
    assert!(matches!(
        err,
        LambertError::NonFiniteInput {
            parameter: NonFiniteParameter::Tof,
            ..
        }
    ));

    let bad_r1 = LambertInput { r1: [7000.0, f64::INFINITY, 0.0], ..valid() };
    let err = lambert(&bad_r1).unwrap_err();
    assert!(matches!(
        err,
        LambertError::NonFiniteInput {
            parameter: NonFiniteParameter::R1Y,
            ..
        }
    ));
}