Struct Angle 

pub struct Angle<T>
where
    T: Float,
{ /* private fields */ }

An angle represented by it’s sine and cosine as UnitNegRanges.

Implementations

impl<T> Angle<T>

where T: Float,

pub const fn new(sin: UnitNegRange<T>, cos: UnitNegRange<T>) -> Angle<T>

Construct an Angle from sin and cos values.

pub fn from_y_x(y: T, x: T) -> Angle<T>

Construct an Angle from y and x values. Normalizes the values.

pub const fn sin(self) -> UnitNegRange<T>

The sine of the Angle.

pub const fn cos(self) -> UnitNegRange<T>

The cosine of the Angle.

pub fn tan(self) -> Option<T>

The tangent of the Angle.

returns the tangent or None if self.cos < SQ_EPSILON

pub fn csc(self) -> Option<T>

The cosecant of the Angle.

returns the cosecant or None if self.sin < SQ_EPSILON

pub fn sec(self) -> Option<T>

The secant of the Angle.

returns the secant or None if self.cos < SQ_EPSILON

pub fn cot(self) -> Option<T>

The cotangent of the Angle.

returns the cotangent or None if self.sin < SQ_EPSILON

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

The absolute value of the angle, i.e. the angle with a positive sine.

Examples

use angle_sc::{Angle, Degrees};

let angle_m45 = Angle::from(Degrees(-45.0));
let result_45 = angle_m45.abs();
assert_eq!(Degrees(45.0), Degrees::from(result_45));

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

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

Examples

use angle_sc::{Angle, Degrees};

let angle_m30 = Angle::from(Degrees(-30.0));
let result = angle_m30.opposite();
assert_eq!(Degrees(150.0), Degrees::from(result));

pub fn quarter_turn_cw(self) -> Angle<T>

A quarter turn clockwise around the circle, i.e. + 90°.

Examples

use angle_sc::{Angle, Degrees};

let angle_m30 = Angle::from(Degrees(-30.0));
let result = angle_m30.quarter_turn_cw();
assert_eq!(Angle::from(Degrees(60.0)), result);

pub fn quarter_turn_ccw(self) -> Angle<T>

A quarter turn counter-clockwise around the circle, i.e. - 90°.

Examples

use angle_sc::{Angle, Degrees};

let angle_120 = Angle::from(Degrees(120.0));
let result = angle_120.quarter_turn_ccw();
assert_eq!(Angle::from(Degrees(30.0)), result);

pub fn negate_cos(self) -> Angle<T>

Negate the cosine of the Angle. I.e. PI - angle.radians() for positive angles, angle.radians() + PI for negative angles

Examples

use angle_sc::{Angle, Degrees};

let angle_45 = Angle::from(Degrees(45.0));
let result_45 = angle_45.negate_cos();
assert_eq!(Degrees(135.0), Degrees::from(result_45));

pub fn double(self) -> Angle<T>

Double the Angle. See: Double-angle formulae

Examples

use angle_sc::{Angle, Degrees};

let angle_30 = Angle::from(Degrees(30.0));
let result_60 = angle_30.double();

// Note: multiplication is not precise...
// assert_eq!(Degrees(60.0), Degrees::<f64>::from(result_60));
let delta_angle = (60.0 - Degrees::<f64>::from(result_60).0).abs();
assert!(delta_angle <= 32.0 * f64::EPSILON);

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

Half of the Angle. See: Half-angle formulae

Examples

use angle_sc::{Angle, Degrees};

let angle_30 = Angle::from(Degrees(30.0));
let angle_60 = Angle::from(Degrees(60.0));

assert_eq!(angle_30, angle_60.half());

Trait Implementations

impl<T> Add for Angle<T>

where T: Float,

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

Add two Angles, i.e. a + b Uses trigonometric identity functions, see: angle sum and difference identities.

Examples

use angle_sc::{Angle, Degrees};

let angle_30 = Angle::from(Degrees(30.0));
let angle_60 = Angle::from(Degrees(60.0));
let result_90 = angle_30 + angle_60;
assert_eq!(Degrees(90.0), Degrees::from(result_90));

type Output = Angle<T>

The resulting type after applying the + operator.

impl<T> AddAssign for Angle<T>

where T: Float,

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

Performs the += operation.

impl<T> Clone for Angle<T>

where T: Clone + Float,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Angle<T>

where T: Copy + Float,

impl<T> Debug for Angle<T>

where T: Debug + Float,

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

Formats the value using the given formatter.

impl<T> Default for Angle<T>

where T: Float,

