Enum starstuff_types::angle::Angle

pub enum Angle {
    Degree(f64),
    Radian(f64),
    Hour(f64),
}

Enum containing common angle variants

Variants

Degree(f64)

Variant containing decimal degree

Radian(f64)

Variant containing decimal radian

Hour(f64)

Variant containing decimal hour

Implementations

impl Angle

pub fn to_deg(&self) -> f64

Convert to decimal degree

Examples found in repository

src/angle.rs (line 161)

    fn from(angle: Angle) -> Self {
        Self::angle_to_ams(angle.to_deg())
    }

pub fn to_rad(&self) -> f64

Convert to decimal radian

Examples found in repository

src/angle.rs (line 65)

    pub fn sin(&self) -> f64 {
        Self::to_rad(self).sin()
    }
    pub fn cos(&self) -> f64 {
        Self::to_rad(self).cos()
    }
    pub fn tan(&self) -> f64 {
        Self::to_rad(self).tan()
    }

src/coord.rs (line 28)

    fn new(angle: &Angle) -> Self {
        let rad = angle.to_rad();
        if !(0.0..=PI).contains(&rad) {
            panic!("ZenithAngle must be between 0 and pi!")
        }
        Self(*angle)
    }
    fn value(&self) -> Angle {
        self.0
    }
}

/**
Declination

<https://en.wikipedia.org/wiki/Declination>
 */
#[derive(Debug, Copy, Clone)]
pub struct Declination(pub Angle);

impl ConstrainedAngle for Declination {
    fn new(angle: &Angle) -> Self {
        let rad = angle.to_rad();
        if !(-PI_HALF..=PI_HALF).contains(&rad) {
            panic!("Declination must be between -pi/2 and pi/2!")
        }
        Self(*angle)
    }
    fn value(&self) -> Angle {
        self.0
    }
}

/**
Altitude

<https://en.wikipedia.org/wiki/Horizontal_coordinate_system>
 */
#[derive(Debug, Copy, Clone)]
pub struct Altitude(pub Angle);

impl ConstrainedAngle for Altitude {
    fn new(angle: &Angle) -> Self {
        let rad = angle.to_rad();
        if !(-PI_HALF..=PI_HALF).contains(&rad) {
            panic!("Altitude must be between -pi/2 and pi/2!")
        }
        Self(*angle)
    }
    fn value(&self) -> Angle {
        self.0
    }
}

/**
Latitude

<https://en.wikipedia.org/wiki/Latitude>
 */
#[derive(Debug, Copy, Clone)]
pub struct Latitude(pub Angle);

impl ConstrainedAngle for Latitude {
    fn new(angle: &Angle) -> Self {
        let rad = angle.to_rad();
        if !(-PI_HALF..=PI_HALF).contains(&rad) {
            panic!("Latitude must be between -pi/2 and pi/2!")
        }
        Self(*angle)
    }
    fn value(&self) -> Angle {
        self.0
    }
}

/**
Right Ascension

<https://en.wikipedia.org/wiki/Right_ascension>
 */
#[derive(Debug, Copy, Clone)]
pub struct RightAscension(pub Angle);

/**
Azimuth

<https://en.wikipedia.org/wiki/Azimuth>
 */
#[derive(Debug, Copy, Clone)]
pub struct Azimuth(pub Angle);

/**
Longitude

<https://en.wikipedia.org/wiki/Longitude>
 */
#[derive(Debug, Copy, Clone)]
pub struct Longitude(pub Angle);

/**
Cartesian Coordinates

<https://en.wikipedia.org/wiki/Cartesian_coordinate_system>
 */
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)]
pub struct Cartesian {
    pub x: f64,
    pub y: f64,
    pub z: f64,
}

/**
Geographic Coordinates (Latitude/Longitude)

<https://en.wikipedia.org/wiki/Geographic_coordinate_system>
 */
#[derive(Debug, Copy, Clone)]
pub struct Geographic {
    pub latitude: Latitude,
    pub longitude: Longitude,
}

/**
Two-dimensional Polar Coordinates

<https://en.wikipedia.org/wiki/Polar_coordinate_system>
 */
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)]
pub struct Polar {
    pub radius: f64,
    pub angle: Angle,
}

/**
Equitorial Astronomical Coordinates

<https://en.wikipedia.org/wiki/Astronomical_coordinate_systems#Equatorial_system>
 */
#[derive(Debug, Copy, Clone)]
pub struct Equitorial {
    pub right_ascension: RightAscension,
    pub declination: Declination,
}

/**
Horizontal Astronomical Coordinates

<https://en.wikipedia.org/wiki/Astronomical_coordinate_systems#Horizontal_system>
 */
#[derive(Debug, Copy, Clone)]
pub struct Horizontal {
    pub altitude: Altitude,
    pub azimuth: Azimuth,
}

