# [−]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, `

#### `pub fn new() -> Id<O>`

Creates a new identity element.

## Trait Implementations

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

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

This method tests for `!=`.

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

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

The inverse of `ApproxEq::ulps_eq`.

### `impl Mul<Id<Multiplicative>> for Id<Multiplicative>`

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

The resulting type after applying the `*` operator.

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

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

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

### `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 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> AbsDiffEq for Id<O> where    O: Operator, `

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

Used for specifying relative comparisons.

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

The inverse of `ApproxEq::abs_diff_eq`.

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

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

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

Performs copy-assignment from `source`. Read more

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

#### `fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where    Self: RelativeEq, `

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, `

Returns `true` if latin squareness holds for the given arguments. Read more

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

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

Performs specific operation.

### `impl One for Id<Multiplicative>`

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

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

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

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

The inverse of `ApproxEq::relative_eq`.

### `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 self, other: &'a Self) -> Option<&'a Self>`

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

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

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

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

Sorts two values in increasing order using a partial ordering.

#### `fn partial_clamp(&'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`. Read more

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

#### `fn id(O) -> Self`

Specific identity.

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

#### `fn prop_is_commutative_approx(args: (Self, Self)) -> bool where    Self: RelativeEq, `

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, `

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

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

#### `fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where    Self: RelativeEq, `

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, `

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

### `impl Div<Id<Multiplicative>> for Id<Multiplicative>`

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

The resulting type after applying the `/` operator.

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

#### `fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where    Self: RelativeEq, `

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, `

Returns `true` if associativity holds for the given arguments.

### `impl<O> PartialOrd<Id<O>> for Id<O> where    O: Operator, `

#### ```#[must_use] 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

#### ```#[must_use] 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

#### ```#[must_use] 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

#### ```#[must_use] 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 Add<Id<Additive>> for Id<Additive>`

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

The resulting type after applying the `+` operator.

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

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

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

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

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

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

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

#### `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, `

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

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, `

#### `type Scaling = R`

The type of the pure (uniform) scaling part 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.