# [−][src]Struct nalgebra::geometry::Isometry

    #[repr(C)]
    pub struct Isometry<N: RealField, D: DimName, R> where
        DefaultAllocator: Allocator<N, D>,  {
        pub rotation: R,
        pub translation: Translation<N, D>,
        // some fields omitted
    }

A direct isometry, i.e., a rotation followed by a translation, aka. a rigid-body motion, aka. an element of a Special Euclidean (SE) group.

## Fields

`rotation: R`

The pure rotational part of this isometry.

`translation: Translation<N, D>`

The pure translational part of this isometry.

## Methods

### `impl<N: RealField, D: DimName, R: Rotation<Point<N, D>>> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

#### `pub fn from_parts(translation: Translation<N, D>, rotation: R) -> Self`[src]

Creates a new isometry from its rotational and translational parts.

# Example

    let tra = Translation3::new(0.0, 0.0, 3.0);
    let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::PI);
    let iso = Isometry3::from_parts(tra, rot);

    assert_relative_eq!(iso * Point3::new(1.0, 2.0, 3.0), Point3::new(-1.0, 2.0, 0.0), epsilon = 1.0e-6);

#### `pub fn inverse(&self) -> Self`[src]

Inverts `self`.

# Example

    let iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
    let inv = iso.inverse();
    let pt = Point2::new(1.0, 2.0);

    assert_eq!(inv * (iso * pt), pt);

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

Inverts `self` in-place.

# Example

    let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
    let pt = Point2::new(1.0, 2.0);
    let transformed_pt = iso * pt;
    iso.inverse_mut();

    assert_eq!(iso * transformed_pt, pt);

#### `pub fn append_translation_mut(&mut self, t: &Translation<N, D>)`[src]

Appends to `self` the given translation in-place.

# Example

    let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
    let tra = Translation2::new(3.0, 4.0);
    // Same as `iso = tra * iso`.
    iso.append_translation_mut(&tra);

    assert_eq!(iso.translation, Translation2::new(4.0, 6.0));

#### `pub fn append_rotation_mut(&mut self, r: &R)`[src]

Appends to `self` the given rotation in-place.

# Example

    let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::PI / 6.0);
    let rot = UnitComplex::new(f32::consts::PI / 2.0);
    // Same as `iso = rot * iso`.
    iso.append_rotation_mut(&rot);

    assert_relative_eq!(iso, Isometry2::new(Vector2::new(-2.0, 1.0), f32::consts::PI * 2.0 / 3.0), epsilon = 1.0e-6);

#### `pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<N, D>)`[src]

Appends in-place to `self` a rotation centered at the point `p`, i.e., the rotation that lets `p` invariant.

# Example

    let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
    let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
    let pt = Point2::new(1.0, 0.0);
    iso.append_rotation_wrt_point_mut(&rot, &pt);

    assert_relative_eq!(iso * pt, Point2::new(-2.0, 0.0), epsilon = 1.0e-6);

#### `pub fn append_rotation_wrt_center_mut(&mut self, r: &R)`[src]

Appends in-place to `self` a rotation centered at the point with coordinates `self.translation`.

# Example

    let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
    let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
    iso.append_rotation_wrt_center_mut(&rot);

    // The translation part should not have changed.
    assert_eq!(iso.translation.vector, Vector2::new(1.0, 2.0));
    assert_eq!(iso.rotation, UnitComplex::new(f32::consts::PI));

#### `pub fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

Transform the given point by this isometry.

This is the same as the multiplication `self * pt`.

# Example

    let tra = Translation3::new(0.0, 0.0, 3.0);
    let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
    let iso = Isometry3::from_parts(tra, rot);

    let transformed_point = iso.transform_point(&Point3::new(1.0, 2.0, 3.0));
    assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6);

#### `pub fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>`[src]

Transform the given vector by this isometry, ignoring the translation component of the isometry.

This is the same as the multiplication `self * v`.

# Example

    let tra = Translation3::new(0.0, 0.0, 3.0);
    let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
    let iso = Isometry3::from_parts(tra, rot);

    let transformed_point = iso.transform_vector(&Vector3::new(1.0, 2.0, 3.0));
    assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

#### `pub fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

Transform the given point by the inverse of this isometry. This may be less expensive than computing the entire isometry inverse and then transforming the point.

