Struct pythagore::transform::transform_nd::Transform

pub struct Transform<N: Num, const D: usize> { /* private fields */ }

Transform<N, D> structure for D dimension transformations

Implementations

impl<N: Copy + Num, const D: usize> Transform<N, D>

pub fn identity() -> Self

pub fn scale(by: &Force<N, D>) -> Self

pub fn translate(by: &Force<N, D>) -> Self

impl<N: Copy + Float> Transform<N, 3>

pub fn rotate(theta: N) -> Self

impl<N: Copy + Float> Transform<N, 4>

pub fn rotate_x(theta: N) -> Self

pub fn rotate_y(theta: N) -> Self

pub fn rotate_z(theta: N) -> Self

Trait Implementations

impl<N: Num, const D: usize> AsRef<Matrix<N, D, D>> for Transform<N, D>

fn as_ref(&self) -> &SquareMatrix<N, D>

Converts this type into a shared reference of the (usually inferred) input type.

impl<N: Clone + Num, const D: usize> Clone for Transform<N, D>

fn clone(&self) -> Transform<N, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Num, const D: usize> Debug for Transform<N, D>

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

Formats the value using the given formatter.

impl<N: Copy + Num, const D: usize> Default for Transform<N, D>

fn default() -> Self

Returns the “default value” for a type.

impl<N: Num + Hash, const D: usize> Hash for Transform<N, D>

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<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for &Force<N, D>

type Output = Force<N, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for &Point<N, D>

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for &Transform<N, D>

type Output = Transform<N, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<&Transform<N, D>> for Transform<N, D>

type Output = <&'static Transform<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for &Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for &Point<N, D>

type Output = <&'static Point<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for &Transform<N, D>

type Output = <&'static Transform<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for Force<N, D>

type Output = <&'static Force<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for Point<N, D>

type Output = <&'static Point<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> Mul<Transform<N, D>> for Transform<N, D>

type Output = <&'static Transform<N, D> as Mul<&'static Transform<N, D>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Transform<N, D>) -> Self::Output

Performs the * operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<&Transform<N, D>> for Force<N, D>

fn mul_assign(&mut self, rhs: &Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<&Transform<N, D>> for Point<N, D>

fn mul_assign(&mut self, rhs: &Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<&Transform<N, D>> for Transform<N, D>

fn mul_assign(&mut self, rhs: &Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<Transform<N, D>> for Force<N, D>

fn mul_assign(&mut self, rhs: Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<Transform<N, D>> for Point<N, D>

fn mul_assign(&mut self, rhs: Transform<N, D>)

Performs the *= operation.

impl<N: Copy + Num + Sum, const D: usize> MulAssign<Transform<N, D>> for Transform<N, D>

fn mul_assign(&mut self, rhs: Transform<N, D>)

Performs the *= operation.

impl<N: Num, const D: usize> PartialEq<Transform<N, D>> for Transform<N, D>

fn eq(&self, other: &Self) -> 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<N: Num, const D: usize> TryFrom<Matrix<N, D, D>> for Transform<N, D>

type Error = InvalidTransformMatrixError

The type returned in the event of a conversion error.

fn try_from(matrix: SquareMatrix<N, D>) -> Result<Self, Self::Error>

Performs the conversion.

impl<N: Copy + Num, const D: usize> Copy for Transform<N, D>

impl<N: Eq + Num, const D: usize> Eq for Transform<N, D>

impl<N: Num, const D: usize> StructuralEq for Transform<N, D>