Struct Radians 

#[repr(transparent)]
pub struct Radians<T: Float + FloatConst>(pub T);

The Radians newtype an f64.

Tuple Fields

0: T

Implementations

impl<T: Float + FloatConst> Radians<T>

pub fn abs(self) -> Self

The absolute value of the angle.

pub fn half(self) -> Self

Half of the angle.

pub fn opposite(self) -> Self

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

pub fn clamp(self, max_value: Self) -> Self

Clamp value into the range: 0.0..=max_value.

Examples

use angle_sc::Radians;

let value = Radians(-f64::EPSILON);
assert_eq!(Radians(0.0), value.clamp(Radians(1.0)));
let value = Radians(0.0);
assert_eq!(Radians(0.0), value.clamp(Radians(1.0)));
let value = Radians(1.0);
assert_eq!(Radians(1.0), value.clamp(Radians(1.0)));
let value = Radians(1.0 + f64::EPSILON);
assert_eq!(Radians(1.0), value.clamp(Radians(1.0)));

Trait Implementations

impl<T: Float + FloatConst> Add for Radians<T>

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

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

Examples

use angle_sc::{Radians, is_within_tolerance};

let angle_120 = Radians(2.0 * core::f64::consts::FRAC_PI_3);
let result = angle_120 + angle_120;
assert!(is_within_tolerance(-2.0 * core::f64::consts::FRAC_PI_3, result.0,  4.0 * f64::EPSILON));

type Output = Radians<T>

The resulting type after applying the + operator.

impl<T: Float + FloatConst> AddAssign for Radians<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone + Float + FloatConst> Clone for Radians<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Float + FloatConst> Copy for Radians<T>

impl<T: Debug + Float + FloatConst> Debug for Radians<T>

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

Formats the value using the given formatter.

impl<T: Float + FloatConst> Default for Radians<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Eq + Float + FloatConst> Eq for Radians<T>

impl<T: Float + FloatConst> From<Angle<T>> for Radians<T>

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

Convert an Angle to Radians.

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

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

fn from(a: Radians<T>) -> 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<T: Float + FloatConst> Neg for Radians<T>

fn neg(self) -> Self

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

Examples

use angle_sc::Radians;

let angle_45 = Radians(core::f64::consts::FRAC_PI_4);
let result_m45 = -angle_45;
assert_eq!(-core::f64::consts::FRAC_PI_4, result_m45.0);

type Output = Radians<T>

The resulting type after applying the - operator.

impl<T: PartialEq + Float + FloatConst> PartialEq for Radians<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialOrd + Float + FloatConst> PartialOrd for Radians<T>

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

This method returns an ordering between self and other values if one exists.

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: PartialEq + Float + FloatConst> StructuralPartialEq for Radians<T>

impl<T: Float + FloatConst> Sub for Radians<T>

fn sub(self, other: Self) -> Self::Output

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

Examples

use angle_sc::{Radians, is_within_tolerance};

let angle_120 = Radians(2.0 * core::f64::consts::FRAC_PI_3);
let angle_m120 = -angle_120;
let result = angle_m120 - angle_120;
assert!(is_within_tolerance(angle_120.0, result.0,  4.0 * f64::EPSILON));

type Output = Radians<T>

The resulting type after applying the - operator.

impl<T: Float + FloatConst> SubAssign for Radians<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.