Struct nalgebra::Id

pub struct Id<O = Multiplicative>where
    O: Operator,{ /* private fields */ }

The universal identity element wrt. a given operator, usually noted Id with a context-dependent subscript.

By default, it is the multiplicative identity element. It represents the degenerate set containing only the identity element of any group-like structure. It has no dimension known at compile-time. All its operations are no-ops.

Implementations

impl<O> Id<O>where
    O: Operator,

pub fn new() -> Id<O>

Creates a new identity element.

Trait Implementations

impl<O> AbsDiffEq<Id<O>> for Id<O>where
    O: Operator,

type Epsilon = Id<O>

Used for specifying relative comparisons.

fn default_epsilon() -> <Id<O> as AbsDiffEq<Id<O>>>::Epsilon

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

fn abs_diff_eq(&self, _: &Id<O>, _: <Id<O> as AbsDiffEq<Id<O>>>::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 ApproxEq::abs_diff_eq.

impl<O> AbstractGroupAbelian<O> for Id<O>where
    O: Operator,

fn prop_is_commutative_approx(args: (Self, Self)) -> boolwhere
    Self: RelativeEq<Self>,

Returns true if the operator is commutative for the given argument tuple. Approximate equality is used for verifications.

fn prop_is_commutative(args: (Self, Self)) -> boolwhere
    Self: Eq,

Returns true if the operator is commutative for the given argument tuple.

impl<O> AbstractMagma<O> for Id<O>where
    O: Operator,

fn operate(&self, _: &Id<O>) -> Id<O>

Performs an operation.

fn op(&self, _: O, lhs: &Self) -> Self

Performs specific operation.

impl<O> AbstractMonoid<O> for Id<O>where
    O: Operator,

fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> boolwhere
    Self: RelativeEq<Self>,

Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications.

fn prop_operating_identity_element_is_noop(args: (Self,)) -> boolwhere
    Self: Eq,

Checks whether operating with the identity element is a no-op for the given argument.

impl<O> AbstractQuasigroup<O> for Id<O>where
    O: Operator,

fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> boolwhere
    Self: RelativeEq<Self>,

Returns true if latin squareness holds for the given arguments. Approximate equality is used for verifications.

fn prop_inv_is_latin_square(args: (Self, Self)) -> boolwhere
    Self: Eq,

Returns true if latin squareness holds for the given arguments.

impl<O> AbstractSemigroup<O> for Id<O>where
    O: Operator,

fn prop_is_associative_approx(args: (Self, Self, Self)) -> boolwhere
    Self: RelativeEq<Self>,

Returns true if associativity holds for the given arguments. Approximate equality is used for verifications.

fn prop_is_associative(args: (Self, Self, Self)) -> boolwhere
    Self: Eq,

Returns true if associativity holds for the given arguments.

impl Add<Id<Additive>> for Id<Additive>

type Output = Id<Additive>

The resulting type after applying the + operator.

fn add(self, _: Id<Additive>) -> Id<Additive>

Performs the + operation.

impl AddAssign<Id<Additive>> for Id<Additive>

fn add_assign(&mut self, _: Id<Additive>)

Performs the += operation.

impl<E> AffineTransformation<E> for Id<Multiplicative>where
    E: EuclideanSpace,

type Rotation = Id<Multiplicative>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Id<Multiplicative>

The type of the pure translation part of this affine transformation.

fn decompose(
    &self
) -> (Id<Multiplicative>, Id<Multiplicative>, Id<Multiplicative>, Id<Multiplicative>)

Decomposes this affine transformation into a rotation followed by a non-uniform scaling, followed by a rotation, followed by a translation.

fn append_translation(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::Translation
) -> Id<Multiplicative>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::Translation
) -> Id<Multiplicative>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::Rotation
) -> Id<Multiplicative>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::Rotation
) -> Id<Multiplicative>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::NonUniformScaling
) -> Id<Multiplicative>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    _: &<Id<Multiplicative> as AffineTransformation<E>>::NonUniformScaling
) -> Id<Multiplicative>

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant.

impl<O> Clone for Id<O>where
    O: Operator,

fn clone(&self) -> Id<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O> Debug for Id<O>where
    O: Debug + Operator,

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

Formats the value using the given formatter.

impl<O> Display for Id<O>where
    O: Operator,

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

Formats the value using the given formatter.

impl Div<Id<Multiplicative>> for Id<Multiplicative>

type Output = Id<Multiplicative>

