Struct GeoLocation 

pub struct GeoLocation { /* private fields */ }

A struct that contains location information such as latitude and longitude required for astronomical calculations. The elevation field may be ignored by calculations that do not account for elevation.

Construct with GeoLocation::new, which validates the coordinates.

Implementations

impl GeoLocation

pub fn new( latitude: f64, longitude: f64, elevation: f64, timezone: TimeZone, ) -> Result<Self, GeoLocationError>

Returns a validated GeoLocation.

latitude is in the World Geodetic System, or degrees North of the Equator, and must be in [-90.0, 90.0]. longitude is in the World Geodetic System, or degrees East of the IERS Reference Meridian, and must be in [-180.0, 180.0]. elevation is in meters above sea level and must be non-negative and finite.

Errors

Returns a GeoLocationError describing the first invalid parameter.

Examples found in repository

examples/chiluf_mishmaros.rs (line 11)

fn main() {
    let new_york = TimeZone::get("America/New_York").unwrap();
    // first night of slichos
    let date = civil::date(2025, 9, 13);
    let yu = GeoLocation::new(40.8506041, -73.9297205, 0.0, new_york).unwrap();

    // beginning of the night
    let sunset = zmanim_calculator::shkia(date, &yu, false).unwrap();

    // add a day to calculate sunrise the next day
    let tomorrow = date.add(Span::new().days(1));
    // end of the night
    let sunrise = zmanim_calculator::hanetz(tomorrow, &yu, false).unwrap();

    // each ashmura is 1/3 of the night
    let ashmura = sunrise.duration_since(&sunset) / 3;
    // first chiluf mishmaros is one ashmura into the night
    let chiluf1 = sunset.add(ashmura).strftime("%Y-%m-%d %H:%M:%S %Z");
    println!("{chiluf1}");
}

examples/astronomical.rs (line 12)

fn main() {
    let jerusalem = TimeZone::get("Asia/Jerusalem").unwrap();
    let today = Zoned::now().date();

    // your location here
    let kosel = GeoLocation::new(31.777, 35.234, 700.0, jerusalem).unwrap();

    let dawn = astronomical_calculator::sunrise_offset_by_degrees(
        today,
        &kosel,
        astronomical_calculator::ASTRONOMICAL_ZENITH,
    )
    .unwrap();
    let sunrise = astronomical_calculator::sunrise(today, &kosel).unwrap();
    let noon = astronomical_calculator::solar_noon(today, &kosel).unwrap();

    // where the sun is right now
    let now = Zoned::now();
    let azimuth = astronomical_calculator::solar_azimuth(&now, &kosel);
    let elevation = astronomical_calculator::solar_elevation(&now, &kosel);

    println!(
        "
dawn:     {dawn}
sunrise:  {sunrise}
noon:     {noon}

solar azimuth now:   {azimuth:.2} deg
solar elevation now: {elevation:.2} deg
"
    )
}

examples/zman_registry.rs (line 12)

fn main() {
    let jerusalem = TimeZone::get("Asia/Jerusalem").unwrap();
    let today = Zoned::now().date();

    // your location here
    let kosel = GeoLocation::new(31.777, 35.234, 700.0, jerusalem).unwrap();
    let czc = ComplexZmanimCalendar::new(kosel, today, UseElevation::No);

    // look up a single zman by its method name
    let entry = find_zman("sof_zman_shema_gra").unwrap();
    if let Some(ZmanValue::Time(time)) = (entry.compute)(&czc) {
        println!("{}: {}\n", entry.name, time.strftime("%H:%M:%S %Z"));
    }

    // iterate over every zero-argument zman accessor
    for entry in ALL_ZMANIM {
        match (entry.compute)(&czc) {
            Some(ZmanValue::Time(time)) => {
                println!("{}: {}", entry.name, time.strftime("%H:%M:%S %Z"));
            }
            Some(ZmanValue::Duration(duration)) => println!("{}: {duration:#}", entry.name),
            None => println!("{}: does not occur today", entry.name),
        }
    }
}

examples/baal_hatanya.rs (line 12)

fn main() {
    let jerusalem = TimeZone::get("Asia/Jerusalem").unwrap();
    let today = Zoned::now().date();

    // your location here
    let kosel = GeoLocation::new(31.777, 35.234, 700.0, jerusalem).unwrap();

    let czc = ComplexZmanimCalendar::new(kosel, today, UseElevation::No);

    let alos = czc.alos_baal_hatanya().unwrap();
    let hanetz = czc.hanetz().unwrap();
    let szks = czc.sof_zman_shema_baal_hatanya().unwrap();
    let szt = czc.sof_zman_tefila_baal_hatanya().unwrap();
    let chatzos = czc.chatzos_hayom().unwrap();
    let mg = czc.mincha_gedola_baal_hatanya().unwrap();
    let mk = czc.mincha_ketana_baal_hatanya().unwrap();
    let plag = czc.plag_baal_hatanya().unwrap();
    let shkia = czc.shkia().unwrap();
    let tzeis = czc.tzeis_baal_hatanya().unwrap();
    let shaah = czc.shaah_zmanis_baal_hatanya().unwrap();

    println!(
        "alos:         {alos}
hanetz:       {hanetz}
SZKS:         {szks}
SZT:          {szt}
chatzos:      {chatzos}
MG:           {mg}
MK:           {mk}
shkia:        {shkia}
plag:         {plag}
tzeis:        {tzeis}
shaah zmanis: {shaah}"
    )
}

