siderust 0.7.0

High-precision astronomy and satellite mechanics in Rust.
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

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

use siderust::bodies::solar_system::Mars;
use siderust::coordinates::{
    cartesian,
    centers::*,
    frames::*,
    spherical,
    transform::{Transform, TransformFrame},
};
use siderust::qtty::*;
use siderust::targets::CoordinateWithPM;
use siderust::time::JulianDate;

const EPS: f64 = 1e-9;

#[test]
fn target_cartesian_position_transform() {
    let jd = JulianDate::J2000;
    let orig: CoordinateWithPM<
        cartesian::Position<Heliocentric, EclipticMeanJ2000, AstronomicalUnit>,
    > = CoordinateWithPM::new_static(Mars::vsop87a(jd), jd);

    let converted: CoordinateWithPM<
        cartesian::Position<Geocentric, EquatorialMeanJ2000, AstronomicalUnit>,
    > = CoordinateWithPM::from(&orig);

    let step: cartesian::Position<Heliocentric, EquatorialMeanJ2000, AstronomicalUnit> =
        orig.position.transform(jd);
    let expected: cartesian::Position<Geocentric, EquatorialMeanJ2000, AstronomicalUnit> =
        step.transform(jd);

    assert!(converted.position.distance_to(&expected).value() < EPS);
    assert_eq!(converted.time, orig.time);
    assert_eq!(
        converted.proper_motion.is_none(),
        orig.proper_motion.is_none()
    );
}

#[test]
fn target_spherical_position_transform() {
    let jd = JulianDate::J2000;
    let cart_orig: CoordinateWithPM<
        cartesian::Position<Heliocentric, EclipticMeanJ2000, AstronomicalUnit>,
    > = CoordinateWithPM::new_static(Mars::vsop87a(jd), jd);
    let sph_pos: spherical::Position<Heliocentric, EclipticMeanJ2000, AstronomicalUnit> =
        spherical::Position::from_cartesian(&cart_orig.position);
    let orig: CoordinateWithPM<
        spherical::Position<Heliocentric, EclipticMeanJ2000, AstronomicalUnit>,
    > = CoordinateWithPM::new_static(sph_pos, jd);

    let converted: CoordinateWithPM<
        spherical::Position<Geocentric, EquatorialMeanJ2000, AstronomicalUnit>,
    > = CoordinateWithPM::from(&orig);

    let step_cart: cartesian::Position<Heliocentric, EquatorialMeanJ2000, AstronomicalUnit> =
        orig.position.to_cartesian().transform(jd);
    let expected_cart: cartesian::Position<Geocentric, EquatorialMeanJ2000, AstronomicalUnit> =
        step_cart.transform(jd);
    let converted_cart = converted.position.to_cartesian();

    assert!(converted_cart.distance_to(&expected_cart).value() < EPS);
    assert_eq!(converted.time, orig.time);
    assert_eq!(
        converted.proper_motion.is_none(),
        orig.proper_motion.is_none()
    );
}

#[test]
fn cartesian_direction_frame_transform() {
    // Directions are now frame-only (no center parameter).
    // They can only undergo frame transformations, not center transformations.
    let dir = cartesian::Direction::<EclipticMeanJ2000>::normalize(1.0, 0.5, 0.2);

    // Frame transform from EclipticMeanJ2000 to EquatorialMeanJ2000 (rotation only)
    let dir_equatorial: cartesian::Direction<EquatorialMeanJ2000> = TransformFrame::to_frame(&dir);

    // Verify it's still a unit vector
    let norm =
        (dir_equatorial.x().powi(2) + dir_equatorial.y().powi(2) + dir_equatorial.z().powi(2))
            .sqrt();
    assert!((norm - 1.0).abs() < 1e-12);

    // X component is unchanged in ecliptic/equatorial rotation
    assert!((dir_equatorial.x() - dir.x()).abs() < 1e-12);
}

#[test]
fn spherical_direction_frame_transform() {
    // Directions are now frame-only (no center parameter).
    let sph_dir =
        spherical::Direction::<EclipticMeanJ2000>::new(Degrees::new(10.0), Degrees::new(20.0));

    // Convert to cartesian, transform frame, then back
    let cart_dir = sph_dir.to_cartesian();
    let cart_equatorial: cartesian::Direction<EquatorialMeanJ2000> =
        TransformFrame::to_frame(&cart_dir);

    // Verify the Cartesian direction is still unit vector
    let norm =
        (cart_equatorial.x().powi(2) + cart_equatorial.y().powi(2) + cart_equatorial.z().powi(2))
            .sqrt();
    assert!((norm - 1.0).abs() < 1e-12);
}