Struct Configuration 

pub struct Configuration { /* private fields */ }

Builder for Parameters.

Implementations

impl Configuration

pub fn new(fajr_angle: f64, isha_angle: f64) -> Configuration

Create a Configuration builder with initial Fajr and Isha angles.

Examples found in repository

examples/high-latitude.rs (line 5)

fn times_at(lat: f64, label: &str, date: NaiveDate, original_coords: Coordinates) {
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .done();

    let ref_coords = Coordinates::new(lat, original_coords.longitude);
    match PrayerTimes::try_new(date, ref_coords, params) {
        Ok(t) => println!(
            "{label:>12} ({lat:.2}°): {:?} {:?} {:?} {:?} {:?} {:?}",
            t.time(Prayer::Fajr),
            t.time(Prayer::Sunrise),
            t.time(Prayer::Dhuhr),
            t.time(Prayer::Asr),
            t.time(Prayer::Maghrib),
            t.time(Prayer::Isha),
        ),
        Err(e) => println!("{label:>12} ({lat:.2}°): FAIL ({e})"),
    }
}

fn main() {
    let date = NaiveDate::from_ymd_opt(2026, 7, 5).expect("valid date");
    let dt: DateTime<Utc> = date.and_hms_opt(0, 0, 0).unwrap().and_utc();
    let tromso = Coordinates::new(70.0, 20.0);

    // 1. Original 70°N — no fallback
    times_at(70.0, "Original 70°", date, tromso);

    // 2. NearestLatitude (resolved)
    let resolved = PolarFallback::NearestLatitude
        .resolve_latitude(dt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(resolved, "NearestLat", date, tromso);
    println!("  → Resolved latitude: {resolved:.6}°");

    // 3. Reference45 (fixed 45°N)
    times_at(45.0, "Reference45", date, tromso);

    // 4. Also show at a clean mid-latitude
    times_at(48.0, "48° fixed", date, tromso);

    // Now show NearestLatitude via the proper API
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .polar_fallback(PolarFallback::NearestLatitude)
        .done();
    let t = PrayerTimes::try_new(date, tromso, params).unwrap();
    println!("\nNearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t.time(Prayer::Fajr),
        t.time(Prayer::Sunrise),
        t.time(Prayer::Dhuhr),
        t.time(Prayer::Asr),
        t.time(Prayer::Maghrib),
        t.time(Prayer::Isha),
    );

    // Also for Jan 15 (winter)
    let winter = NaiveDate::from_ymd_opt(2026, 1, 15).expect("valid date");
    let wt: DateTime<Utc> = winter.and_hms_opt(0, 0, 0).unwrap().and_utc();
    println!("\n--- Winter (Jan 15) ---");
    times_at(70.0, "Original 70°", winter, tromso);

    let winter_resolved = PolarFallback::NearestLatitude
        .resolve_latitude(wt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(winter_resolved, "NearestLat", winter, tromso);
    println!("  → Resolved latitude: {winter_resolved:.6}°");
    times_at(45.0, "Reference45", winter, tromso);

    let t2 = PrayerTimes::try_new(winter, tromso, params).unwrap();
    println!("\nWinter NearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t2.time(Prayer::Fajr),
        t2.time(Prayer::Sunrise),
        t2.time(Prayer::Dhuhr),
        t2.time(Prayer::Asr),
        t2.time(Prayer::Maghrib),
        t2.time(Prayer::Isha),
    );
}

pub fn with(method: Method, madhab: Madhab) -> Parameters

Convenience method: build Parameters from a Method and Madhab in one step, bypassing the builder chain.

Examples found in repository

examples/prayer-times.rs (lines 8-11)

fn main() {
    let prayers = PrayerSchedule::new()
        .on(NaiveDate::from_ymd_opt(2026, 6, 21).expect("invalid date"))
        .for_location(Coordinates::new(50.85, 4.35)) // Brussels
        .with_configuration(Configuration::with(
            Method::MuslimWorldLeague,
            Madhab::Shafi,
        ))
        .calculate()
        .expect("prayer times calculation failed");

    println!("Prayer times for Brussels on 2026-06-21:");
    for prayer in &[
        Prayer::Fajr,
        Prayer::Sunrise,
        Prayer::Dhuhr,
        Prayer::Asr,
        Prayer::Maghrib,
        Prayer::Isha,
    ] {
        let local = prayers.time(*prayer).with_timezone(&Local);
        println!("  {prayer:>8?}  {}", local.format("%H:%M"));
    }
}

examples/schedule-builder.rs (lines 23-26)

fn main() {
    // Use the builder to configure and compute prayer times.
    let result = PrayerSchedule::new()
        .on(NaiveDate::from_ymd_opt(2026, 6, 21).expect("invalid date"))
        .for_location(Coordinates::new(50.85, 4.35)) // Brussels
        .with_configuration(Configuration::with(
            Method::MuslimWorldLeague,
            Madhab::Shafi,
        ))
        .calculate();

    match result {
        Ok(prayers) => {
            println!("Brussels — 2026-06-21 (MWL, Shafi):");
            print_prayers(&prayers);
        }
        Err(e) => {
            eprintln!("Error: {e}");
        }
    }

    // The builder returns an error if required fields are missing.
    let incomplete = PrayerSchedule::new()
        .on(NaiveDate::from_ymd_opt(2026, 6, 21).expect("invalid date"))
        .calculate();

    match incomplete {
        Ok(_) => println!("unexpected success"),
        Err(e) => println!("\nExpected error: {e}"),
    }
}

examples/prayer-clock.rs (line 9)

fn main() {
    let coords = Coordinates::new(50.85, 4.35);
    let params = Configuration::with(Method::MuslimWorldLeague, Madhab::Shafi);

    loop {
        let today = Local::now().date_naive();
        let prayers = PrayerSchedule::new()
            .on(today)
            .for_location(coords)
            .with_configuration(params)
            .calculate()
            .expect("prayer times calculation failed");

        let current = prayers.current();
        let next = prayers.next();
        let (hours, minutes) = prayers.time_remaining();
        let next_local = prayers.time(next).with_timezone(&Local);
        let current_time = prayers.current_prayer_time().with_timezone(&Local);

        print!(
            "\rCurrent: {current:<10?} (since {time:<8})  \
             Next: {next:<12?} at {next_time:<8}  \
             Remaining: {hours}h {minutes:02}m   ",
            time = current_time.format("%H:%M"),
            next_time = next_local.format("%H:%M"),
        );
        stdout().flush().expect("flush failed");

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn method(&mut self, method: Method) -> &mut Configuration

Set the calculation authority.

Examples found in repository

examples/high-latitude.rs (line 6)

fn times_at(lat: f64, label: &str, date: NaiveDate, original_coords: Coordinates) {
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .done();

    let ref_coords = Coordinates::new(lat, original_coords.longitude);
    match PrayerTimes::try_new(date, ref_coords, params) {
        Ok(t) => println!(
            "{label:>12} ({lat:.2}°): {:?} {:?} {:?} {:?} {:?} {:?}",
            t.time(Prayer::Fajr),
            t.time(Prayer::Sunrise),
            t.time(Prayer::Dhuhr),
            t.time(Prayer::Asr),
            t.time(Prayer::Maghrib),
            t.time(Prayer::Isha),
        ),
        Err(e) => println!("{label:>12} ({lat:.2}°): FAIL ({e})"),
    }
}

fn main() {
    let date = NaiveDate::from_ymd_opt(2026, 7, 5).expect("valid date");
    let dt: DateTime<Utc> = date.and_hms_opt(0, 0, 0).unwrap().and_utc();
    let tromso = Coordinates::new(70.0, 20.0);

    // 1. Original 70°N — no fallback
    times_at(70.0, "Original 70°", date, tromso);

    // 2. NearestLatitude (resolved)
    let resolved = PolarFallback::NearestLatitude
        .resolve_latitude(dt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(resolved, "NearestLat", date, tromso);
    println!("  → Resolved latitude: {resolved:.6}°");

    // 3. Reference45 (fixed 45°N)
    times_at(45.0, "Reference45", date, tromso);

    // 4. Also show at a clean mid-latitude
    times_at(48.0, "48° fixed", date, tromso);

    // Now show NearestLatitude via the proper API
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .polar_fallback(PolarFallback::NearestLatitude)
        .done();
    let t = PrayerTimes::try_new(date, tromso, params).unwrap();
    println!("\nNearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t.time(Prayer::Fajr),
        t.time(Prayer::Sunrise),
        t.time(Prayer::Dhuhr),
        t.time(Prayer::Asr),
        t.time(Prayer::Maghrib),
        t.time(Prayer::Isha),
    );

    // Also for Jan 15 (winter)
    let winter = NaiveDate::from_ymd_opt(2026, 1, 15).expect("valid date");
    let wt: DateTime<Utc> = winter.and_hms_opt(0, 0, 0).unwrap().and_utc();
    println!("\n--- Winter (Jan 15) ---");
    times_at(70.0, "Original 70°", winter, tromso);

    let winter_resolved = PolarFallback::NearestLatitude
        .resolve_latitude(wt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(winter_resolved, "NearestLat", winter, tromso);
    println!("  → Resolved latitude: {winter_resolved:.6}°");
    times_at(45.0, "Reference45", winter, tromso);

    let t2 = PrayerTimes::try_new(winter, tromso, params).unwrap();
    println!("\nWinter NearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t2.time(Prayer::Fajr),
        t2.time(Prayer::Sunrise),
        t2.time(Prayer::Dhuhr),
        t2.time(Prayer::Asr),
        t2.time(Prayer::Maghrib),
        t2.time(Prayer::Isha),
    );
}

pub fn method_adjustments( &mut self, method_adjustments: TimeAdjustment, ) -> &mut Configuration

Override the method’s built-in time adjustments.

pub fn high_latitude_rule( &mut self, high_latitude_rule: HighLatitudeRule, ) -> &mut Configuration

Choose the rule for approximating Fajr and Isha at high latitudes.

pub fn madhab(&mut self, madhab: Madhab) -> &mut Configuration

Set the madhab for Asr shadow-length calculation (Shafi or Hanafi).

Examples found in repository

examples/high-latitude.rs (line 7)

fn times_at(lat: f64, label: &str, date: NaiveDate, original_coords: Coordinates) {
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .done();

    let ref_coords = Coordinates::new(lat, original_coords.longitude);
    match PrayerTimes::try_new(date, ref_coords, params) {
        Ok(t) => println!(
            "{label:>12} ({lat:.2}°): {:?} {:?} {:?} {:?} {:?} {:?}",
            t.time(Prayer::Fajr),
            t.time(Prayer::Sunrise),
            t.time(Prayer::Dhuhr),
            t.time(Prayer::Asr),
            t.time(Prayer::Maghrib),
            t.time(Prayer::Isha),
        ),
        Err(e) => println!("{label:>12} ({lat:.2}°): FAIL ({e})"),
    }
}

fn main() {
    let date = NaiveDate::from_ymd_opt(2026, 7, 5).expect("valid date");
    let dt: DateTime<Utc> = date.and_hms_opt(0, 0, 0).unwrap().and_utc();
    let tromso = Coordinates::new(70.0, 20.0);

    // 1. Original 70°N — no fallback
    times_at(70.0, "Original 70°", date, tromso);

    // 2. NearestLatitude (resolved)
    let resolved = PolarFallback::NearestLatitude
        .resolve_latitude(dt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(resolved, "NearestLat", date, tromso);
    println!("  → Resolved latitude: {resolved:.6}°");

    // 3. Reference45 (fixed 45°N)
    times_at(45.0, "Reference45", date, tromso);

    // 4. Also show at a clean mid-latitude
    times_at(48.0, "48° fixed", date, tromso);

    // Now show NearestLatitude via the proper API
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .polar_fallback(PolarFallback::NearestLatitude)
        .done();
    let t = PrayerTimes::try_new(date, tromso, params).unwrap();
    println!("\nNearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t.time(Prayer::Fajr),
        t.time(Prayer::Sunrise),
        t.time(Prayer::Dhuhr),
        t.time(Prayer::Asr),
        t.time(Prayer::Maghrib),
        t.time(Prayer::Isha),
    );

    // Also for Jan 15 (winter)
    let winter = NaiveDate::from_ymd_opt(2026, 1, 15).expect("valid date");
    let wt: DateTime<Utc> = winter.and_hms_opt(0, 0, 0).unwrap().and_utc();
    println!("\n--- Winter (Jan 15) ---");
    times_at(70.0, "Original 70°", winter, tromso);

    let winter_resolved = PolarFallback::NearestLatitude
        .resolve_latitude(wt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(winter_resolved, "NearestLat", winter, tromso);
    println!("  → Resolved latitude: {winter_resolved:.6}°");
    times_at(45.0, "Reference45", winter, tromso);

    let t2 = PrayerTimes::try_new(winter, tromso, params).unwrap();
    println!("\nWinter NearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t2.time(Prayer::Fajr),
        t2.time(Prayer::Sunrise),
        t2.time(Prayer::Dhuhr),
        t2.time(Prayer::Asr),
        t2.time(Prayer::Maghrib),
        t2.time(Prayer::Isha),
    );
}

pub fn polar_fallback(&mut self, fallback: PolarFallback) -> &mut Configuration

Set the strategy for handling polar day/night latitudes.

Examples found in repository

examples/high-latitude.rs (line 50)

fn main() {
    let date = NaiveDate::from_ymd_opt(2026, 7, 5).expect("valid date");
    let dt: DateTime<Utc> = date.and_hms_opt(0, 0, 0).unwrap().and_utc();
    let tromso = Coordinates::new(70.0, 20.0);

    // 1. Original 70°N — no fallback
    times_at(70.0, "Original 70°", date, tromso);

    // 2. NearestLatitude (resolved)
    let resolved = PolarFallback::NearestLatitude
        .resolve_latitude(dt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(resolved, "NearestLat", date, tromso);
    println!("  → Resolved latitude: {resolved:.6}°");

    // 3. Reference45 (fixed 45°N)
    times_at(45.0, "Reference45", date, tromso);

    // 4. Also show at a clean mid-latitude
    times_at(48.0, "48° fixed", date, tromso);

    // Now show NearestLatitude via the proper API
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .polar_fallback(PolarFallback::NearestLatitude)
        .done();
    let t = PrayerTimes::try_new(date, tromso, params).unwrap();
    println!("\nNearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t.time(Prayer::Fajr),
        t.time(Prayer::Sunrise),
        t.time(Prayer::Dhuhr),
        t.time(Prayer::Asr),
        t.time(Prayer::Maghrib),
        t.time(Prayer::Isha),
    );

    // Also for Jan 15 (winter)
    let winter = NaiveDate::from_ymd_opt(2026, 1, 15).expect("valid date");
    let wt: DateTime<Utc> = winter.and_hms_opt(0, 0, 0).unwrap().and_utc();
    println!("\n--- Winter (Jan 15) ---");
    times_at(70.0, "Original 70°", winter, tromso);

    let winter_resolved = PolarFallback::NearestLatitude
        .resolve_latitude(wt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(winter_resolved, "NearestLat", winter, tromso);
    println!("  → Resolved latitude: {winter_resolved:.6}°");
    times_at(45.0, "Reference45", winter, tromso);

    let t2 = PrayerTimes::try_new(winter, tromso, params).unwrap();
    println!("\nWinter NearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t2.time(Prayer::Fajr),
        t2.time(Prayer::Sunrise),
        t2.time(Prayer::Dhuhr),
        t2.time(Prayer::Asr),
        t2.time(Prayer::Maghrib),
        t2.time(Prayer::Isha),
    );
}

pub fn isha_interval(&mut self, isha_interval: i32) -> &mut Configuration

Use a fixed interval (in minutes) from Maghrib for Isha instead of a twilight angle. Sets isha_angle to 0. Used by Umm al-Qura (90 min) and Qatar (90 min).

pub fn maghrib_angle(&mut self, angle: f64) -> &mut Configuration

Set a custom twilight angle for Maghrib (default: 0° — geometric sunset). Used by the Tehran method (4.5°).

pub fn rounding(&mut self, value: Rounding) -> &mut Configuration

Set the rounding rule for all computed prayer times.

pub fn shafaq(&mut self, value: Shafaq) -> &mut Configuration

Set the twilight phenomenon used by the Moonsighting Committee method for Isha calculation (General, Ahmer, or Abyad).

pub fn done(&self) -> Parameters

Finalise the builder and return the Parameters.

Examples found in repository

examples/high-latitude.rs (line 8)

fn times_at(lat: f64, label: &str, date: NaiveDate, original_coords: Coordinates) {
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .done();

    let ref_coords = Coordinates::new(lat, original_coords.longitude);
    match PrayerTimes::try_new(date, ref_coords, params) {
        Ok(t) => println!(
            "{label:>12} ({lat:.2}°): {:?} {:?} {:?} {:?} {:?} {:?}",
            t.time(Prayer::Fajr),
            t.time(Prayer::Sunrise),
            t.time(Prayer::Dhuhr),
            t.time(Prayer::Asr),
            t.time(Prayer::Maghrib),
            t.time(Prayer::Isha),
        ),
        Err(e) => println!("{label:>12} ({lat:.2}°): FAIL ({e})"),
    }
}

fn main() {
    let date = NaiveDate::from_ymd_opt(2026, 7, 5).expect("valid date");
    let dt: DateTime<Utc> = date.and_hms_opt(0, 0, 0).unwrap().and_utc();
    let tromso = Coordinates::new(70.0, 20.0);

    // 1. Original 70°N — no fallback
    times_at(70.0, "Original 70°", date, tromso);

    // 2. NearestLatitude (resolved)
    let resolved = PolarFallback::NearestLatitude
        .resolve_latitude(dt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(resolved, "NearestLat", date, tromso);
    println!("  → Resolved latitude: {resolved:.6}°");

    // 3. Reference45 (fixed 45°N)
    times_at(45.0, "Reference45", date, tromso);

    // 4. Also show at a clean mid-latitude
    times_at(48.0, "48° fixed", date, tromso);

    // Now show NearestLatitude via the proper API
    let params = Configuration::new(18.0, 17.0)
        .method(Method::MuslimWorldLeague)
        .madhab(Madhab::Shafi)
        .polar_fallback(PolarFallback::NearestLatitude)
        .done();
    let t = PrayerTimes::try_new(date, tromso, params).unwrap();
    println!("\nNearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t.time(Prayer::Fajr),
        t.time(Prayer::Sunrise),
        t.time(Prayer::Dhuhr),
        t.time(Prayer::Asr),
        t.time(Prayer::Maghrib),
        t.time(Prayer::Isha),
    );

    // Also for Jan 15 (winter)
    let winter = NaiveDate::from_ymd_opt(2026, 1, 15).expect("valid date");
    let wt: DateTime<Utc> = winter.and_hms_opt(0, 0, 0).unwrap().and_utc();
    println!("\n--- Winter (Jan 15) ---");
    times_at(70.0, "Original 70°", winter, tromso);

    let winter_resolved = PolarFallback::NearestLatitude
        .resolve_latitude(wt, tromso, Madhab::Shafi)
        .unwrap();
    times_at(winter_resolved, "NearestLat", winter, tromso);
    println!("  → Resolved latitude: {winter_resolved:.6}°");
    times_at(45.0, "Reference45", winter, tromso);

    let t2 = PrayerTimes::try_new(winter, tromso, params).unwrap();
    println!("\nWinter NearestLatitude via API:");
    println!(
        "  {:?} {:?} {:?} {:?} {:?} {:?}",
        t2.time(Prayer::Fajr),
        t2.time(Prayer::Sunrise),
        t2.time(Prayer::Dhuhr),
        t2.time(Prayer::Asr),
        t2.time(Prayer::Maghrib),
        t2.time(Prayer::Isha),
    );
}