Struct Position 

pub struct Position {
    pub x: f64,
    pub y: f64,
    pub z: f64,
}

3D position vector

Fields

x: f64

X coordinate (AU)

y: f64

Y coordinate (AU)

z: f64

Z coordinate (AU)

Implementations

impl Position

pub fn new(x: f64, y: f64, z: f64) -> Self

Create a new position

pub fn distance(&self) -> f64

Calculate distance from origin

Examples found in repository

examples/planetary_positions.rs (line 45)

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/basic_usage.rs (line 98)

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 Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Position

impl Debug for Position

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

Formats the value using the given formatter.

impl PartialEq for Position

fn eq(&self, other: &Position) -> 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 StructuralPartialEq for Position