Struct Moebius 

pub struct Moebius<T> { /* private fields */ }

Implementations

impl<T> Moebius<T>

pub fn new(a: T, b: T, c: T, d: T) -> Self

pub fn from_matrix(mat: Matrix2x2<T>) -> Self

pub fn into_matrix(self) -> Matrix2x2<T>

pub fn as_matrix(&self) -> &Matrix2x2<T>

pub fn as_mut_matrix(&mut self) -> &mut Matrix2x2<T>

pub fn from_array(array: [[T; 2]; 2]) -> Self

pub fn into_array(self) -> [[T; 2]; 2]

pub fn as_array_of_arrays(&self) -> &[[T; 2]; 2]

pub fn as_mut_array_of_arrays(&mut self) -> &mut [[T; 2]; 2]

pub fn from_tuple(tup: (T, T, T, T)) -> Self

pub fn into_tuple(self) -> (T, T, T, T)

impl<T: Copy> Moebius<T>

pub fn a(&self) -> T

pub fn b(&self) -> T

pub fn c(&self) -> T

pub fn d(&self) -> T

impl<T> Moebius<T>

pub fn a_ref(&self) -> &T

pub fn b_ref(&self) -> &T

pub fn c_ref(&self) -> &T

pub fn d_ref(&self) -> &T

pub fn a_mut(&mut self) -> &mut T

pub fn b_mut(&mut self) -> &mut T

pub fn c_mut(&mut self) -> &mut T

pub fn d_mut(&mut self) -> &mut T

impl<T: Zero + One> Moebius<T>

pub fn identity() -> Self

impl<T> Moebius<T>

where T: Add<Output = T> + Mul<Output = T> + Div<Output = T> + Copy,

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

impl<T> Moebius<T>

pub fn apply<U>(&self, x: U) -> U

where T: Mul<U, Output = U> + Copy, U: Add<T, Output = U> + Div<Output = U> + Copy,

impl<T: Neg<Output = T> + Num + Copy> Moebius<T>

pub fn det(&self) -> T

impl<T> Moebius<Complex<T>>

where T: Neg<Output = T> + Num + Copy,

pub fn deriv(&self, p: Complex<T>) -> Complex<T>

impl<T> Moebius<Complex<T>>

where T: Neg<Output = T> + Num + NumCast + Copy,

pub fn deriv_dir(&self, p: Quaternion<T>, v: Quaternion<T>) -> Quaternion<T>

impl<T> Moebius<T>

where T: Neg<Output = T> + Num + Copy,

pub fn inv(self) -> Self

Trait Implementations

impl<T> AbsDiffEq for Moebius<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 Moebius<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Moebius<T>

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

Formats the value using the given formatter.

impl<T> Directional<Complex<T>> for Moebius<Complex<T>>

where Self: Transform<Complex<T>>, Complex<T>: Normalize,

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

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

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

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

impl<T> Directional<Quaternion<T>> for Moebius<Complex<T>>

where Self: Transform<Quaternion<T>>, Quaternion<T>: Normalize,

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

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

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

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

impl<T: Neg<Output = T> + Num + Copy> Distribution<Moebius<T>> for Invertible

where Invertible: Distribution<Matrix<T, 2, 2>>,

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Moebius<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, Self: Sized,

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

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<'a, T> From<&'a Moebius<T>> for &'a [[T; 2]; 2]

fn from(mo: &'a Moebius<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a Moebius<T>> for &'a Matrix2x2<T>

fn from(mo: &'a Moebius<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a mut Moebius<T>> for &'a mut [[T; 2]; 2]

fn from(mo: &'a mut Moebius<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<&'a mut Moebius<T>> for &'a mut Matrix2x2<T>

fn from(mo: &'a mut Moebius<T>) -> Self

Converts to this type from the input type.

impl<T> From<[[T; 2]; 2]> for Moebius<T>

fn from(array: [[T; 2]; 2]) -> Self

Converts to this type from the input type.

impl<T> From<Matrix<T, 2, 2>> for Moebius<T>

fn from(mat: Matrix2x2<T>) -> Self

Converts to this type from the input type.

impl<T> From<Moebius<T>> for [[T; 2]; 2]

fn from(mo: Moebius<T>) -> Self

Converts to this type from the input type.

impl<T> From<Moebius<T>> for Matrix2x2<T>

fn from(mo: Moebius<T>) -> Self

Converts to this type from the input type.

impl<T: Neg<Output = T> + Num + Copy> Normalize for Moebius<T>

fn normalize(self) -> Self

Normalize object.

impl<T: PartialEq> PartialEq for Moebius<T>

fn eq(&self, other: &Moebius<T>) -> 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<T> Transform<Complex<T>> for Moebius<Complex<T>>

where T: Neg<Output = T> + Num + Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

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

Perform the transformation itself.

fn deriv(&self, pos: Complex<T>, dir: Complex<T>) -> Complex<T>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one.

impl<T> Transform<Quaternion<T>> for Moebius<Complex<T>>

where T: Neg<Output = T> + Num + NumCast + Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

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

Perform the transformation itself.

fn deriv(&self, pos: Quaternion<T>, dir: Quaternion<T>) -> Quaternion<T>

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 Moebius<T>

impl<T> StructuralPartialEq for Moebius<T>