Struct Degrees 

#[repr(transparent)]
pub struct Degrees<T>(pub T)
where
    T: Float;

The Degrees newtype an f64.

Tuple Fields

0: T

Implementations

impl<T> Degrees<T>

where T: Float,

pub fn abs(self) -> Degrees<T>

The absolute value of the angle.

pub fn half(self) -> Degrees<T>

Half of the angle.

pub fn opposite(self) -> Degrees<T>

The opposite angle on the circle, i.e. +/- 180 degrees.

Trait Implementations

impl<T> Add for Degrees<T>

where T: Float,

fn add(self, other: Degrees<T>) -> <Degrees<T> as Add>::Output

Add a pair of angles in Degrees, wraps around +/-180 degrees. Uses the 2Sum algorithm to reduce round-off error.

Examples

use angle_sc::{Degrees};

let angle_120 = Degrees(120.0);
let result = angle_120 + angle_120;
assert_eq!(-angle_120, result);

type Output = Degrees<T>

The resulting type after applying the + operator.

impl<T> AddAssign for Degrees<T>

where T: Float,

fn add_assign(&mut self, other: Degrees<T>)

Performs the += operation.

impl<T> Clone for Degrees<T>

where T: Clone + Float,

fn clone(&self) -> Degrees<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Degrees<T>

where T: Copy + Float,

impl<T> Debug for Degrees<T>

where T: Debug + Float,

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

Formats the value using the given formatter.

impl<T> Default for Degrees<T>

where T: Float,

fn default() -> Degrees<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Degrees<T>

where T: Float + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Degrees<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Eq for Degrees<T>

where T: Eq + Float,

impl<T> From<Angle<T>> for Degrees<T>

where T: Float + FloatConst,

fn from(a: Angle<T>) -> Degrees<T>

Convert an Angle to Degrees.

impl<T> From<Degrees<T>> for Angle<T>

where T: Float + FloatConst, f64: From<T>,

fn from(a: Degrees<T>) -> Angle<T>

Construct an Angle from an angle in Degrees.

Examples:

use angle_sc::{Angle, Degrees, is_within_tolerance, trig};

let angle = Angle::from(Degrees(60.0));
assert_eq!(trig::COS_30_DEGREES, angle.sin().0);
assert_eq!(0.5, angle.cos().0);
assert_eq!(60.0, Degrees::from(angle).0);

impl<T> Neg for Degrees<T>

where T: Float,

fn neg(self) -> <Degrees<T> as Neg>::Output

An implementation of Neg for Degrees, i.e. -angle.

Examples

use angle_sc::Degrees;

let angle_45 = Degrees(45.0);
let result_m45 = -angle_45;
assert_eq!(-45.0, result_m45.0);

type Output = Degrees<T>

The resulting type after applying the - operator.

impl<T> PartialEq for Degrees<T>

where T: PartialEq + Float,

fn eq(&self, other: &Degrees<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> Serialize for Degrees<T>

where T: Float + Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Degrees<T>

where T: PartialEq + Float,

impl<T> Sub for Degrees<T>

where T: Float,

fn sub(self, other: Degrees<T>) -> <Degrees<T> as Sub>::Output

Subtract a pair of angles in Degrees, wraps around +/-180 degrees. Uses the 2Sum algorithm to reduce round-off error.

Examples

use angle_sc::{Degrees};

let angle_120 = Degrees(120.0);
let result = -angle_120 - angle_120;
assert_eq!(angle_120, result);

type Output = Degrees<T>

The resulting type after applying the - operator.

impl<T> SubAssign for Degrees<T>

where T: Float,

fn sub_assign(&mut self, other: Degrees<T>)

Performs the -= operation.