[−][src]Struct nalgebra::geometry::Isometry
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: Real, D: DimName, R: Rotation<Point<N, D>>> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
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));
impl<N: Real, D: DimName, R> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
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]
D: DimNameAdd<U1>,
R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
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: Real, D: DimName, R: AlgaRotation<Point<N, D>>> Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
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: Real> 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: Real> 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: Real> 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]
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self
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]
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self
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: Real> 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]
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self
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]
eye: &Point3<N>,
target: &Point3<N>,
up: &Vector3<N>
) -> Self
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: Real, 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]
D: DimNameAdd<U1>,
R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D>,
impl<N: Real, D: DimName, R> Eq for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + Eq,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>> + Eq,
DefaultAllocator: Allocator<N, D>,
impl<N: Real, 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]
DefaultAllocator: Allocator<N, D>,
Owned<N, D>: Copy,
impl<N: Real, D: DimName, R: Rotation<Point<N, D>> + Clone> Clone for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<N: Real, 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]
R: Rotation<Point<N, D>> + PartialEq,
DefaultAllocator: Allocator<N, D>,
fn eq(&self, right: &Self) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<N: Real + Hash, D: DimName + Hash, R: Hash> Hash for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
Owned<N, D>: Hash,
[src]
DefaultAllocator: Allocator<N, D>,
Owned<N, D>: Hash,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<N: Real> Mul<Isometry<N, U2, Unit<Complex<N>>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
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]
impl<'a, N: Real> Mul<Isometry<N, U2, Unit<Complex<N>>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
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]
impl<'b, N: Real> Mul<&'b Isometry<N, U2, Unit<Complex<N>>>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
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]
impl<'a, 'b, N: Real> Mul<&'b Isometry<N, U2, Unit<Complex<N>>>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
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]
impl<N: Real, D: DimName, R> Mul<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> Mul<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: R) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: R) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b R) -> Self::Output
[src]
impl<'a, 'b, N: Real, D: DimName, R> Mul<&'b R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b R) -> Self::Output
[src]
impl<N: Real, D: DimName, R> Mul<Point<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Point<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: Point<N, D>) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<Point<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Point<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: Point<N, D>) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b Point<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Point<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Point<N, D>) -> Self::Output
[src]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Point<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Point<N, D>) -> Self::Output
[src]
impl<N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Unit<VectorN<N, D>>
The resulting type after applying the *
operator.
fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Unit<VectorN<N, D>>
The resulting type after applying the *
operator.
fn mul(self, right: Unit<VectorN<N, D>>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> Mul<Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: Translation<N, D>) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<Translation<N, D>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: Translation<N, D>) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Translation<N, D>) -> Self::Output
[src]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Translation<N, D>) -> Self::Output
[src]
impl<N: Real, D: DimName, R> Mul<Isometry<N, D, R>> for Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: Isometry<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<Isometry<N, D, R>> for &'a Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, right: Isometry<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b Isometry<N, D, R>> for Translation<N, D> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName> Mul<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
[src]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'a, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'b, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'a, 'b, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'a, N: Real> Mul<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'b, N: Real> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'a, 'b, N: Real> Mul<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<N: Real, D: DimName, R> Mul<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> Mul<Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Similarity<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the *
operator.
fn mul(self, rhs: Similarity<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
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]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
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]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
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]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
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]
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 + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
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]
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 + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
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]
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 + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
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]
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 + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, DimNameSum<D, U1>>,
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]
impl<N: Real, D: DimName, R> Div<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> Div<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: R) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Div<R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: R) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Div<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b R) -> Self::Output
[src]
impl<'a, 'b, N: Real, D: DimName, R> Div<&'b R> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Isometry<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b R) -> Self::Output
[src]
impl<N: Real, D: DimName> Div<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
[src]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'a, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'b, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<'a, 'b, N: Real, 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]
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
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]
impl<N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'a, N: Real> Div<Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'b, N: Real> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<'a, 'b, N: Real> Div<&'b Isometry<N, U3, Unit<Quaternion<N>>>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
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]
impl<N: Real, D: DimName, R> Div<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Isometry<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> Div<Similarity<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Similarity<N, D, R>) -> Self::Output
[src]
impl<'a, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = Similarity<N, D, R>
The resulting type after applying the /
operator.
fn div(self, rhs: Similarity<N, D, R>) -> Self::Output
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<'a, 'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
impl<N: Real, D: DimName, R> MulAssign<Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: Translation<N, D>)
[src]
impl<'b, N: Real, D: DimName, R> MulAssign<&'b Translation<N, D>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: &'b Translation<N, D>)
[src]
impl<N: Real, D: DimName, R> MulAssign<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: Isometry<N, D, R>)
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)
[src]
impl<N: Real, D: DimName, R> MulAssign<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: R)
[src]
impl<'b, N: Real, D: DimName, R> MulAssign<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: &'b R)
[src]
impl<N: Real, D: DimName, R> MulAssign<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: Isometry<N, D, R>)
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)
[src]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,
fn mul_assign(&mut self, rhs: Isometry<N, D, R>)
[src]
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 + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>,
fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)
[src]
impl<N: Real, D: DimName, R> DivAssign<Isometry<N, D, R>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: Isometry<N, D, R>)
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)
[src]
impl<N: Real, D: DimName, R> DivAssign<R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: R)
[src]
impl<'b, N: Real, D: DimName, R> DivAssign<&'b R> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: &'b R)
[src]
impl<N: Real, D: DimName, R> DivAssign<Isometry<N, D, R>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: Isometry<N, D, R>)
[src]
impl<'b, N: Real, 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]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)
[src]
impl<N: Debug + Real, D: Debug + DimName, R: Debug> Debug for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
impl<N: Real + Display, D: DimName, R> Display for Isometry<N, D, R> where
R: Display,
DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
[src]
R: Display,
DefaultAllocator: Allocator<N, D> + Allocator<usize, D>,
impl<N: Real, D: DimName, R> AbsDiffEq for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + AbsDiffEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
[src]
R: Rotation<Point<N, D>> + AbsDiffEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
type Epsilon = N::Epsilon
Used for specifying relative comparisons.
fn default_epsilon() -> Self::Epsilon
[src]
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
The inverse of ApproxEq::abs_diff_eq
.
impl<N: Real, D: DimName, R> RelativeEq for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + RelativeEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
[src]
R: Rotation<Point<N, D>> + RelativeEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
fn default_max_relative() -> Self::Epsilon
[src]
fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of ApproxEq::relative_eq
.
impl<N: Real, D: DimName, R> UlpsEq for Isometry<N, D, R> where
R: Rotation<Point<N, D>> + UlpsEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
[src]
R: Rotation<Point<N, D>> + UlpsEq<Epsilon = N::Epsilon>,
DefaultAllocator: Allocator<N, D>,
N::Epsilon: Copy,
fn default_max_ulps() -> u32
[src]
fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
The inverse of ApproxEq::ulps_eq
.
impl<N: Real, D: DimName, R: AlgaRotation<Point<N, D>>> One for Isometry<N, D, R> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
fn one() -> Self
[src]
Creates a new identity isometry.
fn is_one(&self) -> bool where
Self: PartialEq<Self>,
[src]
Self: PartialEq<Self>,
Returns true
if self
is equal to the multiplicative identity. Read more
impl<N: Real, 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]
R: AlgaRotation<Point<N, D>>,
Standard: Distribution<N> + Distribution<R>,
DefaultAllocator: Allocator<N, D>,
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Isometry<N, D, R>
[src]
fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
R: Rng,
[src]
R: Rng,
Create an iterator that generates random values of T
, using rng
as the source of randomness. Read more
impl<N: Real, D: DimName, R> AbstractMagma<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn operate(&self, rhs: &Self) -> Self
[src]
fn op(&self, O, lhs: &Self) -> Self
[src]
Performs specific operation.
impl<N: Real, D: DimName, R> AbstractQuasigroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
Self: RelativeEq,
[src]
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,
[src]
Self: Eq,
Returns true
if latin squareness holds for the given arguments. Read more
impl<N: Real, D: DimName, R> AbstractSemigroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
Self: RelativeEq,
[src]
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,
[src]
Self: Eq,
Returns true
if associativity holds for the given arguments.
impl<N: Real, D: DimName, R> AbstractLoop<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
impl<N: Real, D: DimName, R> AbstractMonoid<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where
Self: RelativeEq,
[src]
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,
[src]
Self: Eq,
Checks whether operating with the identity element is a no-op for the given argument. Read more
impl<N: Real, D: DimName, R> AbstractGroup<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
impl<N: Real, D: DimName, R> Identity<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
impl<N: Real, D: DimName, R> TwoSidedInverse<Multiplicative> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn two_sided_inverse(&self) -> Self
[src]
fn two_sided_inverse_mut(&mut self)
[src]
impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Rotation<N1, D> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point<N2, D>> + SupersetOf<Self>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point<N2, D>> + SupersetOf<Self>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D>,
fn to_superset(&self) -> Isometry<N2, D, R>
[src]
fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for UnitQuaternion<N1> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point3<N2>> + SupersetOf<Self>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point3<N2>> + SupersetOf<Self>,
fn to_superset(&self) -> Isometry<N2, U3, R>
[src]
fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, U3, R>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for UnitComplex<N1> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point2<N2>> + SupersetOf<Self>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: AlgaRotation<Point2<N2>> + SupersetOf<Self>,
fn to_superset(&self) -> Isometry<N2, U2, R>
[src]
fn is_in_subset(iso: &Isometry<N2, U2, R>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D: DimName, R> SubsetOf<Isometry<N2, D, R>> for Translation<N1, D> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
fn to_superset(&self) -> Isometry<N2, D, R>
[src]
fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D: DimName, R1, R2> SubsetOf<Isometry<N2, D, R2>> for Isometry<N1, D, R1> where
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
fn to_superset(&self) -> Isometry<N2, D, R2>
[src]
fn is_in_subset(iso: &Isometry<N2, D, R2>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D: DimName, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1> where
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D>,
fn to_superset(&self) -> Similarity<N2, D, R2>
[src]
fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool
[src]
unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Isometry<N1, D, R> where
N1: Real,
N2: Real + 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<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + 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<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
fn to_superset(&self) -> Transform<N2, D, C>
[src]
fn is_in_subset(t: &Transform<N2, D, C>) -> bool
[src]
unsafe fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<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: Real,
N2: Real + 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<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + 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<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N: Real, D: DimName, R> Transformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
[src]
fn transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
[src]
impl<N: Real, D: DimName, R> ProjectiveTransformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
[src]
fn inverse_transform_vector(&self, v: &VectorN<N, D>) -> VectorN<N, D>
[src]
impl<N: Real, D: DimName, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
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]
fn append_translation(&self, t: &Self::Translation) -> Self
[src]
fn prepend_translation(&self, t: &Self::Translation) -> Self
[src]
fn append_rotation(&self, r: &Self::Rotation) -> Self
[src]
fn prepend_rotation(&self, r: &Self::Rotation) -> Self
[src]
fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self
[src]
fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self
[src]
fn append_rotation_wrt_point(
&self,
r: &Self::Rotation,
p: &Point<N, D>
) -> Option<Self>
[src]
&self,
r: &Self::Rotation,
p: &Point<N, D>
) -> Option<Self>
impl<N: Real, D: DimName, R> Similarity<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Scaling = Id
The type of the pure (uniform) scaling part of this similarity transformation.
fn translation(&self) -> Translation<N, D>
[src]
fn rotation(&self) -> R
[src]
fn scaling(&self) -> Id
[src]
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]
&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
[src]
&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
[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]
&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
[src]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation inverse's pure scaling part to a vector.
impl<N: Real, D: DimName, R> Isometry<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
impl<N: Real, D: DimName, R> DirectIsometry<Point<N, D>> for Isometry<N, D, R> where
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
Auto Trait Implementations
Blanket Implementations
impl<T> From for T
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Same for T
[src]
type Output = T
Should always be Self
impl<T, Right> ClosedMul for T where
T: Mul<Right, Output = T> + MulAssign<Right>,
[src]
T: Mul<Right, Output = T> + MulAssign<Right>,
impl<T, Right> ClosedDiv for T where
T: Div<Right, Output = T> + DivAssign<Right>,
[src]
T: Div<Right, Output = T> + DivAssign<Right>,
impl<SS, SP> SupersetOf for SP where
SS: SubsetOf<SP>,
[src]
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
[src]
fn is_in_subset(&self) -> bool
[src]
unsafe fn to_subset_unchecked(&self) -> SS
[src]
fn from_subset(element: &SS) -> SP
[src]
impl<T> MultiplicativeMagma for T where
T: AbstractMagma<Multiplicative>,
[src]
T: AbstractMagma<Multiplicative>,
impl<T> MultiplicativeQuasigroup for T where
T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma,
[src]
T: AbstractQuasigroup<Multiplicative> + ClosedDiv<T> + MultiplicativeMagma,
impl<T> MultiplicativeLoop for T where
T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One,
[src]
T: AbstractLoop<Multiplicative> + MultiplicativeQuasigroup + One,
impl<T> MultiplicativeSemigroup for T where
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
[src]
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
impl<T> MultiplicativeMonoid for T where
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
[src]
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
impl<T> MultiplicativeGroup for T where
T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid,
[src]
T: AbstractGroup<Multiplicative> + MultiplicativeLoop + MultiplicativeMonoid,
impl<R, E> Transformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
fn transform_point(&self, pt: &E) -> E
[src]
fn transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
impl<R, E> ProjectiveTransformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
fn inverse_transform_point(&self, pt: &E) -> E
[src]
fn inverse_transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
impl<R, E> AffineTransformation for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
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 decompose(
&self
) -> (Id<Multiplicative>, Id<Multiplicative>, R, Id<Multiplicative>)
[src]
&self
) -> (Id<Multiplicative>, Id<Multiplicative>, R, Id<Multiplicative>)
fn append_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R
[src]
fn prepend_translation(&self, &<R as AffineTransformation<E>>::Translation) -> R
[src]
fn append_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R
[src]
fn prepend_rotation(&self, &<R as AffineTransformation<E>>::Rotation) -> R
[src]
fn append_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
[src]
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
fn prepend_scaling(
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
[src]
&self,
s: &<R as AffineTransformation<E>>::NonUniformScaling
) -> R
fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>
[src]
Appends to this similarity a rotation centered at the point p
, i.e., this point is left invariant. Read more
impl<R, E> Similarity for R where
E: EuclideanSpace<Real = R>,
R: Real + SubsetOf<R>,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
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 translation(&self) -> <R as AffineTransformation<E>>::Translation
[src]
fn rotation(&self) -> <R as AffineTransformation<E>>::Rotation
[src]
fn scaling(&self) -> <R as Similarity<E>>::Scaling
[src]
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]
&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
[src]
&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
[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]
&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
[src]
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation inverse's pure scaling part to a vector.