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

```#[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> PartialOrd<Id<O>> for Id<O> where    O: Operator, `[src]

#### `fn partial_cmp(&self, &Id<O>) -> Option<Ordering>`[src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn le(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn gt(&self, other: &Rhs) -> bool`1.0.0[src]

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

#### `fn ge(&self, other: &Rhs) -> bool`1.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> 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<E> Rotation<E> for Id<Multiplicative> where    E: EuclideanSpace, `[src]

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

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

#### `fn rotation_between(    a: &<E as EuclideanSpace>::Coordinates,     b: &<E as EuclideanSpace>::Coordinates) -> Option<Id<Multiplicative>>`[src]

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

#### `fn scaled_rotation_between(    a: &<E as EuclideanSpace>::Coordinates,     b: &<E as EuclideanSpace>::Coordinates,     <E as EuclideanSpace>::Real) -> Option<Id<Multiplicative>>`[src]

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

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

#### `type Epsilon = Id<O>`

Used for specifying relative comparisons.

#### `fn default_epsilon() -> <Id<O> as ApproxEq>::Epsilon`[src]

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

#### `fn default_max_relative() -> <Id<O> as ApproxEq>::Epsilon`[src]

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

#### `fn default_max_ulps() -> u32`[src]

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

#### `fn relative_eq(    &self,     &Id<O>,     <Id<O> as ApproxEq>::Epsilon,     <Id<O> as ApproxEq>::Epsilon) -> bool`[src]

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

#### `fn ulps_eq(&self, &Id<O>, <Id<O> as ApproxEq>::Epsilon, u32) -> bool`[src]

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

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

The inverse of `ApproxEq::relative_eq`.

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

The inverse of `ApproxEq::ulps_eq`.

### `impl AddAssign<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `fn add_assign(&mut self, Id<Multiplicative>)`[src]

Performs the `+=` operation.

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

#### `fn eq(&self, &Id<O>) -> bool`[src]

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

#### `fn ne(&self, other: &Rhs) -> bool`1.0.0[src]

This method tests for `!=`.

### `impl Add<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `type Output = Id<Multiplicative>`

The resulting type after applying the `+` operator.

#### `fn add(self, Id<Multiplicative>) -> Id<Multiplicative>`[src]

Performs the `+` operation.

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

#### `fn inverse(&self) -> Id<O>`[src]

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

#### `fn inverse_mut(&mut self)`[src]

In-place inversin of `self`.

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

#### `fn to_superset(&self) -> T`[src]

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

#### `fn is_in_subset(t: &T) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(&T) -> Id<O>`[src]

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

#### `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> JoinSemilattice for Id<O> where    O: Operator, `[src]

#### `fn join(&self, &Id<O>) -> Id<O>`[src]

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

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

#### `fn to_vector(&self) -> <E as EuclideanSpace>::Coordinates`[src]

Converts this translation to a vector.

#### `fn from_vector(    v: <E as EuclideanSpace>::Coordinates) -> Option<Id<Multiplicative>>`[src]

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

#### `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)`.

### `impl DivAssign<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `fn div_assign(&mut self, Id<Multiplicative>)`[src]

Performs the `/=` operation.

### `impl<O> Debug for Id<O> where    O: Operator + Debug, `[src]

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

### `impl Zero for Id<Multiplicative>`[src]

#### `fn zero() -> Id<Multiplicative>`[src]

Returns the additive identity element of `Self`, `0`. Read more

#### `fn is_zero(&self) -> bool`[src]

Returns `true` if `self` is equal to the additive identity.

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

#### `fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where    Self: ApproxEq, `[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 Mul<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `type Output = Id<Multiplicative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, Id<Multiplicative>) -> Id<Multiplicative>`[src]

Performs the `*` operation.

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

#### `fn operate(&self, &Id<O>) -> Id<O>`[src]

Performs an operation.

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

Performs specific operation.

### `impl MulAssign<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `fn mul_assign(&mut self, Id<Multiplicative>)`[src]

Performs the `*=` operation.

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

#### `fn clone(&self) -> Id<O>`[src]

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

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

#### `fn meet(&self, &Id<O>) -> Id<O>`[src]

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

### `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<O> Identity<O> for Id<O> where    O: Operator, `[src]

#### `fn identity() -> Id<O>`[src]

The identity element.

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

Specific identity.

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

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`[src]

Formats the value using the given formatter. Read more

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

#### `fn prop_is_commutative_approx(args: (Self, Self)) -> bool where    Self: ApproxEq, `[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 One for Id<Multiplicative>`[src]

#### `fn one() -> Id<Multiplicative>`[src]

Returns the multiplicative identity element of `Self`, `1`. Read more

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

Returns `true` if `self` is equal to the multiplicative identity. 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 translation(    &self) -> <Id<Multiplicative> as AffineTransformation<E>>::Translation`[src]

The pure translational component of this similarity transformation.

#### `fn rotation(&self) -> <Id<Multiplicative> as AffineTransformation<E>>::Rotation`[src]

The pure rotational component of this similarity transformation.

#### `fn scaling(&self) -> <Id<Multiplicative> as Similarity<E>>::Scaling`[src]

The pure scaling component 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<O> AbstractMonoid<O> for Id<O> where    O: Operator, `[src]

#### `fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where    Self: ApproxEq, `[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 Div<Id<Multiplicative>> for Id<Multiplicative>`[src]

#### `type Output = Id<Multiplicative>`

The resulting type after applying the `/` operator.

#### `fn div(self, Id<Multiplicative>) -> Id<Multiplicative>`[src]

Performs the `/` operation.

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

#### `fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where    Self: ApproxEq, `[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<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 decompose(    &self) -> (Id<Multiplicative>, Id<Multiplicative>, Id<Multiplicative>, Id<Multiplicative>)`[src]

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

#### `fn append_translation(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::Translation) -> Id<Multiplicative>`[src]

Appends a translation to this similarity.

#### `fn prepend_translation(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::Translation) -> Id<Multiplicative>`[src]

Prepends a translation to this similarity.

#### `fn append_rotation(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::Rotation) -> Id<Multiplicative>`[src]

Appends a rotation to this similarity.

#### `fn prepend_rotation(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::Rotation) -> Id<Multiplicative>`[src]

Prepends a rotation to this similarity.

#### `fn append_scaling(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::NonUniformScaling) -> Id<Multiplicative>`[src]

Appends a scaling factor to this similarity.

#### `fn prepend_scaling(    &self,     &<Id<Multiplicative> as AffineTransformation<E>>::NonUniformScaling) -> Id<Multiplicative>`[src]

Prepends a scaling factor to this similarity.

#### `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<E> ProjectiveTransformation<E> for Id<Multiplicative> where    E: EuclideanSpace, `[src]

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

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

Applies this group's inverse action on a vector from the euclidean space. Read more

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

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

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

Applies this group's action on a vector from the euclidean space. Read more