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) -> Self

Construct an Angle from sin and cos values.

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

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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) -> Self

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: Self) -> Self::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: Self)

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

impl Debug for Angle

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

Formats the value using the given formatter.

impl Default for Angle

A default angle: zero degrees or radians.

fn default() -> Self

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<Self, D::Error>

where D: Deserializer<'de>,

Deserialize an value in Degrees to an Angle.

impl From<(Degrees, Degrees)> for Angle

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

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)) -> Self

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) -> Self

Convert an Angle to Degrees.

impl From<Angle> for Radians

fn from(a: Angle) -> Self

Convert an Angle to Radians.

impl From<Degrees> for Angle

fn from(a: Degrees) -> Self

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) -> Self

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) -> Self

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: &Self) -> 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::Ok, S::Error>

where S: Serializer,

Serialize an Angle to an value in Degrees.

impl StructuralPartialEq for Angle

impl Sub for Angle

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

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.