Struct JulianDate 

pub struct JulianDate {
    pub jd: f64,
}

Represents a Julian Date (JD)

Fields

jd: f64

Julian day number

Implementations

impl JulianDate

pub fn new(jd: f64) -> Self

Create a Julian date from a Julian day number

Examples found in repository

examples/time_conversion.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Time Conversion Examples ===\n");

    // Example 1: Convert calendar date to Julian date
    println!("Example 1: Calendar to Julian Date");
    let cal = CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    let jd = cal.to_julian()?;
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        cal.year, cal.month, cal.day, cal.hour, cal.minute, cal.second as i32
    );
    println!("  Julian Date: {:.6}\n", jd.as_f64());

    // Example 2: Convert Julian date to calendar date
    println!("Example 2: Julian to Calendar Date");
    let jd2 = JulianDate::new(2460327.0); // January 15, 2024
    let cal2 = jd2.to_calendar();
    println!("  Julian Date: {:.6}", jd2.as_f64());
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        cal2.year, cal2.month, cal2.day, cal2.hour, cal2.minute, cal2.second as i32
    );

    // Example 3: Using from_calendar directly
    println!("Example 3: Direct conversion");
    let jd3 = JulianDate::from_calendar(2000, 1, 1, 12, 0, 0.0)?;
    println!("  January 1, 2000 12:00:00 UTC");
    println!("  Julian Date: {:.6}\n", jd3.as_f64());

    // Example 4: Historical dates
    println!("Example 4: Historical Dates");
    let dates = vec![
        (1969, 7, 20, 20, 17, 0.0, "Apollo 11 Moon Landing"),
        (1986, 1, 28, 11, 39, 0.0, "Space Shuttle Challenger"),
        (2021, 7, 20, 9, 13, 0.0, "Blue Origin NS-16"),
    ];

    for (year, month, day, hour, minute, second, event) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!("  {}: JD {:.6}", event, jd.as_f64());
    }

    Ok(())
}

pub fn from_calendar( year: i32, month: i32, day: i32, hour: i32, minute: i32, second: f64, ) -> Result<Self, Error>

Convert calendar date to Julian date

Arguments

• year - Year (e.g., 2024)
• month - Month (1-12)
• day - Day of month (1-31)
• hour - Hour (0-23)
• minute - Minute (0-59)
• second - Second (0-59.999…)

Example

use rust_jpl::JulianDate;
let jd = JulianDate::from_calendar(2024, 1, 15, 12, 0, 0.0);

Examples found in repository

examples/planetary_positions.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Planetary Positions Example ===\n");

    // Initialize ephemeris
    let eph = Ephemeris::new("config.toml")?;

    // Define dates to query
    let dates = vec![
        (2024, 1, 1, 0, 0, 0.0),
        (2024, 6, 15, 12, 0, 0.0),
        (2024, 12, 31, 23, 59, 59.0),
    ];

    let bodies = vec!["Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter"];

    for (year, month, day, hour, minute, second) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!(
            "Date: {}-{:02}-{:02} {:02}:{:02}:{:02} (JD: {:.6})",
            year,
            month,
            day,
            hour,
            minute,
            second as i32,
            jd.as_f64()
        );
        println!("{}", "=".repeat(70));

        for body_name in &bodies {
            match eph.get_position(body_name, jd) {
                Ok(pos) => {
                    println!(
                        "  {:10} | X: {:12.6} | Y: {:12.6} | Z: {:12.6} | Distance: {:10.6} AU",
                        body_name,
                        pos.x,
                        pos.y,
                        pos.z,
                        pos.distance()
                    );
                }
                Err(e) => {
                    println!("  {:10} | Error: {}", body_name, e);
                }
            }
        }
        println!();
    }

    Ok(())
}