# Example

    let tra = Translation3::new(0.0, 0.0, 3.0);
    let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
    let iso = Isometry3::from_parts(tra, rot);

    let transformed_point = iso.inverse_transform_point(&Point3::new(1.0, 2.0, 3.0));
    assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6);

#### `pub fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>`[src]

Transform the given vector by the inverse of this isometry, ignoring the translation component of the isometry. This may be less expensive than computing the entire isometry inverse and then transforming the point.

# Example

    let tra = Translation3::new(0.0, 0.0, 3.0);
    let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
    let iso = Isometry3::from_parts(tra, rot);

    let transformed_point = iso.inverse_transform_vector(&Vector3::new(1.0, 2.0, 3.0));
    assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

### `impl<N: RealField, D: DimName, R> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

#### `pub fn to_homogeneous(&self) -> MatrixN<N, DimNameSum<D, U1>> where
D: DimNameAdd<U1>,
R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,` [src]

Converts this isometry into its equivalent homogeneous transformation matrix.

# Example

    let iso = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_6);
    let expected = Matrix3::new(0.8660254, -0.5,      10.0,
                                0.5,       0.8660254, 20.0,
                                0.0,       0.0,       1.0);

    assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6);

### `impl<N: RealField, D: DimName, R: AlgaRotation<Point<N, D>>> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

#### `pub fn identity() -> Self`[src]

Creates a new identity isometry.

# Example

    let iso = Isometry2::identity();
    let pt = Point2::new(1.0, 2.0);
    assert_eq!(iso * pt, pt);

    let iso = Isometry3::identity();
    let pt = Point3::new(1.0, 2.0, 3.0);
    assert_eq!(iso * pt, pt);

#### `pub fn rotation_wrt_point(r: R, p: Point<N, D>) -> Self`[src]

The isometry that applies the rotation `r` with its axis passing through the point `p`. This effectively lets `p` invariant.

# Example

    let rot = UnitComplex::new(f32::consts::PI);
    let pt = Point2::new(1.0, 0.0);
    let iso = Isometry2::rotation_wrt_point(rot, pt);

    assert_eq!(iso * pt, pt); // The rotation center is not affected.
    assert_relative_eq!(iso * Point2::new(1.0, 2.0), Point2::new(1.0, -2.0), epsilon = 1.0e-6);

### `impl<N: RealField> Isometry<N, U2, Rotation2<N>>`[src]

#### `pub fn new(translation: Vector2<N>, angle: N) -> Self`[src]

Creates a new 2D isometry from a translation and a rotation angle.

Its rotational part is represented as a 2x2 rotation matrix.

# Example

    let iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);

    assert_eq!(iso * Point2::new(3.0, 4.0), Point2::new(-3.0, 5.0));

#### `pub fn translation(x: N, y: N) -> Self`[src]

Creates a new isometry from the given translation coordinates.

#### `pub fn rotation(angle: N) -> Self`[src]

Creates a new isometry from the given rotation angle.

### `impl<N: RealField> Isometry<N, U2, UnitComplex<N>>`[src]

#### `pub fn new(translation: Vector2<N>, angle: N) -> Self`[src]

Creates a new 2D isometry from a translation and a rotation angle.

Its rotational part is represented as an unit complex number.

# Example

    let iso = IsometryMatrix2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);

    assert_eq!(iso * Point2::new(3.0, 4.0), Point2::new(-3.0, 5.0));

#### `pub fn translation(x: N, y: N) -> Self`[src]

Creates a new isometry from the given translation coordinates.

#### `pub fn rotation(angle: N) -> Self`[src]

Creates a new isometry from the given rotation angle.

### `impl<N: RealField> Isometry<N, U3, Rotation3<N>>`[src]

#### `pub fn new(translation: Vector3<N>, axisangle: Vector3<N>) -> Self`[src]

Creates a new isometry from a translation and a rotation axis-angle.

