s2::s1::angle

Struct Angle

pub struct Angle(/* private fields */);

Expand description

Angle represents a 1D angle. The internal representation is a double precision value in radians, so conversion to and from radians is exact. Conversions between E5, E6, E7, and Degrees are not always exact. For example, Deg(3.1) is different from E6(3100000) or E7(310000000).

use s2::s1::angle::*;
use std::f64::consts::PI;

// The following conversions between degrees and radians are exact:
assert_eq!(Deg(180.), Deg::from(Rad(PI)));
for n in 0..9 {
    // for n == 0..8
    assert_eq!(Rad(PI/(n as f64)), Deg(180./(n as f64)).into());
}

// These identities hold when the arguments are scaled up or down by any power
// of 2. Some similar identities are also true, for example,
assert_eq!(Rad(PI/3.), Deg(60.).into());

// But be aware that this type of identity does not hold in general. For example,
assert_ne!(Rad(PI/60.), Deg(3.).into());

// Similarly, the conversion to radians means that Deg::from(Angle::from(Deg(x)))
// does not always equal x. For example,

// for n == 0..8
for n in 0..9 {
    let x = 45. * (n as f64);
    assert_eq!(Deg(x), Deg::from(Angle::from(Deg(x))));
}

// but
assert_ne!(Deg(60.), Deg::from(Angle::from(Deg(60.))));

When testing for equality, you should allow for numerical errors (float64Eq) or convert to discrete E5/E6/E7 values first.

Struct AngleCopy item path

Implementations§

impl Angle

pub fn rad(&self) -> f64

pub fn deg(&self) -> f64

pub fn inf() -> Self

pub fn is_infinite(&self) -> bool

pub fn abs(&self) -> Self

pub fn normalized(&self) -> Self

pub fn max(self, other: Angle) -> Self

pub fn min(self, other: Angle) -> Self

Trait Implementations§

impl Add<Angle> for f64

type Output = Angle

fn add(self, other: Angle) -> Angle

impl Add<f64> for Angle

type Output = Angle

fn add(self, other: f64) -> Self

impl Add for Angle

type Output = Angle

fn add(self, other: Self) -> Self

impl AddAssign<Angle> for f64

fn add_assign(self: &mut f64, other: Angle)

impl AddAssign<f64> for Angle

fn add_assign(&mut self, other: f64)

impl AddAssign for Angle

fn add_assign(&mut self, other: Self)

impl Clone for Angle

fn clone(&self) -> Angle

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

impl Debug for Angle

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

impl Default for Angle

fn default() -> Angle

impl<'de> Deserialize<'de> for Angle

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl Div<Angle> for f64

type Output = Angle

fn div(self, other: Angle) -> Angle

impl Div<f64> for Angle

type Output = Angle

fn div(self, other: f64) -> Self

impl Div for Angle

type Output = Angle

fn div(self, other: Self) -> Self

impl DivAssign<Angle> for f64

fn div_assign(self: &mut f64, other: Angle)

impl DivAssign<f64> for Angle

fn div_assign(&mut self, other: f64)

impl DivAssign for Angle

fn div_assign(&mut self, other: Self)

impl<'a> From<&'a Angle> for ChordAngle

fn from(a: &'a Angle) -> Self

impl<'a> From<&'a Angle> for Deg

fn from(a: &Angle) -> Self

impl<'a> From<&'a Angle> for E5

fn from(a: &Angle) -> Self

impl<'a> From<&'a Angle> for E6

fn from(a: &Angle) -> Self

impl<'a> From<&'a Angle> for E7

fn from(a: &Angle) -> Self

impl<'a> From<&'a Angle> for Rad

fn from(a: &Angle) -> Self

impl<'a> From<&'a ChordAngle> for Angle

fn from(ca: &'a ChordAngle) -> Self

impl<'a> From<&'a Deg> for Angle

fn from(a: &Deg) -> Self

impl<'a> From<&'a E5> for Angle

fn from(a: &E5) -> Self

impl<'a> From<&'a E6> for Angle

fn from(a: &E6) -> Self

impl<'a> From<&'a E7> for Angle

fn from(a: &E7) -> Self

impl<'a> From<&'a Rad> for Angle

fn from(a: &Rad) -> Self

impl From<Angle> for ChordAngle

fn from(a: Angle) -> Self

impl From<Angle> for Deg

fn from(a: Angle) -> Self

impl From<Angle> for E5

Struct Angle

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,