examples/time_conversion.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Time Conversion Examples ===\n");

    // Example 1: Convert calendar date to Julian date
    println!("Example 1: Calendar to Julian Date");
    let cal = CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    let jd = cal.to_julian()?;
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        cal.year, cal.month, cal.day, cal.hour, cal.minute, cal.second as i32
    );
    println!("  Julian Date: {:.6}\n", jd.as_f64());

    // Example 2: Convert Julian date to calendar date
    println!("Example 2: Julian to Calendar Date");
    let jd2 = JulianDate::new(2460327.0); // January 15, 2024
    let cal2 = jd2.to_calendar();
    println!("  Julian Date: {:.6}", jd2.as_f64());
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        cal2.year, cal2.month, cal2.day, cal2.hour, cal2.minute, cal2.second as i32
    );

    // Example 3: Using from_calendar directly
    println!("Example 3: Direct conversion");
    let jd3 = JulianDate::from_calendar(2000, 1, 1, 12, 0, 0.0)?;
    println!("  January 1, 2000 12:00:00 UTC");
    println!("  Julian Date: {:.6}\n", jd3.as_f64());

    // Example 4: Historical dates
    println!("Example 4: Historical Dates");
    let dates = vec![
        (1969, 7, 20, 20, 17, 0.0, "Apollo 11 Moon Landing"),
        (1986, 1, 28, 11, 39, 0.0, "Space Shuttle Challenger"),
        (2021, 7, 20, 9, 13, 0.0, "Blue Origin NS-16"),
    ];

    for (year, month, day, hour, minute, second, event) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!("  {}: JD {:.6}", event, jd.as_f64());
    }

    Ok(())
}

pub fn to_calendar(&self) -> CalendarDate

Convert Julian date to calendar date

Examples found in repository

examples/time_conversion.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Time Conversion Examples ===\n");

    // Example 1: Convert calendar date to Julian date
    println!("Example 1: Calendar to Julian Date");
    let cal = CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    let jd = cal.to_julian()?;
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        cal.year, cal.month, cal.day, cal.hour, cal.minute, cal.second as i32
    );
    println!("  Julian Date: {:.6}\n", jd.as_f64());

    // Example 2: Convert Julian date to calendar date
    println!("Example 2: Julian to Calendar Date");
    let jd2 = JulianDate::new(2460327.0); // January 15, 2024
    let cal2 = jd2.to_calendar();
    println!("  Julian Date: {:.6}", jd2.as_f64());
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        cal2.year, cal2.month, cal2.day, cal2.hour, cal2.minute, cal2.second as i32
    );

    // Example 3: Using from_calendar directly
    println!("Example 3: Direct conversion");
    let jd3 = JulianDate::from_calendar(2000, 1, 1, 12, 0, 0.0)?;
    println!("  January 1, 2000 12:00:00 UTC");
    println!("  Julian Date: {:.6}\n", jd3.as_f64());

    // Example 4: Historical dates
    println!("Example 4: Historical Dates");
    let dates = vec![
        (1969, 7, 20, 20, 17, 0.0, "Apollo 11 Moon Landing"),
        (1986, 1, 28, 11, 39, 0.0, "Space Shuttle Challenger"),
        (2021, 7, 20, 9, 13, 0.0, "Blue Origin NS-16"),
    ];

    for (year, month, day, hour, minute, second, event) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!("  {}: JD {:.6}", event, jd.as_f64());
    }

    Ok(())
}

