Struct cgmath::Deg

pub struct Deg<S> {
    pub s: S,
}

An angle, in degrees

Fields

s: S

Trait Implementations

impl<R: Into<Rad<S>>, S: BaseFloat> Add<R> for Deg<S>

type Output = Deg<S>

The resulting type after applying the + operator.

fn add(self, other: R) -> Deg<S>

Performs the + operation.

impl<S: BaseFloat> Angle<S> for Deg<S>

fn from<A: Angle<S>>(theta: A) -> Deg<S>

Create a new angle from any other valid angle.

fn full_turn() -> Deg<S>

fn neg_self(&mut self)

Negate this angle, in-place.

fn add_a(&self, other: Self) -> Self

Add this angle with another, returning the new angle.

fn sub_a(&self, other: Self) -> Self

Subtract another angle from this one, returning the new angle.

fn div_a(&self, other: Self) -> S

Divide this angle by another, returning the ratio.

fn rem_a(&self, other: Self) -> S

Take the remainder of this angle with another.

fn mul_s(&self, s: S) -> Self

Multiply this angle by a scalar, returning the new angle.

fn div_s(&self, s: S) -> Self

Divide this angle by a scalar, returing the new angle.

fn rem_s(&self, s: S) -> Self

Take the remainder of this angle by a scalar, returning the new angle.

fn add_self_a(&mut self, other: Self)

Add this angle with another, in-place.

fn sub_self_a(&mut self, other: Self)

Subtract another angle from this one, in-place.

fn mul_self_s(&mut self, s: S)

Multiply this angle by a scalar, in-place.

fn div_self_s(&mut self, s: S)

Divide this angle by a scalar, in-place.

fn rem_self_s(&mut self, s: S)

Take the remainder of this angle by a scalar, in-place.

fn normalize(&self) -> Self

Return the angle, normalized to the range [0, full_turn).

fn normalize_self(&mut self)

Normalize the angle to the range [0, full_turn).

fn opposite(&self) -> Self

Return the angle rotated by half a turn

fn bisect(&self, other: Self) -> Self

Returns the interior bisector of the two angles

fn turn_div_2() -> Self

fn turn_div_3() -> Self

fn turn_div_4() -> Self

fn turn_div_6() -> Self

fn equiv(&self, other: &Self) -> bool

impl<S: BaseFloat> ApproxEq for Deg<S>

type Epsilon = S

fn approx_eq_eps(&self, other: &Deg<S>, epsilon: &S) -> bool

fn approx_epsilon() -> Self::Epsilon

fn approx_eq(&self, other: &Self) -> bool

impl<S: Clone> Clone for Deg<S>

fn clone(&self) -> Deg<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: BaseFloat + Debug> Debug for Deg<S>

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

Formats the value using the given formatter.

impl<S: Decodable> Decodable for Deg<S>

fn decode<__D: Decoder>(d: &mut __D) -> Result<Deg<S>, __D::Error>

Deserialize a value using a Decoder.

impl<S: Encodable> Encodable for Deg<S>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl<S> From<Deg<S>> for Rad<S>where S: BaseFloat,

fn from(d: Deg<S>) -> Rad<S>

Converts to this type from the input type.

impl<S> From<Rad<S>> for Deg<S>where S: BaseFloat,

fn from(r: Rad<S>) -> Deg<S>

Converts to this type from the input type.

impl<S: Hash> Hash for Deg<S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R: Into<Rad<S>>, S: BaseFloat> Mul<R> for Deg<S>

type Output = Deg<S>

The resulting type after applying the * operator.

fn mul(self, other: R) -> Deg<S>

Performs the * operation.

impl<S: BaseFloat> Neg for Deg<S>

type Output = Deg<S>

The resulting type after applying the - operator.

fn neg(self) -> Deg<S>

Performs the unary - operation.

impl<S: BaseFloat> One for Deg<S>

fn one() -> Deg<S>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> boolwhere Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<S: PartialEq> PartialEq<Deg<S>> for Deg<S>

fn eq(&self, other: &Deg<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<S: PartialOrd> PartialOrd<Deg<S>> for Deg<S>

fn partial_cmp(&self, other: &Deg<S>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<S: BaseFloat + PartialOrd + SampleRange + Rand> Rand for Deg<S>

fn rand<R: Rng>(rng: &mut R) -> Deg<S>

Generates a random instance of this type using the specified source of randomness.

impl<R: Into<Rad<S>>, S: BaseFloat> Sub<R> for Deg<S>

type Output = Deg<S>

The resulting type after applying the - operator.

fn sub(self, other: R) -> Deg<S>

Performs the - operation.

impl<S: BaseFloat> Zero for Deg<S>

fn zero() -> Deg<S>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<S: Copy> Copy for Deg<S>

impl<S> StructuralPartialEq for Deg<S>