Struct vecmat::transform::Rotation2

pub struct Rotation2<T> { /* fields omitted */ }

Two-dimensional rotation.

Implementations

impl<T> Rotation2<T>

pub fn from_complex(comp: Complex<T>) -> Self

pub fn into_complex(self) -> Complex<T>

impl<T> Rotation2<T> where
    T: Float, 

pub fn new(angle: T) -> Self

pub fn angle(&self) -> T

impl<T> Rotation2<T> where
    T: Neg<Output = T> + Copy, 

pub fn to_linear(self) -> Linear<T, 2>

Trait Implementations

impl<T> AbsDiffEq<Rotation2<T>> for Rotation2<T> where
    T: AbsDiffEq<Epsilon = T> + Copy, 

type Epsilon = T

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Clone> Clone for Rotation2<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Rotation2<T>

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

Formats the value using the given formatter.

impl<T> Directional<Vector<T, 2_usize>> for Rotation2<T> where
    Self: Transform<Vector<T, 2>>, 

fn apply_dir(&self, pos: Vector<T, 2>, dir: Vector<T, 2>) -> Vector<T, 2>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, pos: Vector<T, 2>, normal: Vector<T, 2>) -> Vector<T, 2>

Returns the result of the normal transformation at the specified position.

impl<T> Distribution<Rotation2<T>> for Uniform where
    RangedUniform<T>: Distribution<T>,
    T: SampleUniform + Float + FloatConst + NumCast, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Rotation2<T>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T> From<Complex<T>> for Rotation2<T>

fn from(comp: Complex<T>) -> Self

Performs the conversion.

impl<T> From<Rotation2<T>> for Complex<T>

fn from(rot: Rotation2<T>) -> Self

Performs the conversion.

impl<T: PartialEq> PartialEq<Rotation2<T>> for Rotation2<T>

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

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

fn ne(&self, other: &Rotation2<T>) -> bool

This method tests for !=.

impl<T> Reorder<Rotation2<T>, Vector<T, 2_usize>> for Shift<T, 2> where
    Rotation2<T>: Transform<Vector<T, 2>> + Copy,
    Self: Transform<Vector<T, 2>>, 

fn reorder(self, other: Rotation2<T>) -> (Rotation2<T>, Shift<T, 2>)

For given A and B returns B' and A'.

impl<T> Reorder<Shift<T, 2_usize>, Vector<T, 2_usize>> for Rotation2<T> where
    Self: Transform<Vector<T, 2>>,
    Shift<T, 2>: Transform<Vector<T, 2>>, 

fn reorder(self, other: Shift<T, 2>) -> (Shift<T, 2>, Rotation2<T>)

For given A and B returns B' and A'.

impl<T> Transform<Vector<T, 2_usize>> for Rotation2<T> where
    T: Neg<Output = T> + Num + Copy, 

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, 2>) -> Vector<T, 2>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, 2>, dir: Vector<T, 2>) -> Vector<T, 2>

Find transformation directional derivative at specified point.

fn chain(self, other: Self) -> Self

Chain two transformations into a new one.

impl<T: Copy> Copy for Rotation2<T>

impl<T> StructuralPartialEq for Rotation2<T>