examples/basic_usage.rs (line 69)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Rust JPL Ephemeris Reader - Basic Usage Example ===\n");

    // Initialize the ephemeris from config.toml
    println!("1. Initializing Ephemeris...");
    let eph = Ephemeris::new("config.toml")?;
    println!("   ✓ Ephemeris loaded successfully\n");

    // Display metadata
    println!("2. Ephemeris Metadata:");
    let metadata = eph.get_metadata();
    println!(
        "   - Date Range: {} - {}",
        metadata.start_year, metadata.end_year
    );
    println!(
        "   - Julian Date Range: {:.2} - {:.2}",
        metadata.julian_start, metadata.julian_end
    );
    println!("   - Interval: {} days", metadata.interval_days);
    println!(
        "   - Earth-Moon Mass Ratio: {:.6}",
        metadata.earth_moon_ratio
    );
    println!(
        "   - Number of Coefficients: {}\n",
        metadata.number_of_coefficients
    );

    // List available bodies
    println!("3. Available Celestial Bodies:");
    for body in eph.get_bodies() {
        let status = if body.active { "✓" } else { "✗" };
        println!(
            "   {} {} ({})",
            status,
            body.name,
            if body.active { "active" } else { "inactive" }
        );
    }
    println!();

    // Time conversion example
    println!("4. Time Conversion Example:");
    let calendar_date = rust_jpl::CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    println!(
        "   Calendar Date: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        calendar_date.year,
        calendar_date.month,
        calendar_date.day,
        calendar_date.hour,
        calendar_date.minute,
        calendar_date.second as i32
    );

    let jd = calendar_date.to_julian()?;
    println!("   Julian Date: {:.6}", jd.as_f64());

    let converted_back = jd.to_calendar();
    println!(
        "   Converted back: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        converted_back.year,
        converted_back.month,
        converted_back.day,
        converted_back.hour,
        converted_back.minute,
        converted_back.second as i32
    );

    // Get planetary positions
    println!(
        "5. Planetary Positions (at Julian Date {:.6}):",
        jd.as_f64()
    );
    let bodies = [
        "Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn",
    ];

    for body_name in &bodies {
        match eph.get_position(body_name, jd) {
            Ok(pos) => {
                println!(
                    "   {}: ({:12.6}, {:12.6}, {:12.6}) AU, Distance: {:.6} AU",
                    body_name,
                    pos.x,
                    pos.y,
                    pos.z,
                    pos.distance()
                );
            }
            Err(e) => {
                println!("   {}: Error - {}", body_name, e);
            }
        }
    }

    println!("\n=== Example Complete ===");
    Ok(())
}

pub fn as_f64(&self) -> f64

Get the Julian day number

Examples found in repository

examples/planetary_positions.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Planetary Positions Example ===\n");

    // Initialize ephemeris
    let eph = Ephemeris::new("config.toml")?;

    // Define dates to query
    let dates = vec![
        (2024, 1, 1, 0, 0, 0.0),
        (2024, 6, 15, 12, 0, 0.0),
        (2024, 12, 31, 23, 59, 59.0),
    ];

    let bodies = vec!["Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter"];

    for (year, month, day, hour, minute, second) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!(
            "Date: {}-{:02}-{:02} {:02}:{:02}:{:02} (JD: {:.6})",
            year,
            month,
            day,
            hour,
            minute,
            second as i32,
            jd.as_f64()
        );
        println!("{}", "=".repeat(70));

        for body_name in &bodies {
            match eph.get_position(body_name, jd) {
                Ok(pos) => {
                    println!(
                        "  {:10} | X: {:12.6} | Y: {:12.6} | Z: {:12.6} | Distance: {:10.6} AU",
                        body_name,
                        pos.x,
                        pos.y,
                        pos.z,
                        pos.distance()
                    );
                }
                Err(e) => {
                    println!("  {:10} | Error: {}", body_name, e);
                }
            }
        }
        println!();
    }

    Ok(())
}

examples/time_conversion.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Time Conversion Examples ===\n");

    // Example 1: Convert calendar date to Julian date
    println!("Example 1: Calendar to Julian Date");
    let cal = CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    let jd = cal.to_julian()?;
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        cal.year, cal.month, cal.day, cal.hour, cal.minute, cal.second as i32
    );
    println!("  Julian Date: {:.6}\n", jd.as_f64());

    // Example 2: Convert Julian date to calendar date
    println!("Example 2: Julian to Calendar Date");
    let jd2 = JulianDate::new(2460327.0); // January 15, 2024
    let cal2 = jd2.to_calendar();
    println!("  Julian Date: {:.6}", jd2.as_f64());
    println!(
        "  Calendar: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        cal2.year, cal2.month, cal2.day, cal2.hour, cal2.minute, cal2.second as i32
    );

    // Example 3: Using from_calendar directly
    println!("Example 3: Direct conversion");
    let jd3 = JulianDate::from_calendar(2000, 1, 1, 12, 0, 0.0)?;
    println!("  January 1, 2000 12:00:00 UTC");
    println!("  Julian Date: {:.6}\n", jd3.as_f64());

    // Example 4: Historical dates
    println!("Example 4: Historical Dates");
    let dates = vec![
        (1969, 7, 20, 20, 17, 0.0, "Apollo 11 Moon Landing"),
        (1986, 1, 28, 11, 39, 0.0, "Space Shuttle Challenger"),
        (2021, 7, 20, 9, 13, 0.0, "Blue Origin NS-16"),
    ];

    for (year, month, day, hour, minute, second, event) in dates {
        let jd = JulianDate::from_calendar(year, month, day, hour, minute, second)?;
        println!("  {}: JD {:.6}", event, jd.as_f64());
    }

    Ok(())
}