The resulting type after applying the / operator.

fn div(self, _: Id<Multiplicative>) -> Id<Multiplicative>

Performs the / operation.

impl DivAssign<Id<Multiplicative>> for Id<Multiplicative>

fn div_assign(&mut self, _: Id<Multiplicative>)

Performs the /= operation.

impl<O> Identity<O> for Id<O>where
    O: Operator,

fn identity() -> Id<O>

The identity element.

fn id(_: O) -> Selfwhere
    Self: Sized,

Specific identity.

impl<O> Inverse<O> for Id<O>where
    O: Operator,

fn inverse(&self) -> Id<O>

Returns the inverse of self, relative to the operator O.

fn inverse_mut(&mut self)

In-place inversin of self.

impl<O> JoinSemilattice for Id<O>where
    O: Operator,

fn join(&self, _: &Id<O>) -> Id<O>

Returns the join (aka. supremum) of two values.

impl<O> Lattice for Id<O>where
    O: Operator,

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

Returns the infimum and the supremum simultaneously.

fn partial_min<'a>(&'a self, other: &'a Self) -> Option<&'a Self>

Return the minimum of self and other if they are comparable.

fn partial_max<'a>(&'a self, other: &'a Self) -> Option<&'a Self>

Return the maximum of self and other if they are comparable.

fn partial_sort2<'a>(&'a self, other: &'a Self) -> Option<(&'a Self, &'a Self)>

Sorts two values in increasing order using a partial ordering.

fn partial_clamp<'a>(&'a self, min: &'a Self, max: &'a Self) -> Option<&'a Self>

Clamp value between min and max. Returns None if value is not comparable to min or max.

impl<O> MeetSemilattice for Id<O>where
    O: Operator,

fn meet(&self, _: &Id<O>) -> Id<O>

Returns the meet (aka. infimum) of two values.

impl Mul<Id<Multiplicative>> for Id<Multiplicative>

type Output = Id<Multiplicative>

The resulting type after applying the * operator.

fn mul(self, _: Id<Multiplicative>) -> Id<Multiplicative>

Performs the * operation.

impl MulAssign<Id<Multiplicative>> for Id<Multiplicative>

fn mul_assign(&mut self, _: Id<Multiplicative>)

Performs the *= operation.

impl One for Id<Multiplicative>

fn one() -> Id<Multiplicative>

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<O> PartialEq<Id<O>> for Id<O>where
    O: Operator,

fn eq(&self, _: &Id<O>) -> 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<O> PartialOrd<Id<O>> for Id<O>where
    O: Operator,

fn partial_cmp(&self, _: &Id<O>) -> 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<E> ProjectiveTransformation<E> for Id<Multiplicative>where
    E: EuclideanSpace,

fn inverse_transform_point(&self, pt: &E) -> E

Applies this group’s inverse action on a point from the euclidean space.

