erfars 0.2.0

Safe Rust bindings to the Essential Routines for Fundamental Astronomy (ERFA) C library.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

//! ERFA Star Catalog Functions

use crate::{ERFAResult, raw::starcatalogs::*, unexpected_val_err};

/// Convert B1950.0 FK4 star catalog data to J2000.0 FK5.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk425.c)
pub fn Fk425(r1950: f64, d1950: f64, dr1950: f64, dd1950: f64, p1950: f64, v1950: f64) -> (f64, f64, f64, f64, f64, f64) {
    let mut r2000: f64 = 0.0;
    let mut d2000: f64 = 0.0;
    let mut dr2000: f64 = 0.0;
    let mut dd2000: f64 = 0.0;
    let mut p2000: f64 = 0.0;
    let mut v2000: f64 = 0.0;

    unsafe {
        eraFk425(r1950, d1950, dr1950, dd1950, p1950, v1950, &mut r2000, &mut d2000, &mut dr2000, &mut dd2000, &mut p2000, &mut v2000);
    }

    return (r2000, d2000, dr2000, dd2000, p2000, v2000);
}

/// Convert a B1950.0 FK4 star position to J2000.0 FK5, assuming zero proper
/// motion in the FK5 system.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk45z.c)
pub fn Fk45z(r1950: f64, d1950: f64, bepoch: f64) -> (f64, f64) {
    let mut r2000: f64 = 0.0;
    let mut d2000: f64 = 0.0;

    unsafe {
        eraFk45z(r1950, d1950, bepoch, &mut r2000, &mut d2000);
    }

    return (r2000, d2000);
}

/// Convert J2000.0 FK5 star catalog data to B1950.0 FK4.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk524.c)
pub fn Fk524(r2000: f64, d2000: f64, dr2000: f64, dd2000: f64, p2000: f64, v2000: f64) -> (f64, f64, f64, f64, f64, f64) {
    let mut r1950: f64 = 0.0;
    let mut d1950: f64 = 0.0;
    let mut dr1950: f64 = 0.0;
    let mut dd1950: f64 = 0.0;
    let mut p1950: f64 = 0.0;
    let mut v1950: f64 = 0.0;

    unsafe {
        eraFk524(r2000, d2000, dr2000, dd2000, p2000, v2000, &mut r1950, &mut d1950, &mut dr1950, &mut dd1950, &mut p1950, &mut v1950);
    }

    return (r1950, d1950, dr1950, dd1950, p1950, v1950);
}

/// Transform FK5 (J2000.0) star data into the Hipparcos system.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk52h.c)
pub fn Fk52h(r5: f64, d5: f64, dr5: f64, dd5: f64, px5: f64, rv5: f64) -> (f64, f64, f64, f64, f64, f64) {
    let mut rh: f64 = 0.0;
    let mut dh: f64 = 0.0;
    let mut drh: f64 = 0.0;
    let mut ddh: f64 = 0.0;
    let mut pxh: f64 = 0.0;
    let mut rvh: f64 = 0.0;

    unsafe {
        eraFk52h(r5, d5, dr5, dd5, px5, rv5, &mut rh, &mut dh, &mut drh, &mut ddh, &mut pxh, &mut rvh);
    }

    return (rh, dh, drh, ddh, pxh, rvh);
}

/// Convert a J2000.0 FK5 star position to B1950.0 FK4, assuming zero proper
/// motion in FK5 and parallax.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk54z.c)
pub fn Fk54z(r2000: f64, d2000: f64, bepoch: f64) -> (f64, f64, f64, f64) {
    let mut r1950: f64 = 0.0;
    let mut d1950: f64 = 0.0;
    let mut dr1950: f64 = 0.0;
    let mut dd1950: f64 = 0.0;

    unsafe {
        eraFk54z(r2000, d2000, bepoch, &mut r1950, &mut d1950, &mut dr1950, &mut dd1950);
    }

    return (r1950, d1950, dr1950, dd1950);
}

/// FK5 to Hipparcos rotation and spin.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk5hip.c)
pub fn Fk5hip() -> ([f64; 9], [f64; 3]) {
    let mut r5h: [f64; 9] = [0.0; 9];
    let mut s5h: [f64; 3] = [0.0; 3];

    unsafe {
        eraFk5hip(&mut r5h, &mut s5h);
    }

    return (r5h, s5h);
}

/// Transform an FK5 (J2000.0) star position into the system of the Hipparcos
/// catalog, assuming zero Hipparcos proper motion.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/fk5hz.c)
pub fn Fk5hz(r5: f64, d5: f64, date1: f64, date2: f64) -> (f64, f64) {
    let mut rh: f64 = 0.0;
    let mut dh: f64 = 0.0;

    unsafe {
        eraFk5hz(r5, d5, date1, date2, &mut rh, &mut dh);
    }

    return (rh, dh);
}

/// Transform Hipparcos star data into the FK5 (J2000.0) system.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/h2fk5.c)
pub fn H2fk5(rh: f64, dh: f64, drh: f64, ddh: f64, pxh: f64, rvh: f64) -> (f64, f64, f64, f64, f64, f64) {
    let mut r5: f64 = 0.0;
    let mut d5: f64 = 0.0;
    let mut dr5: f64 = 0.0;
    let mut dd5: f64 = 0.0;
    let mut px5: f64 = 0.0;
    let mut rv5: f64 = 0.0;

    unsafe {
        eraH2fk5(rh, dh, drh, ddh, pxh, rvh, &mut r5, &mut d5, &mut dr5, &mut dd5, &mut px5, &mut rv5);
    }

    return (r5, d5, dr5, dd5, px5, rv5);
}

/// Transform a Hipparcos star position into FK5 J2000.0, assuming zero
/// Hipparcos proper motion.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/hfk5z.c)
pub fn Hfk5z(rh: f64, dh: f64, date1: f64, date2: f64) -> (f64, f64, f64, f64) {
    let mut r5: f64 = 0.0;
    let mut d5: f64 = 0.0;
    let mut dr5: f64 = 0.0;
    let mut dd5: f64 = 0.0;

    unsafe {
        eraHfk5z(rh, dh, date1, date2, &mut r5, &mut d5, &mut dr5, &mut dd5);
    }

    return (r5, d5, dr5, dd5);
}

/// Star proper motion: update star catalog data for space motion.
///
/// Please see the full ERFA docs for this function [here](https://github.com/liberfa/erfa/blob/master/src/starpm.c)
pub fn Starpm(ra1: f64, dec1: f64, pmr1: f64, pmd1: f64, px1: f64, rv1: f64, ep1a: f64, ep1b: f64, ep2a: f64, ep2b: f64) -> ERFAResult<(f64, f64, f64, f64, f64, f64)> {
    let mut ra2: f64 = 0.0;
    let mut dec2: f64 = 0.0;
    let mut pmr2: f64 = 0.0;
    let mut pmd2: f64 = 0.0;
    let mut px2: f64 = 0.0;
    let mut rv2: f64 = 0.0;
    let err: i32;

    unsafe { err = eraStarpm(ra1, dec1, pmr1, pmd1, px1, rv1, ep1a, ep1b, ep2a, ep2b, &mut ra2, &mut dec2, &mut pmr2, &mut pmd2, &mut px2, &mut rv2) }

    if err >= 0 {
        return Ok(((ra2, dec2, pmr2, pmd2, px2, rv2), err));
    } else if err == -1 {
        return Err(-1);
    } else {
        unexpected_val_err!(eraStarpm)
    }
}