# Example

    let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
    let translation = Vector3::new(1.0, 2.0, 3.0);
    // Point and vector being transformed in the tests.
    let pt = Point3::new(4.0, 5.0, 6.0);
    let vec = Vector3::new(4.0, 5.0, 6.0);

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::new(translation, axisangle);
    assert_relative_eq!(iso * pt, Point3::new(7.0, 7.0, -1.0), epsilon = 1.0e-6);
    assert_relative_eq!(iso * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

    // Isometry with its rotation part represented as a Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::new(translation, axisangle);
    assert_relative_eq!(iso * pt, Point3::new(7.0, 7.0, -1.0), epsilon = 1.0e-6);
    assert_relative_eq!(iso * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

#### `pub fn translation(x: N, y: N, z: N) -> Self`[src]

Creates a new isometry from the given translation coordinates.

#### `pub fn rotation(axisangle: Vector3<N>) -> Self`[src]

Creates a new isometry from the given rotation angle.

#### `pub fn face_towards(
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self`[src]

Creates an isometry that corresponds to the local frame of an observer standing at the point `eye` and looking toward `target`.

It maps the `z` axis to the view direction `target - eye`and the origin to the `eye`.

# Arguments

- eye - The observer position.
- target - The target position.
- up - Vertical direction. The only requirement of this parameter is to not be collinear to `eye - at`. Non-collinearity is not checked.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::face_towards(&eye, &target, &up);
    assert_eq!(iso * Point3::origin(), eye);
    assert_relative_eq!(iso * Vector3::z(), Vector3::x());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::face_towards(&eye, &target, &up);
    assert_eq!(iso * Point3::origin(), eye);
    assert_relative_eq!(iso * Vector3::z(), Vector3::x());

#### `pub fn new_observer_frame(
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self`[src]

Deprecated:

renamed to `face_towards`

Deprecated: Use [Isometry::face_towards] instead.

#### `pub fn look_at_rh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self`[src]

Builds a right-handed look-at view matrix.

It maps the view direction `target - eye` to the negative `z` axis to and the `eye` to the origin. This conforms to the common notion of right handed camera look-at view matrix from the computer graphics community, i.e. the camera is assumed to look toward its local `-z` axis.

# Arguments

- eye - The eye position.
- target - The target position.
- up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to `target - eye`.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::look_at_rh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), -Vector3::z());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::look_at_rh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), -Vector3::z());

#### `pub fn look_at_lh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self`[src]

Builds a left-handed look-at view matrix.

It maps the view direction `target - eye` to the positive `z` axis and the `eye` to the origin. This conforms to the common notion of right handed camera look-at view matrix from the computer graphics community, i.e. the camera is assumed to look toward its local `z` axis.

# Arguments

- eye - The eye position.
- target - The target position.
- up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to `target - eye`.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::look_at_lh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), Vector3::z());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::look_at_lh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), Vector3::z());

### `impl<N: RealField> Isometry<N, U3, UnitQuaternion<N>>`[src]

#### `pub fn new(translation: Vector3<N>, axisangle: Vector3<N>) -> Self`[src]

Creates a new isometry from a translation and a rotation axis-angle.

# Example

    let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
    let translation = Vector3::new(1.0, 2.0, 3.0);
    // Point and vector being transformed in the tests.
    let pt = Point3::new(4.0, 5.0, 6.0);
    let vec = Vector3::new(4.0, 5.0, 6.0);

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::new(translation, axisangle);
    assert_relative_eq!(iso * pt, Point3::new(7.0, 7.0, -1.0), epsilon = 1.0e-6);
    assert_relative_eq!(iso * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

    // Isometry with its rotation part represented as a Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::new(translation, axisangle);
    assert_relative_eq!(iso * pt, Point3::new(7.0, 7.0, -1.0), epsilon = 1.0e-6);
    assert_relative_eq!(iso * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

#### `pub fn translation(x: N, y: N, z: N) -> Self`[src]

Creates a new isometry from the given translation coordinates.

#### `pub fn rotation(axisangle: Vector3<N>) -> Self`[src]

Creates a new isometry from the given rotation angle.

#### `pub fn face_towards(
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self`[src]

Creates an isometry that corresponds to the local frame of an observer standing at the point `eye` and looking toward `target`.

It maps the `z` axis to the view direction `target - eye`and the origin to the `eye`.

# Arguments

- eye - The observer position.
- target - The target position.
- up - Vertical direction. The only requirement of this parameter is to not be collinear to `eye - at`. Non-collinearity is not checked.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::face_towards(&eye, &target, &up);
    assert_eq!(iso * Point3::origin(), eye);
    assert_relative_eq!(iso * Vector3::z(), Vector3::x());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::face_towards(&eye, &target, &up);
    assert_eq!(iso * Point3::origin(), eye);
    assert_relative_eq!(iso * Vector3::z(), Vector3::x());

#### `pub fn new_observer_frame(
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self`[src]

Deprecated:

renamed to `face_towards`

Deprecated: Use [Isometry::face_towards] instead.

#### `pub fn look_at_rh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self`[src]

Builds a right-handed look-at view matrix.

It maps the view direction `target - eye` to the negative `z` axis to and the `eye` to the origin. This conforms to the common notion of right handed camera look-at view matrix from the computer graphics community, i.e. the camera is assumed to look toward its local `-z` axis.

# Arguments

- eye - The eye position.
- target - The target position.
- up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to `target - eye`.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::look_at_rh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), -Vector3::z());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::look_at_rh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), -Vector3::z());

#### `pub fn look_at_lh(eye: &Point3<N>, target: &Point3<N>, up: &Vector3<N>) -> Self`[src]

Builds a left-handed look-at view matrix.

It maps the view direction `target - eye` to the positive `z` axis and the `eye` to the origin. This conforms to the common notion of right handed camera look-at view matrix from the computer graphics community, i.e. the camera is assumed to look toward its local `z` axis.

# Arguments

- eye - The eye position.
- target - The target position.
- up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to `target - eye`.

# Example

    let eye = Point3::new(1.0, 2.0, 3.0);
    let target = Point3::new(2.0, 2.0, 3.0);
    let up = Vector3::y();

    // Isometry with its rotation part represented as a UnitQuaternion
    let iso = Isometry3::look_at_lh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), Vector3::z());

    // Isometry with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
    let iso = IsometryMatrix3::look_at_lh(&eye, &target, &up);
    assert_eq!(iso * eye, Point3::origin());
    assert_relative_eq!(iso * Vector3::x(), Vector3::z());

## Trait Implementations

### `impl<N: RealField, D: DimName, R> Eq for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + Eq,
DefaultAllocator: Allocator<N, D>,` [src]

### `impl<N: RealField, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn clone(&self) -> Self`[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<N: RealField, D: DimName, R> PartialEq<Isometry<N, D, R>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + PartialEq,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn eq(&self, right: &Self) -> bool`[src]

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

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

This method tests for `!=`.

### `impl<N: RealField, D: DimName, R> From<Isometry<N, D, R>> for MatrixN<N, DimNameSum<D, U1>> where
D: DimNameAdd<U1>,
R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D>,` [src]

#### `fn from(iso: Isometry<N, D, R>) -> Self`[src]

Performs the conversion.

### `impl<N: RealField, D: DimName + Copy, R: Rotation<Point<N, D>> + Copy> Copy for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
Owned<N, D>: Copy,` [src]

### `impl<N: RealField + Hash, D: DimName + Hash, R: Hash> Hash for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
Owned<N, D>: Hash,` [src]

#### `fn hash<H: Hasher>(&self, state: &mut H)`[src]

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl<N: RealField> Mul<Isometry<N, U2, Unit<Complex<N>>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,` [src]

#### `type Output = Isometry<N, U2, UnitComplex<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, U2, UnitComplex<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField> Mul<Isometry<N, U2, Unit<Complex<N>>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,` [src]

#### `type Output = Isometry<N, U2, UnitComplex<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, U2, UnitComplex<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField> Mul<&'b Isometry<N, U2, Unit<Complex<N>>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,` [src]

#### `type Output = Isometry<N, U2, UnitComplex<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, U2, UnitComplex<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField> Mul<&'b Isometry<N, U2, Unit<Complex<N>>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,` [src]

#### `type Output = Isometry<N, U2, UnitComplex<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, U2, UnitComplex<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: R) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: R) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b R) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b R) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Point<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Point<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Point<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Point<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Point<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Point<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Point<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Point<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = VectorN<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: VectorN<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = VectorN<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: VectorN<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = VectorN<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b VectorN<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = VectorN<N, D>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b VectorN<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Unit<VectorN<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Unit<VectorN<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Unit<VectorN<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Unit<VectorN<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Unit<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Unit<VectorN<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Unit<VectorN<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Translation<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Translation<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Translation<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Translation<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Translation<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Translation<N, D>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for &'a Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for &'a Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName> Mul<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName> Mul<Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName> Mul<&'b Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName> Mul<&'b Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `*` operator.

#### `fn mul(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Isometry<N, D, R>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Mul<Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Similarity<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N: RealField, D: DimName, R> Mul<Similarity<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Similarity<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N: RealField, D: DimName, R> Mul<&'b Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Similarity<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Mul<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Similarity<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<Isometry<N, D, R>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<Isometry<N, D, R>> for &'a Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<&'b Isometry<N, D, R>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<&'b Isometry<N, D, R>> for &'a Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<Transform<N, D, C>> for Isometry<N, D, R> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Transform<N, D, C>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<Transform<N, D, C>> for &'a Isometry<N, D, R> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: Transform<N, D, C>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<&'b Transform<N, D, C>> for Isometry<N, D, R> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Transform<N, D, C>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> Mul<&'b Transform<N, D, C>> for &'a Isometry<N, D, R> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,` [src]

#### `type Output = Transform<N, D, C::Representative>`

The resulting type after applying the `*` operator.

#### `fn mul(self, rhs: &'b Transform<N, D, C>) -> Self::Output`[src]

Performs the `*` operation.

### `impl<N: RealField, D: DimName, R> Div<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField, D: DimName, R> Div<Isometry<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField, D: DimName, R> Div<&'b Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Div<&'b Isometry<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField, D: DimName, R> Div<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: R) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField, D: DimName, R> Div<R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: R) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField, D: DimName, R> Div<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b R) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Div<&'b R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Isometry<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b R) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField, D: DimName> Div<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField, D: DimName> Div<Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField, D: DimName> Div<&'b Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: &'b Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField, D: DimName> Div<&'b Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,` [src]

#### `type Output = Isometry<N, D, Rotation<N, D>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: &'b Isometry<N, D, Rotation<N, D>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,` [src]

#### `type Output = Isometry<N, U3, UnitQuaternion<N>>`

The resulting type after applying the `/` operator.

#### `fn div(self, right: &'b Isometry<N, U3, UnitQuaternion<N>>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField, D: DimName, R> Div<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField, D: DimName, R> Div<Isometry<N, D, R>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField, D: DimName, R> Div<&'b Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Div<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Isometry<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField, D: DimName, R> Div<Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Similarity<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, N: RealField, D: DimName, R> Div<Similarity<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: Similarity<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'b, N: RealField, D: DimName, R> Div<&'b Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Similarity<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<'a, 'b, N: RealField, D: DimName, R> Div<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Output = Similarity<N, D, R>`

The resulting type after applying the `/` operator.

#### `fn div(self, rhs: &'b Similarity<N, D, R>) -> Self::Output`[src]

Performs the `/` operation.

### `impl<N: RealField, D: DimName, R> MulAssign<Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: Translation<N, D>)`[src]

Performs the `*=` operation.

### `impl<'b, N: RealField, D: DimName, R> MulAssign<&'b Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: &'b Translation<N, D>)`[src]

Performs the `*=` operation.

### `impl<N: RealField, D: DimName, R> MulAssign<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<'b, N: RealField, D: DimName, R> MulAssign<&'b Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<N: RealField, D: DimName, R> MulAssign<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: R)`[src]

Performs the `*=` operation.

### `impl<'b, N: RealField, D: DimName, R> MulAssign<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: &'b R)`[src]

Performs the `*=` operation.

### `impl<N: RealField, D: DimName, R> MulAssign<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<'b, N: RealField, D: DimName, R> MulAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<Isometry<N, D, R>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,` [src]

#### `fn mul_assign(&mut self, rhs: Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<'b, N, D: DimNameAdd<U1>, C: TCategory, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<&'b Isometry<N, D, R>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,` [src]

#### `fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)`[src]

Performs the `*=` operation.

### `impl<N: RealField, D: DimName, R> DivAssign<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: Isometry<N, D, R>)`[src]

Performs the `/=` operation.

### `impl<'b, N: RealField, D: DimName, R> DivAssign<&'b Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)`[src]

Performs the `/=` operation.

### `impl<N: RealField, D: DimName, R> DivAssign<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: R)`[src]

Performs the `/=` operation.

### `impl<'b, N: RealField, D: DimName, R> DivAssign<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: &'b R)`[src]

Performs the `/=` operation.

### `impl<N: RealField, D: DimName, R> DivAssign<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: Isometry<N, D, R>)`[src]

Performs the `/=` operation.

### `impl<'b, N: RealField, D: DimName, R> DivAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)`[src]

Performs the `/=` operation.

### `impl<N: Debug + RealField, D: Debug + DimName, R: Debug> Debug for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

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

Formats the value using the given formatter. Read more

### `impl<N: RealField + Display, D: DimName, R> Display for Isometry<N, D, R> where
R: Display,
DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,` [src]

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

Formats the value using the given formatter. Read more

### `impl<N: RealField, D: DimName, R> AbsDiffEq<Isometry<N, D, R>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + AbsDiffEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,` [src]

#### `type Epsilon = N::Epsilon`

Used for specifying relative comparisons.

#### `fn default_epsilon() -> Self::Epsilon`[src]

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

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

A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more

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

The inverse of `ApproxEq::abs_diff_eq`.

### `impl<N: RealField, D: DimName, R> RelativeEq<Isometry<N, D, R>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + RelativeEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,` [src]

#### `fn default_max_relative() -> Self::Epsilon`[src]

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

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

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

The inverse of `ApproxEq::relative_eq`.

### `impl<N: RealField, D: DimName, R> UlpsEq<Isometry<N, D, R>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + UlpsEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,` [src]

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

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

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

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

The inverse of `ApproxEq::ulps_eq`.

### `impl<N: RealField, D: DimName, R: AlgaRotation<Point<N, D>>> One for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn one() -> Self`[src]

Creates a new identity isometry.

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

Sets `self` to the multiplicative identity element of `Self`, `1`.

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

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

### `impl<N: RealField, D: DimName, R> Distribution<Isometry<N, D, R>> for Standard where
R: AlgaRotation<Point<N, D>>,
Standard: Distribution<N> + Distribution<R>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Isometry<N, D, R>`[src]

Generate a random value of `T`, using `rng` as the source of randomness.

#### `fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
R: Rng,` [src]

Create an iterator that generates random values of `T`, using `rng` as the source of randomness. Read more

### `impl<N: RealField, D: DimName, R> AbstractMagma<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn operate(&self, rhs: &Self) -> Self`[src]

Performs an operation.

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

Performs specific operation.

### `impl<N: RealField, D: DimName, R> AbstractQuasigroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
Self: RelativeEq<Self>,` [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. Read more

### `impl<N: RealField, D: DimName, R> AbstractSemigroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
Self: RelativeEq<Self>,` [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<N: RealField, D: DimName, R> AbstractLoop<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

### `impl<N: RealField, D: DimName, R> AbstractMonoid<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where
Self: RelativeEq<Self>,` [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<N: RealField, D: DimName, R> AbstractGroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

### `impl<N: RealField, D: DimName, R> Identity<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn identity() -> Self`[src]

The identity element.

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

Specific identity.

### `impl<N: RealField, D: DimName, R> TwoSidedInverse<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn two_sided_inverse(&self) -> Self`[src]

Returns the two_sided_inverse of `self`, relative to the operator `O`. Read more

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

In-place inversion of `self`, relative to the operator `O`. Read more

### `impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Rotation<N1, D> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R: AlgaRotation<Point<N2, D>> + SupersetOf<Self>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> Isometry<N2, D, R>`[src]

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

#### `fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self`[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<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R: AlgaRotation<Point3<N2>> + SupersetOf<Self>,` [src]

#### `fn to_superset(&self) -> Isometry<N2, U3, R>`[src]

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

#### `fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self`[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<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for UnitComplex<N1> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R: AlgaRotation<Point2<N2>> + SupersetOf<Self>,` [src]

#### `fn to_superset(&self) -> Isometry<N2, U2, R>`[src]

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

#### `fn is_in_subset(iso: &Isometry<N2, U2, R>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Self`[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<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Translation<N1, D> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> Isometry<N2, D, R>`[src]

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

#### `fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self`[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<N1, N2, D: DimName, R1, R2> SubsetOf<Isometry<N2, D, R2>> for Isometry<N1, D, R1> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> Isometry<N2, D, R2>`[src]

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

#### `fn is_in_subset(iso: &Isometry<N2, D, R2>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R2>) -> Self`[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<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> Similarity<N2, D, R2>`[src]

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

#### `fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R2>) -> Self`[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<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Isometry<N1, D, R> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
C: SuperTCategoryOf<TAffine>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> Transform<N2, D, C>`[src]

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

#### `fn is_in_subset(t: &Transform<N2, D, C>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self`[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<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Isometry<N1, D, R> where
N1: RealField,
N2: RealField + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,` [src]

#### `fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>`[src]

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

#### `fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool`[src]

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

#### `unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self`[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<N: RealField, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

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

#### `fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>`[src]

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

### `impl<N: RealField, D: DimName, R> Transformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>`[src]

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

#### `fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>`[src]

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

### `impl<N: RealField, D: DimName, R> DirectIsometry<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

### `impl<N: RealField, D: DimName, R> Similarity<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Scaling = Id`

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

#### `fn translation(&self) -> Translation<N, D>`[src]

The pure translational component of this similarity transformation.

#### `fn rotation(&self) -> R`[src]

The pure rotational component of this similarity transformation.

#### `fn scaling(&self) -> Id`[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<N: RealField, D: DimName, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

#### `type Rotation = R`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Translation<N, D>`

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

#### `fn decompose(&self) -> (Self::Translation, R, Id, R)`[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, t: &Self::Translation) -> Self`[src]

Appends a translation to this similarity.

#### `fn prepend_translation(&self, t: &Self::Translation) -> Self`[src]

Prepends a translation to this similarity.

#### `fn append_rotation(&self, r: &Self::Rotation) -> Self`[src]

Appends a rotation to this similarity.

#### `fn prepend_rotation(&self, r: &Self::Rotation) -> Self`[src]

Prepends a rotation to this similarity.

#### `fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self`[src]

Appends a scaling factor to this similarity.

#### `fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self`[src]

Prepends a scaling factor to this similarity.

#### `fn append_rotation_wrt_point(
&self,
r: &Self::Rotation,
p: &Point<N, D>
) -> Option<Self>`[src]

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

### `impl<N: RealField, D: DimName, R> Isometry<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,` [src]

## Auto Trait Implementations

### `impl<N, D, R> !Send for Isometry<N, D, R>`

### `impl<N, D, R> !Unpin for Isometry<N, D, R>`

### `impl<N, D, R> !Sync for Isometry<N, D, R>`

### `impl<N, D, R> !UnwindSafe for Isometry<N, D, R>`

### `impl<N, D, R> !RefUnwindSafe for Isometry<N, D, R>`

## Blanket Implementations

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

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

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

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

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `default fn to_string(&self) -> String`[src]

Converts the given value to a `String`. Read more

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

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

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

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

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

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

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

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

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

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

#### `type Output = T`

Should always be `Self`

### `impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,` [src]

#### `fn to_subset(&self) -> Option<SS>`[src]

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

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

Checks if `self` is actually part of its subset `T` (and can be converted to it).

#### `unsafe fn to_subset_unchecked(&self) -> SS`[src]

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

#### `fn from_subset(element: &SS) -> SP`[src]

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

### `impl<T, Right> ClosedMul<Right> for T where
T: Mul<Right, Output = T> + MulAssign<Right>,` [src]

### `impl<T, Right> ClosedDiv<Right> for T where
T: Div<Right, Output = T> + DivAssign<Right>,` [src]

### `impl<T> MultiplicativeMagma for T where
T: AbstractMagma<Multiplicative>,` [src]

### `impl<T> MultiplicativeQuasigroup for T where
T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma,` [src]

### `impl<T> MultiplicativeLoop for T where
T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One,` [src]

### `impl<T> MultiplicativeSemigroup for T where
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,` [src]

### `impl<T> MultiplicativeMonoid for T where
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,` [src]

### `impl<T> MultiplicativeGroup for T where
T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid,` [src]

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

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

Applies this group's two_sided_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 two_sided_inverse action on a vector from the euclidean space. Read more

### `impl<R, E> Transformation<E> for R where
E: EuclideanSpace<RealField = R>,
R: RealField,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,` [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

### `impl<R, E> Similarity<E> for R where
E: EuclideanSpace<RealField = R>,
R: RealField + 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 translation(&self) -> <R as AffineTransformation<E>>::Translation`[src]

The pure translational component of this similarity transformation.

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

The pure rotational component of this similarity transformation.

#### `fn scaling(&self) -> <R 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<R, E> AffineTransformation<E> for R where
E: EuclideanSpace<RealField = R>,
R: RealField,
<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 decompose(
&self
) -> (Id<Multiplicative>, Id<Multiplicative>, R, 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, &<R as AffineTransformation<E>>::Translation) -> R`[src]

Appends a translation to this similarity.

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

Prepends a translation to this similarity.

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

Appends a rotation to this similarity.

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

Prepends a rotation to this similarity.

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

Appends a scaling factor to this similarity.

#### `fn prepend_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R`[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

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)