fn inverse_transform_vector(
    &self,
    v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this group’s inverse action on a vector from the euclidean space.

impl<O> RelativeEq<Id<O>> for Id<O>where
    O: Operator,

fn default_max_relative() -> <Id<O> as AbsDiffEq<Id<O>>>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    _: &Id<O>,
    _: <Id<O> as AbsDiffEq<Id<O>>>::Epsilon,
    _: <Id<O> as AbsDiffEq<Id<O>>>::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

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

The inverse of ApproxEq::relative_eq.

impl<E> Rotation<E> for Id<Multiplicative>where
    E: EuclideanSpace,

fn powf(&self, _: <E as EuclideanSpace>::Real) -> Option<Id<Multiplicative>>

Raises this rotation to a power. If this is a simple rotation, the result must be equivalent to multiplying the rotation angle by n.

fn rotation_between(
    a: &<E as EuclideanSpace>::Coordinates,
    b: &<E as EuclideanSpace>::Coordinates
) -> Option<Id<Multiplicative>>

Computes a simple rotation that makes the angle between a and b equal to zero, i.e., b.angle(a * delta_rotation(a, b)) = 0. If a and b are collinear, the computed rotation may not be unique. Returns None if no such simple rotation exists in the subgroup represented by Self.

fn scaled_rotation_between(
    a: &<E as EuclideanSpace>::Coordinates,
    b: &<E as EuclideanSpace>::Coordinates,
    _: <E as EuclideanSpace>::Real
) -> Option<Id<Multiplicative>>

Computes the rotation between a and b and raises it to the power n.

impl<E> Scaling<E> for Id<Multiplicative>where
    E: EuclideanSpace,

fn to_real(&self) -> <E as EuclideanSpace>::Real

Converts this scaling factor to a real. Same as self.to_superset().

fn from_real(r: <E as EuclideanSpace>::Real) -> Option<Self>

Attempts to convert a real to an element of this scaling subgroup. Same as Self::from_superset(). Returns None if no such scaling is possible for this subgroup.

fn powf(&self, n: <E as EuclideanSpace>::Real) -> Option<Self>

Raises the scaling to a power. The result must be equivalent to self.to_superset().powf(n). Returns None if the result is not representable by Self.

fn scale_between(
    a: &<E as EuclideanSpace>::Coordinates,
    b: &<E as EuclideanSpace>::Coordinates
) -> Option<Self>

The scaling required to make a have the same norm as b, i.e., |b| = |a| * norm_ratio(a, b).

impl<E> Similarity<E> for Id<Multiplicative>where
    E: EuclideanSpace,

type Scaling = Id<Multiplicative>

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(
    &self
) -> <Id<Multiplicative> as AffineTransformation<E>>::Translation

The pure translational component of this similarity transformation.

fn rotation(&self) -> <Id<Multiplicative> as AffineTransformation<E>>::Rotation

The pure rotational component of this similarity transformation.

fn scaling(&self) -> <Id<Multiplicative> as Similarity<E>>::Scaling

The pure scaling component of this similarity transformation.

fn translate_point(&self, pt: &E) -> E

Applies this transformation’s pure translational part to a point.

fn rotate_point(&self, pt: &E) -> E

Applies this transformation’s pure rotational part to a point.

fn scale_point(&self, pt: &E) -> E

Applies this transformation’s pure scaling part to a point.

fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation’s pure rotational part to a vector.

fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation’s pure scaling part to a vector.

fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse’s pure translational part to a point.

fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse’s pure rotational part to a point.

fn inverse_scale_point(&self, pt: &E) -> E

Applies this transformation inverse’s pure scaling part to a point.

fn inverse_rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse’s pure rotational part to a vector.

fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse’s pure scaling part to a vector.

impl<O, T> SubsetOf<T> for Id<O>where
    O: Operator,
    T: PartialEq<T> + Identity<O>,

fn to_superset(&self) -> T

The inclusion map: converts self to the equivalent element of its superset.

fn is_in_subset(t: &T) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

unsafe fn from_superset_unchecked(_: &T) -> Id<O>

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<E> Transformation<E> for Id<Multiplicative>where
    E: EuclideanSpace,

fn transform_point(&self, pt: &E) -> E

Applies this group’s action on a point from the euclidean space.

fn transform_vector(
    &self,
    v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this group’s action on a vector from the euclidean space.

impl<E> Translation<E> for Id<Multiplicative>where
    E: EuclideanSpace,

fn to_vector(&self) -> <E as EuclideanSpace>::Coordinates

Converts this translation to a vector.

fn from_vector(
    v: <E as EuclideanSpace>::Coordinates
) -> Option<Id<Multiplicative>>

Attempts to convert a vector to this translation. Returns None if the translation represented by v is not part of the translation subgroup represented by Self.

fn powf(&self, n: <E as EuclideanSpace>::Real) -> Option<Self>

Raises the translation to a power. The result must be equivalent to self.to_superset() * n. Returns None if the result is not representable by Self.

fn translation_between(a: &E, b: &E) -> Option<Self>

The translation needed to make a coincide with b, i.e., b = a * translation_to(a, b).

impl<O> UlpsEq<Id<O>> for Id<O>where
    O: Operator,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    _: &Id<O>,
    _: <Id<O> as AbsDiffEq<Id<O>>>::Epsilon,
    _: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl Zero for Id<Additive>

fn zero() -> Id<Additive>

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<O> AbstractGroup<O> for Id<O>where
    O: Operator,

impl<O> AbstractLoop<O> for Id<O>where
    O: Operator,

impl<O> Copy for Id<O>where
    O: Operator,

impl<E> DirectIsometry<E> for Id<Multiplicative>where
    E: EuclideanSpace,

impl<O> Eq for Id<O>where
    O: Operator,

impl<E> Isometry<E> for Id<Multiplicative>where
    E: EuclideanSpace,

impl<E> OrthogonalTransformation<E> for Id<Multiplicative>where
    E: EuclideanSpace,