A default angle: zero degrees or radians.

fn default() -> Angle<T>

Implementation of Default for Angle returns Angle(0.0, 1.0), i.e. the Angle corresponding to zero degrees or radians.

Examples

use angle_sc::Angle;

let zero = Angle::<f64>::default();
assert_eq!(0.0, zero.sin().0);
assert_eq!(1.0, zero.cos().0);

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

where T: Float + FloatConst + Deserialize<'de>, f64: From<T>,

fn deserialize<D>( deserializer: D, ) -> Result<Angle<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize an value in Degrees to an Angle.

impl<T> Eq for Angle<T>

where T: Eq + Float,

impl<T> From<(Degrees<T>, Degrees<T>)> for Angle<T>

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

fn from(params: (Degrees<T>, Degrees<T>)) -> Angle<T>

Construct an Angle from the difference of a pair angles in Degrees: a - b

Examples:

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

// Difference of Degrees(-155.0) - Degrees(175.0)
let angle = Angle::from((Degrees(-155.0), Degrees(175.0)));
assert_eq!(0.5, angle.sin().0);
assert_eq!(trig::COS_30_DEGREES, angle.cos().0);
assert_eq!(30.0, Degrees::from(angle).0);

impl<T> From<(Radians<T>, Radians<T>)> for Angle<T>

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

fn from(params: (Radians<T>, Radians<T>)) -> Angle<T>

Construct an Angle from the difference of a pair angles in Radians: a - b

Examples:

use angle_sc::{Angle, Radians, trig};

// 6*π - π/3 radians round trip
let angle = Angle::from((
    Radians(3.0 * core::f64::consts::TAU),
    Radians(core::f64::consts::FRAC_PI_3),
));
assert_eq!(-core::f64::consts::FRAC_PI_3, Radians::from(angle).0);

impl<T> From<Angle<T>> for Radians<T>

where T: Float + FloatConst,

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

Convert an Angle to Radians.

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> From<Radians<T>> for Angle<T>

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

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

Construct an Angle from an angle in Radians.

Examples:

use angle_sc::{Angle, Radians, trig};

let angle = Angle::from(Radians(-core::f64::consts::FRAC_PI_6));
assert_eq!(-0.5, angle.sin().0);
assert_eq!(trig::COS_30_DEGREES, angle.cos().0);
assert_eq!(-core::f64::consts::FRAC_PI_6, Radians::from(angle).0);

impl<T> Neg for Angle<T>

where T: Float,

fn neg(self) -> Angle<T>

An implementation of Neg for Angle, i.e. -angle. Negates the sine of the Angle, does not affect the cosine.

Examples

use angle_sc::{Angle, Degrees};

let angle_45 = Angle::from(Degrees(45.0));
let result_m45 = -angle_45;
assert_eq!(Degrees(-45.0), Degrees::from(result_m45));

type Output = Angle<T>

The resulting type after applying the - operator.

impl<T> PartialEq for Angle<T>

where T: PartialEq + Float,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialOrd for Angle<T>

where T: Float,

fn partial_cmp(&self, other: &Angle<T>) -> Option<Ordering>

Compare two Angles, i.e. a < b. It compares whether an Angle is clockwise of the other Angle on the unit circle.

Examples

use angle_sc::{Angle, Degrees};
let degrees_120 = Angle::from(Degrees(120.0));
let degrees_m120 = -degrees_120;
assert!(degrees_120 < degrees_m120);

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for Angle<T>

where T: Float + FloatConst + Serialize,

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

where S: Serializer,

Serialize an Angle to an value in Degrees.

impl<T> StructuralPartialEq for Angle<T>

where T: PartialEq + Float,

impl<T> Sub for Angle<T>

where T: Float,

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

Subtract two Angles, i.e. a - b Uses trigonometric identity functions, see: angle sum and difference identities.

Examples

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

let angle_30 = Angle::from(Degrees(30.0));
let angle_60 = Angle::from(Degrees(60.0));
let result_30 = angle_60 - angle_30;

assert!(is_within_tolerance(Degrees(30.0).0, Degrees::from(result_30).0, 32.0 * f64::EPSILON));

type Output = Angle<T>

The resulting type after applying the - operator.

impl<T> SubAssign for Angle<T>

where T: Float,

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

Performs the -= operation.

impl<T> Validate for Angle<T>

where T: Float,

fn is_valid(&self) -> bool

Test whether an Angle is valid, i.e. both sin and cos are valid UnitNegRanges and the length of their hypotenuse is approximately 1.0.