Struct Moon 

pub struct Moon {
    pub epoch: f64,
    pub l0: f64,
    pub n0: f64,
    pub i: Angle,
    pub e: f64,
    pub a: f64,
    pub theta0: Angle,
    pub pi0: Angle,
}

Structure for the moons orbital properties at an epoch.

There’s only one moon, but having the data and routines all in one type is cleaner. The data contained in this is floating point instead of the Time/Coordinate types provided because static Time/Angle/Coordinate data using those types is unpleasant to construct. And because the code I’ve written before works with floats.

Fields

epoch: f64

The epoch on which this data is based off

l0: f64

Mean Longitude

n0: f64

Mean Longitude of the node

i: Angle

Inclination

e: f64

Eccentricity

a: f64

Semi-major axis

theta0: Angle

Angular size at 1AU

pi0: Angle

Parallax at 1AU

Implementations

impl Moon

pub fn locationcart(self, d: Date) -> (f64, f64, f64)

Gets the cartesian coordinates of the moon in AU

pub fn phaseage(self, d: Date) -> f64

Returns age of phase in Days

Examples found in repository

examples/mprintf.rs (line 34)

fn main() {
    let p = (
        moon::MOON.illumfrac(time::Date::now()),
        moon::MOON.phaseage(time::Date::now()),
    );
    println!(
        "{} {} ({:.2}%)",
        PNAMES[phaseidx(p.0, p.1)],
        EMOJIS[phaseidx(p.0, p.1)],
        p.0 * 100.0
    );
}

pub fn illumfrac(self, d: Date) -> f64

Returns the illuminated fraction of the Moons surface

Examples found in repository

examples/mprintf.rs (line 33)

fn main() {
    let p = (
        moon::MOON.illumfrac(time::Date::now()),
        moon::MOON.phaseage(time::Date::now()),
    );
    println!(
        "{} {} ({:.2}%)",
        PNAMES[phaseidx(p.0, p.1)],
        EMOJIS[phaseidx(p.0, p.1)],
        p.0 * 100.0
    );
}

examples/speed.rs (line 28)

fn main() {
    let n = 40000;
    println!("Test,Mean (n={}),Full", n);

    run_test("Control (NOP)", n, || ());
    run_test("Current time", n, || {
        time::Date::now();
    });
    fn ephem() {
        let now = time::Date::now();
        for p in sol::PLANETS {
            let (ra, de) = p.location(now).equatorial();
            (ra.clock(), de.to_latitude().degminsec());
        }
    }
    run_test("Full ephemeris", n, ephem);
    run_test("Moon Phase", n, || {
        moon::MOON.illumfrac(time::Date::now());
    });
}

pub fn phaseangle(self, d: Date) -> Angle

Returns the phase angle of the moon

pub fn location(self, d: Date) -> Coord

Returns the coordinates of the moon

This code has a low accuracy of around 5 degrees

pub fn distance(self, d: Date) -> f64

Returns the distance to the moon in AU

pub fn angdia(self, d: Date) -> Angle

Returns angular diameter of the planet at current time

pub fn parallax(self, d: Date) -> Angle

Calculates the moons horizontal parallax

pub fn magnitude(self, d: Date) -> f64

Magnitude of the moon

Trait Implementations

impl Clone for Moon

fn clone(&self) -> Moon

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Moon