# [−][src]Struct nalgebra::Id

#[repr(C)]
pub struct Id<O = Multiplicative> where
O: Operator
{ /* fields omitted */ }

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.

## Methods

### impl<O> Id<O> where    O: Operator, [src]

#### pub fn new() -> Id<O>[src]

Creates a new identity element.

## Trait Implementations

### impl<O> PartialEq<Id<O>> for Id<O> where    O: Operator, [src]

#### #[must_use] fn ne(&self, other: &Rhs) -> bool1.0.0[src]

This method tests for !=.

### impl<O> RelativeEq for Id<O> where    O: Operator, [src]

#### fn relative_ne(    &self,     other: &Self,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon) -> bool[src]

The inverse of ApproxEq::relative_eq.

### impl Div<Id<Multiplicative>> for Id<Multiplicative>[src]

#### type Output = Id<Multiplicative>

The resulting type after applying the / operator.

### impl<O> Clone for Id<O> where    O: Operator, [src]

#### fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

### impl<O> PartialOrd<Id<O>> for Id<O> where    O: Operator, [src]

#### #[must_use] fn lt(&self, other: &Rhs) -> bool1.0.0[src]

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

#### #[must_use] fn le(&self, other: &Rhs) -> bool1.0.0[src]

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

#### #[must_use] fn gt(&self, other: &Rhs) -> bool1.0.0[src]

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

#### #[must_use] fn ge(&self, other: &Rhs) -> bool1.0.0[src]

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

### impl<O> AbsDiffEq for Id<O> where    O: Operator, [src]

#### type Epsilon = Id<O>

Used for specifying relative comparisons.

#### fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool[src]

The inverse of ApproxEq::abs_diff_eq.

The resulting type after applying the + operator.

### impl<E> Scaling<E> for Id<Multiplicative> where    E: EuclideanSpace, [src]

#### fn to_real(&self) -> <E as EuclideanSpace>::Real[src]

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

#### fn from_real(r: <E as EuclideanSpace>::Real) -> Option<Self>[src]

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. Read more

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

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. Read more

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

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

### impl<E> Similarity<E> for Id<Multiplicative> where    E: EuclideanSpace, [src]

#### type Scaling = Id<Multiplicative>

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

#### fn translate_point(&self, pt: &E) -> E[src]

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

#### fn rotate_point(&self, pt: &E) -> E[src]

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

#### fn scale_point(&self, pt: &E) -> E[src]

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

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

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

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

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

#### fn inverse_translate_point(&self, pt: &E) -> E[src]

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

#### fn inverse_rotate_point(&self, pt: &E) -> E[src]

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

#### fn inverse_scale_point(&self, pt: &E) -> E[src]

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[src]

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[src]

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

### impl<E> AffineTransformation<E> for Id<Multiplicative> where    E: EuclideanSpace, [src]

#### 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 append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>[src]

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

### impl<O> AbstractQuasigroup<O> for Id<O> where    O: Operator, [src]

#### fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where    Self: RelativeEq, [src]

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

#### fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where    Self: Eq, [src]

Returns true if latin squareness holds for the given arguments.

### impl<O> AbstractMagma<O> for Id<O> where    O: Operator, [src]

#### fn op(&self, O, lhs: &Self) -> Self[src]

Performs specific operation.

### impl Mul<Id<Multiplicative>> for Id<Multiplicative>[src]

#### type Output = Id<Multiplicative>

The resulting type after applying the * operator.

### impl<O> Lattice for Id<O> where    O: Operator, [src]

#### fn meet_join(&self, other: &Self) -> (Self, Self)[src]

Returns the infimum and the supremum simultaneously.

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

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

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

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

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

Sorts two values in increasing order using a partial ordering.

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

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

### impl<O> Identity<O> for Id<O> where    O: Operator, [src]

#### fn id(O) -> Self[src]

Specific identity.

### impl<O> AbstractGroupAbelian<O> for Id<O> where    O: Operator, [src]

#### fn prop_is_commutative_approx(args: (Self, Self)) -> bool where    Self: RelativeEq, [src]

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

#### fn prop_is_commutative(args: (Self, Self)) -> bool where    Self: Eq, [src]

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

### impl<O> AbstractMonoid<O> for Id<O> where    O: Operator, [src]

#### fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where    Self: RelativeEq, [src]

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

#### fn prop_operating_identity_element_is_noop(args: (Self,)) -> bool where    Self: Eq, [src]

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

### impl<O> AbstractSemigroup<O> for Id<O> where    O: Operator, [src]

#### fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where    Self: RelativeEq, [src]

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

#### fn prop_is_associative(args: (Self, Self, Self)) -> bool where    Self: Eq, [src]

Returns true if associativity holds for the given arguments.

### impl<O, T> SubsetOf<T> for Id<O> where    O: Operator,    T: Identity<O> + PartialEq<T>, [src]

#### fn from_superset(element: &T) -> Option<Self>[src]

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

### impl<O> UlpsEq for Id<O> where    O: Operator, [src]

#### fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool[src]

The inverse of ApproxEq::ulps_eq.

### impl One for Id<Multiplicative>[src]

#### fn is_one(&self) -> bool where    Self: PartialEq<Self>, [src]

Returns true if self is equal to the multiplicative identity. Read more

### impl<E> Translation<E> for Id<Multiplicative> where    E: EuclideanSpace, [src]

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

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. Read more

#### fn translation_between(a: &E, b: &E) -> Option<Self>[src]

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

## Blanket Implementations

### impl<T, U> TryFrom for T where    T: From<U>, [src]

#### type Error = !

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

### impl<T, U> TryInto for T where    U: TryFrom<T>, [src]

#### type Error = <U as TryFrom<T>>::Error

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

### impl<T> Same for T[src]

#### type Output = T

Should always be Self

### impl<R, E> AffineTransformation for R where    E: EuclideanSpace<Real = R>,    R: Real,    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,    <E as EuclideanSpace>::Coordinates: ClosedNeg, [src]

#### type Rotation = Id<Multiplicative>

Type of the first rotation to be applied.

#### type NonUniformScaling = R

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 append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>[src]

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

### impl<R, E> Similarity for R where    E: EuclideanSpace<Real = R>,    R: Real + SubsetOf<R>,    <E as EuclideanSpace>::Coordinates: ClosedMul<R>,    <E as EuclideanSpace>::Coordinates: ClosedDiv<R>,    <E as EuclideanSpace>::Coordinates: ClosedNeg, [src]

#### type Scaling = R

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

#### fn translate_point(&self, pt: &E) -> E[src]

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

#### fn rotate_point(&self, pt: &E) -> E[src]

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

#### fn scale_point(&self, pt: &E) -> E[src]

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

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

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

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

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

#### fn inverse_translate_point(&self, pt: &E) -> E[src]

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

#### fn inverse_rotate_point(&self, pt: &E) -> E[src]

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

#### fn inverse_scale_point(&self, pt: &E) -> E[src]

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[src]

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[src]

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