Contents
This project is currently a work in progress. Some APIs may be updated occasionally.
astro-rust is an MIT licensed library of astronomical algorithms for the Rust programming language.
Implemented capabilities include planetary, solar, lunar and planetary satellite positioning, corrections for precession, nutation, parallax, and aberration, calculation of physical ephemeris of Mars, Jupiter, and the ring system of Saturn, and finding times of rise, set and transit of celestial bodies (and much more).
The main reference used as the source of algorithms is the famous book Astronomical Algorithms by Jean Meeus, whose almost every chapter has been addressed here, with functions that are well-documented and tests that use example data from the book; in some cases such as ΔT approximation and planetary heliocentric positioning, more accurate methods have been implemented (from sources mentioned in the references section).
The end goal (of this project) is to build a modern, well-tested, well-documented library of algorithms for future use in astronomy. And doing it all in Rust is very much a part of that.
Add the dependency astro in your Cargo.toml
toml
[dependencies]
astro = "1.0.1"
Include the crate astro in your code
```rust
extern crate astro;
use astro::*; ```
Find the Julian day (the most important step for almost everything) ```rust // time of the Apollo 11 moon landing
let dayofmonth = time::DayOfMonth{day: 20, hr : 20, min: 18, sec: 4.0, time_zone: 0.0 // at Greenwhich };
let date = time::Date{year : 1969, month : 7, // July decimalday: time::decimalday(&dayofmonth), cal_type : time::CalType::Gregorian};
let julianday = time::julianday(&date);
// for higher accuracy in specifying the time of interest, // find the Julian Ephemeris day; // calculate delta T using the built-in function, or get an observed // value from the Astronomical Almanac
let deltat = time::approxdelta_t(date.year, date.month);
let julianephmday = time::julianemphday(julianday, deltat); ```
Solar and Lunar positioning ```rust
// find the geocentric ecliptic point and radius vector of the Sun
let (suneclpoint, radvecsun) = sun::geoceneclpos(julian_day);
// suneclpoint.long - ecliptic longitude (radians) // suneclpoint.lat - ecliptic latitude (radians) // radvecsun - distance between the Sun and the Earth (AU)
// and similarly for the Moon
let (mooneclpoint, radvecmoon) = lunar::geoceneclpos(julian_day);
```
Planetary position ```rust // find the heliocentric point and radius vector of Jupiter
let (long, lat, radvec) = planet::heliocenpos(&planet::Planet::Jupiter, julian_day); ```
Correct for nutation ```rust // find the nutation in ecliptic longitude and obliquity of the ecliptic
let (nutinlong, nutinoblq) = nutation::nutation(julian_day); ```
Geodesic distance between two locations on Earth ```rust // geodesic distance between the Observatoire de Paris and // the US Naval Observatory at Washington DC
let paris = coords::GeographPoint{long: angle::degfrmdms(-2, 20, 14.0).toradians(), lat : angle::degfrmdms(48, 50, 11.0).toradians()};
let washington = coords::GeographPoint{long: angle::degfrmdms(77, 3, 56.0).toradians(), lat : angle::degfrmdms(38, 55, 17.0).toradians()};
// angle::degfrmdms() converts degrees expressed in degrees, // minutes and seconds into a fractional degree
let distance = planet::earth::geodesic_dist(&paris, &washington); // in meters ```
Convert equatorial coordinates to ecliptic coordinates ```rust // equatorial coordinates of the star Pollux
let rightascension = 116.328942f64.toradians(); let declination = 28.026183f64.to_radians();
// mean obliquity of the ecliptic
let oblqeclip = 23.4392911f64.to_radians();
// you can also get oblqeclip from ecliptic::mnoblqIAU(julianday) // for the Julian day on which the coordinates of the star // were observed
// also make sure to type #[macro_use] before including the crate // to use macros
// now, convert equatorial coordinates to ecliptic coordinates
let (ecllong, ecllat) = eclfrmeq!(rightascension, declination, oblqeclip); ```
Convert equatorial coordinates to galactic coordinates ```rust // equatorial coordinates of the Nova Serpentis 1978
let rightascension = angle::degfrmhms(17, 48, 59.74).toradians(); let declination = angle::degfrmdms(-14, 43, 8.2).to_radians();
// convert to galactic coordinates
let (gallong, gallat) = galfrmeq!(right_ascension, declination); ```
For information on the modules and functions available, see the Rust API Documentation.
The following is a categorical high level listing of all the physical quantities you can calculate or actions you can perform, using the algorithms that have been implemented so far:
Anyone interested to contribute in any way possible is encouraged to do so. Not all the algorithms in Meeus's book have been implemented yet. Documentation and tests need to be written for them as well. Refactored code and minor optimizations for the existing code are also welcome.
A fun suggestion is the addition of the recent IAU 2000/2006 precession-nutation model. This method improves upon the existing model implemented here "by taking into account the effect of mantle anelasticity, ocean tides, electromagnetic couplings produced between the fluid outer core and the mantle as well as between the solid inner core and fluid outer core".