examples/basic_usage.rs (line 67)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Rust JPL Ephemeris Reader - Basic Usage Example ===\n");

    // Initialize the ephemeris from config.toml
    println!("1. Initializing Ephemeris...");
    let eph = Ephemeris::new("config.toml")?;
    println!("   ✓ Ephemeris loaded successfully\n");

    // Display metadata
    println!("2. Ephemeris Metadata:");
    let metadata = eph.get_metadata();
    println!(
        "   - Date Range: {} - {}",
        metadata.start_year, metadata.end_year
    );
    println!(
        "   - Julian Date Range: {:.2} - {:.2}",
        metadata.julian_start, metadata.julian_end
    );
    println!("   - Interval: {} days", metadata.interval_days);
    println!(
        "   - Earth-Moon Mass Ratio: {:.6}",
        metadata.earth_moon_ratio
    );
    println!(
        "   - Number of Coefficients: {}\n",
        metadata.number_of_coefficients
    );

    // List available bodies
    println!("3. Available Celestial Bodies:");
    for body in eph.get_bodies() {
        let status = if body.active { "✓" } else { "✗" };
        println!(
            "   {} {} ({})",
            status,
            body.name,
            if body.active { "active" } else { "inactive" }
        );
    }
    println!();

    // Time conversion example
    println!("4. Time Conversion Example:");
    let calendar_date = rust_jpl::CalendarDate::new(2024, 1, 15, 12, 0, 0.0);
    println!(
        "   Calendar Date: {}-{:02}-{:02} {:02}:{:02}:{:02}",
        calendar_date.year,
        calendar_date.month,
        calendar_date.day,
        calendar_date.hour,
        calendar_date.minute,
        calendar_date.second as i32
    );

    let jd = calendar_date.to_julian()?;
    println!("   Julian Date: {:.6}", jd.as_f64());

    let converted_back = jd.to_calendar();
    println!(
        "   Converted back: {}-{:02}-{:02} {:02}:{:02}:{:02}\n",
        converted_back.year,
        converted_back.month,
        converted_back.day,
        converted_back.hour,
        converted_back.minute,
        converted_back.second as i32
    );

    // Get planetary positions
    println!(
        "5. Planetary Positions (at Julian Date {:.6}):",
        jd.as_f64()
    );
    let bodies = [
        "Sun", "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn",
    ];

    for body_name in &bodies {
        match eph.get_position(body_name, jd) {
            Ok(pos) => {
                println!(
                    "   {}: ({:12.6}, {:12.6}, {:12.6}) AU, Distance: {:.6} AU",
                    body_name,
                    pos.x,
                    pos.y,
                    pos.z,
                    pos.distance()
                );
            }
            Err(e) => {
                println!("   {}: Error - {}", body_name, e);
            }
        }
    }

    println!("\n=== Example Complete ===");
    Ok(())
}

Trait Implementations

impl Clone for JulianDate

fn clone(&self) -> JulianDate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JulianDate

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for JulianDate

fn eq(&self, other: &JulianDate) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for JulianDate

fn partial_cmp(&self, other: &JulianDate) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for JulianDate

impl StructuralPartialEq for JulianDate