solar-positioning 0.5.2

High-accuracy solar positioning algorithms (SPA and Grena3) for calculating sun position and sunrise/sunset/twilight times
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

//! Verify the public API surface makes sense.
//!
//! This example demonstrates all the main ways users can calculate sunrise/sunset.

use solar_positioning::{spa, Horizon, HoursUtc, SunriseResult};

fn main() -> solar_positioning::Result<()> {
    println!("=== API Verification ===\n");

    // 1. Non-chrono API with explicit elevation angle
    println!("1. Non-chrono API with explicit elevation angle:");
    let result1: SunriseResult<HoursUtc> = spa::sunrise_sunset_utc(
        2023, 6, 21, 37.7749, -122.4194, 69.0, -0.833, // explicit angle
    )?;
    print_hours_result(&result1);

    // 2. Non-chrono API with Horizon enum (convenience)
    println!("\n2. Non-chrono API with Horizon enum:");
    let result2: SunriseResult<HoursUtc> = spa::sunrise_sunset_utc_for_horizon(
        2023,
        6,
        21,
        37.7749,
        -122.4194,
        69.0,
        Horizon::SunriseSunset,
    )?;
    print_hours_result(&result2);

    // 3. Different horizons
    println!("\n3. Different horizon types:");
    for horizon in [
        Horizon::SunriseSunset,
        Horizon::CivilTwilight,
        Horizon::NauticalTwilight,
        Horizon::AstronomicalTwilight,
    ] {
        let result =
            spa::sunrise_sunset_utc_for_horizon(2023, 6, 21, 37.7749, -122.4194, 69.0, horizon)?;
        if let SunriseResult::RegularDay {
            sunrise,
            transit: _,
            sunset,
        } = result
        {
            println!(
                "  {:?}: {:.2} - {:.2} hours",
                horizon,
                sunrise.hours(),
                sunset.hours()
            );
        }
    }

    // 4. Working with HoursUtc
    println!("\n4. Working with HoursUtc:");
    if let SunriseResult::RegularDay {
        sunrise,
        transit,
        sunset,
    } = result1
    {
        println!("  Sunrise raw hours: {}", sunrise.hours());
        let (day, hours) = sunrise.day_and_hours();
        println!("  Sunrise normalized: day={}, hours={:.2}", day, hours);

        println!("  Transit raw hours: {}", transit.hours());
        println!("  Sunset raw hours: {}", sunset.hours());
    }

    // 5. Chrono API (if feature enabled)
    #[cfg(feature = "chrono")]
    {
        use chrono::{FixedOffset, NaiveDate, TimeZone};

        println!("\n5. Chrono API:");
        let date = FixedOffset::east_opt(-7 * 3600)
            .unwrap()
            .from_local_datetime(
                &NaiveDate::from_ymd_opt(2023, 6, 21)
                    .unwrap()
                    .and_hms_opt(0, 0, 0)
                    .unwrap(),
            )
            .unwrap();

        let result_chrono = spa::sunrise_sunset_for_horizon(
            date,
            37.7749,
            -122.4194,
            69.0,
            Horizon::SunriseSunset,
        )?;

        if let SunriseResult::RegularDay {
            sunrise,
            transit,
            sunset,
        } = result_chrono
        {
            println!("  Sunrise: {}", sunrise);
            println!("  Transit: {}", transit);
            println!("  Sunset:  {}", sunset);
        }
    }

    println!("\n✓ API verification complete!");
    Ok(())
}

fn print_hours_result(result: &SunriseResult<HoursUtc>) {
    match result {
        SunriseResult::RegularDay {
            sunrise,
            transit,
            sunset,
        } => {
            println!("  Sunrise: {:.2} hours", sunrise.hours());
            println!("  Transit: {:.2} hours", transit.hours());
            println!("  Sunset:  {:.2} hours", sunset.hours());
        }
        SunriseResult::AllDay { transit } => {
            println!("  Polar day (transit: {:.2} hours)", transit.hours());
        }
        SunriseResult::AllNight { transit } => {
            println!("  Polar night (transit: {:.2} hours)", transit.hours());
        }
    }
}