impl Horizontal {
    /**
    Convert equitorial coordinates to horizontal given a place and time.

    <https://en.wikipedia.org/wiki/Astronomical_coordinate_systems#Equatorial_%E2%86%94_horizontal>
     */
    pub fn from_equitorial(eq: &Equitorial, geo: &Geographic, sidereal_time: &GMST) -> Self {
        let hour_local: Angle = sidereal_time.0 + geo.longitude.0 - eq.right_ascension.0;
        let x_horiz: f64 = -(geo.latitude.0.sin()) * (eq.declination.0.cos()) * (hour_local.cos())
            + geo.latitude.0.cos() * (eq.declination.0.sin());
        let y_horiz: f64 = eq.declination.0.cos() * hour_local.sin();
        let azimuth_rad: Angle = Angle::Radian(-(y_horiz.atan2(x_horiz)));
        let altitude_rad: Angle = Angle::Radian(
            (geo.latitude.0.sin() * eq.declination.0.sin()
                + geo.latitude.0.cos() * eq.declination.0.cos() * hour_local.cos())
            .asin(),
        );
        Self {
            altitude: Altitude(azimuth_rad),
            azimuth: Azimuth(altitude_rad),
        }
    }

    /**
    Stereographic map projection of coordinates.

    <https://en.wikipedia.org/wiki/Stereographic_map_projection>
     */
    pub fn stereo_project(&self) -> Polar {
        Polar {
            radius: 2.0 * (PI_FOURTH - self.altitude.0.to_rad() / 2.0).tan(),
            angle: self.azimuth.0,
        }
    }

pub fn to_hr(&self) -> f64

Convert to decimal hour

Examples found in repository

src/angle.rs (line 167)

    fn from(angle: Angle) -> Self {
        Self::angle_to_ams(angle.to_hr())
    }

src/time.rs (line 69)

    fn from(julian_date: JulianDate) -> Self {
        // https://en.wikipedia.org/wiki/Sidereal_time
        Self(Angle::Hour(earth_rotation_angle(julian_date).to_hr()))
    }

pub fn sin(&self) -> f64

Examples found in repository

src/coord.rs (line 192)

    pub fn from_equitorial(eq: &Equitorial, geo: &Geographic, sidereal_time: &GMST) -> Self {
        let hour_local: Angle = sidereal_time.0 + geo.longitude.0 - eq.right_ascension.0;
        let x_horiz: f64 = -(geo.latitude.0.sin()) * (eq.declination.0.cos()) * (hour_local.cos())
            + geo.latitude.0.cos() * (eq.declination.0.sin());
        let y_horiz: f64 = eq.declination.0.cos() * hour_local.sin();
        let azimuth_rad: Angle = Angle::Radian(-(y_horiz.atan2(x_horiz)));
        let altitude_rad: Angle = Angle::Radian(
            (geo.latitude.0.sin() * eq.declination.0.sin()
                + geo.latitude.0.cos() * eq.declination.0.cos() * hour_local.cos())
            .asin(),
        );
        Self {
            altitude: Altitude(azimuth_rad),
            azimuth: Azimuth(altitude_rad),
        }
    }

pub fn cos(&self) -> f64

Examples found in repository

src/coord.rs (line 192)

    pub fn from_equitorial(eq: &Equitorial, geo: &Geographic, sidereal_time: &GMST) -> Self {
        let hour_local: Angle = sidereal_time.0 + geo.longitude.0 - eq.right_ascension.0;
        let x_horiz: f64 = -(geo.latitude.0.sin()) * (eq.declination.0.cos()) * (hour_local.cos())
            + geo.latitude.0.cos() * (eq.declination.0.sin());
        let y_horiz: f64 = eq.declination.0.cos() * hour_local.sin();
        let azimuth_rad: Angle = Angle::Radian(-(y_horiz.atan2(x_horiz)));
        let altitude_rad: Angle = Angle::Radian(
            (geo.latitude.0.sin() * eq.declination.0.sin()
                + geo.latitude.0.cos() * eq.declination.0.cos() * hour_local.cos())
            .asin(),
        );
        Self {
            altitude: Altitude(azimuth_rad),
            azimuth: Azimuth(altitude_rad),
        }
    }

pub fn tan(&self) -> f64

Trait Implementations

impl Add<&Angle> for &Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, rhs: &Angle) -> Self::Output

Performs the + operation.

impl Add<&Angle> for Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, rhs: &Angle) -> Self::Output

Performs the + operation.

impl Add<Angle> for &Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, rhs: Angle) -> Self::Output

Performs the + operation.

impl Add<Angle> for Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, rhs: Angle) -> Self::Output

Performs the + operation.

impl Clone for Angle

fn clone(&self) -> Angle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Angle

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

Formats the value using the given formatter.

impl From<Angle> for Dms

fn from(angle: Angle) -> Self

Converts to this type from the input type.

impl From<Angle> for Hms

fn from(angle: Angle) -> Self

Converts to this type from the input type.

impl From<Dms> for Angle

fn from(angle: Dms) -> Angle

Converts to this type from the input type.

impl From<Hms> for Angle

fn from(angle: Hms) -> Angle

Converts to this type from the input type.

impl PartialEq<Angle> for Angle

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Sub<&Angle> for &Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, rhs: &Angle) -> Self::Output

Performs the - operation.

impl Sub<&Angle> for Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, rhs: &Angle) -> Self::Output

Performs the - operation.

impl Sub<Angle> for &Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, rhs: Angle) -> Self::Output

Performs the - operation.

impl Sub<Angle> for Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, rhs: Angle) -> Self::Output

Performs the - operation.

impl Copy for Angle

impl StructuralPartialEq for Angle