Struct Angle 

pub struct Angle { /* private fields */ }

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

Implementations

impl Angle

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

Construct an Angle from sin and cos values.

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

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

pub const fn sin(self) -> UnitNegRange

The sine of the Angle.

pub const fn cos(self) -> UnitNegRange

The cosine of the Angle.

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

The tangent of the Angle.

returns the tangent or None if self.cos < SQ_EPSILON

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

The cosecant of the Angle.

returns the cosecant or None if self.sin < SQ_EPSILON

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

The secant of the Angle.

returns the secant or None if self.cos < SQ_EPSILON

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

The cotangent of the Angle.

returns the cotangent or None if self.sin < SQ_EPSILON

pub const fn abs(self) -> Angle

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

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

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

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

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

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::from(result_60));
let delta_angle = (60.0 - Degrees::from(result_60).0).abs();
assert!(delta_angle <= 32.0 * f64::EPSILON);

pub fn half(self) -> Angle

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 Add for Angle

fn add(self, other: Angle) -> <Angle 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

The resulting type after applying the + operator.

impl AddAssign for Angle

fn add_assign(&mut self, other: Angle)

Performs the += operation.

impl Clone for Angle

fn clone(&self) -> Angle

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl Default for Angle

A default angle: zero degrees or radians.

fn default() -> Angle

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::default();
assert_eq!(0.0, zero.sin().0);
assert_eq!(1.0, zero.cos().0);

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

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

where D: Deserializer<'de>,

Deserialize an value in Degrees to an Angle.

impl From<(Degrees, Degrees)> for Angle

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

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 From<(Radians, Radians)> for Angle

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

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 From<Angle> for Degrees

fn from(a: Angle) -> Degrees

Convert an Angle to Degrees.

impl From<Angle> for Radians

fn from(a: Angle) -> Radians

Convert an Angle to Radians.

impl From<Degrees> for Angle

fn from(a: Degrees) -> Angle

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

fn from(a: Radians) -> Angle

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 Neg for Angle

fn neg(self) -> Angle

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

The resulting type after applying the - operator.

impl PartialEq for Angle

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Angle

fn partial_cmp(&self, other: &Angle) -> 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 Serialize for Angle

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 Sub for Angle

fn sub(self, other: Angle) -> <Angle 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

The resulting type after applying the - operator.

impl SubAssign for Angle

fn sub_assign(&mut self, other: Angle)

Performs the -= operation.

impl Validate for Angle

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.

impl Copy for Angle

impl StructuralPartialEq for Angle