examples/mga_10_to_13_degrees.rs (line 12)

fn main() {
    let jerusalem = TimeZone::get("Asia/Jerusalem").unwrap();
    let today = Zoned::now().date();

    let kosel = GeoLocation::new(31.777, 35.234, 700.0, jerusalem).unwrap();

    let alos_10_deg =
        zmanim_calculator::alos(today, &kosel, false, &ZmanOffset::Degrees(10.0)).unwrap();
    let tzeis_13_deg =
        zmanim_calculator::tzeis(today, &kosel, false, &ZmanOffset::Degrees(13.0)).unwrap();
    let hanetz = zmanim_calculator::hanetz(today, &kosel, true).unwrap();
    let szks = zmanim_calculator::sof_zman_shema(&alos_10_deg, &tzeis_13_deg);
    let szt = zmanim_calculator::sof_zman_tefila(&alos_10_deg, &tzeis_13_deg);
    let chatzos = zmanim_calculator::chatzos_hayom(today, &kosel).unwrap();
    let mg = zmanim_calculator::mincha_gedola(&alos_10_deg, &tzeis_13_deg);
    let mk = zmanim_calculator::mincha_ketana(&alos_10_deg, &tzeis_13_deg);
    let plag = zmanim_calculator::plag_hamincha(&alos_10_deg, &tzeis_13_deg);
    let shkia = zmanim_calculator::shkia(today, &kosel, true).unwrap();
    let shaah = zmanim_calculator::shaah_zmanis(&alos_10_deg, &tzeis_13_deg);

    println!(
        "alos:         {alos_10_deg}
hanetz:       {hanetz}
SZKS:         {szks}
SZT:          {szt}
chatzos:      {chatzos}
MG:           {mg}
MK:           {mk}
shkia:        {shkia}
plag:         {plag}
tzeis:        {tzeis_13_deg}
shaah zmanis: {shaah}"
    )
}

examples/csv.rs (line 9)

fn main() {
    let new_york = TimeZone::get("America/New_York").unwrap();

    let yeshiva = GeoLocation::new(40.8506041, -73.9297205, 0.0, new_york).unwrap();

    println!(
        "Date, Alos 19.8°, Alos 18°, Misheyakir 6.5°, Hanetz, SZKS, SZT, Chatzos, MG, MK, Plag, Shkia, Tzeis 6°"
    );

    let mut date = civil::date(2027, 1, 1);
    let end = civil::date(2027, 12, 30);
    let mut czc = ComplexZmanimCalendar::new(yeshiva, date, UseElevation::No);
    while date <= end {
        czc.set_date(date);

        println!(
            "{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}",
            date,
            czc.alos_19_8_degrees().unwrap().strftime("%H:%M:%S"),
            czc.alos_18_degrees().unwrap().strftime("%H:%M:%S"),
            czc.alos(&ZmanOffset::Degrees(6.5))
                .unwrap()
                .strftime("%H:%M:%S"),
            czc.hanetz().unwrap().strftime("%H:%M:%S"),
            czc.sof_zman_shema_gra().unwrap().strftime("%H:%M:%S"),
            czc.sof_zman_tefila_gra().unwrap().strftime("%H:%M:%S"),
            czc.chatzos_hayom().unwrap().strftime("%H:%M:%S"),
            czc.mincha_gedola_gra().unwrap().strftime("%H:%M:%S"),
            czc.mincha_ketana_gra().unwrap().strftime("%H:%M:%S"),
            czc.plag_gra().unwrap().strftime("%H:%M:%S"),
            czc.shkia().unwrap().strftime("%H:%M:%S"),
            czc.tzeis_baal_hatanya().unwrap().strftime("%H:%M:%S"),
        );

        date = date.tomorrow().unwrap();
    }
}

Additional examples can be found in:

• examples/basics.rs

pub fn latitude(&self) -> f64

The latitude in the World Geodetic System, or degrees North of the Equator

pub fn longitude(&self) -> f64

The longitude in the World Geodetic System, or degrees East of the IERS Reference Meridian

pub fn elevation(&self) -> f64

The elevation in meters above sea level

pub fn timezone(&self) -> &TimeZone

The location’s time zone

pub fn local_mean_time_offset(&self) -> f64

Returns the location’s local mean time offset from UTC in hours. The globe is split into 360°, with 15° per hour of the day. For a location that is at a longitude evenly divisible by 15 (longitude % 15 == 0), at solar noon (with adjustment for the equation of time) the sun should be directly overhead, so a user who is 1° west of this will have noon at 4 minutes after standard time noon, and conversely, a user who is 1° east of the 15° longitude will have noon at 11:56 AM. Lakewood, N.J., whose longitude is -74.222, is 0.778 away from the closest multiple of 15 at -75°. This is multiplied by 4 to yield 3 minutes and 7 seconds earlier than standard time. The offset returned does not account for the daylight saving time offset since this struct is unaware of dates.

Trait Implementations

impl Clone for GeoLocation

fn clone(&self) -> GeoLocation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GeoLocation

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

Formats the value using the given formatter.

impl PartialEq for GeoLocation

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for GeoLocation