Struct na::Similarity
source · pub struct Similarity<N, D, R>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,{
pub isometry: Isometry<N, D, R>,
/* private fields */
}
Expand description
A similarity, i.e., an uniform scaling, followed by a rotation, followed by a translation.
Fields§
§isometry: Isometry<N, D, R>
The part of this similarity that does not include the scaling factor.
Implementations§
source§impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
sourcepub fn from_parts(
translation: Translation<N, D>,
rotation: R,
scaling: N
) -> Similarity<N, D, R>
pub fn from_parts(
translation: Translation<N, D>,
rotation: R,
scaling: N
) -> Similarity<N, D, R>
Creates a new similarity from its rotational and translational parts.
sourcepub fn from_isometry(
isometry: Isometry<N, D, R>,
scaling: N
) -> Similarity<N, D, R>
pub fn from_isometry(
isometry: Isometry<N, D, R>,
scaling: N
) -> Similarity<N, D, R>
Creates a new similarity from its rotational and translational parts.
sourcepub fn from_scaling(scaling: N) -> Similarity<N, D, R>
pub fn from_scaling(scaling: N) -> Similarity<N, D, R>
Creates a new similarity that applies only a scaling factor.
sourcepub fn inverse(&self) -> Similarity<N, D, R>
pub fn inverse(&self) -> Similarity<N, D, R>
Inverts self
.
sourcepub fn inverse_mut(&mut self)
pub fn inverse_mut(&mut self)
Inverts self
in-place.
sourcepub fn set_scaling(&mut self, scaling: N)
pub fn set_scaling(&mut self, scaling: N)
The scaling factor of this similarity transformation.
sourcepub fn prepend_scaling(&self, scaling: N) -> Similarity<N, D, R>
pub fn prepend_scaling(&self, scaling: N) -> Similarity<N, D, R>
The similarity transformation that applies a scaling factor scaling
before self
.
sourcepub fn append_scaling(&self, scaling: N) -> Similarity<N, D, R>
pub fn append_scaling(&self, scaling: N) -> Similarity<N, D, R>
The similarity transformation that applies a scaling factor scaling
after self
.
sourcepub fn prepend_scaling_mut(&mut self, scaling: N)
pub fn prepend_scaling_mut(&mut self, scaling: N)
Sets self
to the similarity transformation that applies a scaling factor scaling
before self
.
sourcepub fn append_scaling_mut(&mut self, scaling: N)
pub fn append_scaling_mut(&mut self, scaling: N)
Sets self
to the similarity transformation that applies a scaling factor scaling
after self
.
sourcepub fn append_translation_mut(&mut self, t: &Translation<N, D>)
pub fn append_translation_mut(&mut self, t: &Translation<N, D>)
Appends to self
the given translation in-place.
sourcepub fn append_rotation_mut(&mut self, r: &R)
pub fn append_rotation_mut(&mut self, r: &R)
Appends to self
the given rotation in-place.
sourcepub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<N, D>)
pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &Point<N, D>)
Appends in-place to self
a rotation centered at the point p
, i.e., the rotation that
lets p
invariant.
sourcepub fn append_rotation_wrt_center_mut(&mut self, r: &R)
pub fn append_rotation_wrt_center_mut(&mut self, r: &R)
Appends in-place to self
a rotation centered at the point with coordinates
self.translation
.
source§impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
sourcepub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
D: DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
pub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
D: DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
Converts this similarity into its equivalent homogeneous transformation matrix.
source§impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
sourcepub fn identity() -> Similarity<N, D, R>
pub fn identity() -> Similarity<N, D, R>
Creates a new identity similarity.
Example
let sim = Similarity2::identity();
let pt = Point2::new(1.0, 2.0);
assert_eq!(sim * pt, pt);
let sim = Similarity3::identity();
let pt = Point3::new(1.0, 2.0, 3.0);
assert_eq!(sim * pt, pt);
source§impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
sourcepub fn rotation_wrt_point(r: R, p: Point<N, D>, scaling: N) -> Similarity<N, D, R>
pub fn rotation_wrt_point(r: R, p: Point<N, D>, scaling: N) -> Similarity<N, D, R>
The similarity that applies the scaling factor scaling
, followed by the rotation r
with
its axis passing through the point p
.
Example
let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
let pt = Point2::new(3.0, 2.0);
let sim = Similarity2::rotation_wrt_point(rot, pt, 4.0);
assert_relative_eq!(sim * Point2::new(1.0, 2.0), Point2::new(-3.0, 3.0), epsilon = 1.0e-6);
source§impl<N> Similarity<N, U2, Rotation<N, U2>>where
N: Real,
impl<N> Similarity<N, U2, Rotation<N, U2>>where
N: Real,
sourcepub fn new(
translation: Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
angle: N,
scaling: N
) -> Similarity<N, U2, Rotation<N, U2>>
pub fn new(
translation: Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
angle: N,
scaling: N
) -> Similarity<N, U2, Rotation<N, U2>>
Creates a new similarity from a translation, a rotation, and an uniform scaling factor.
Example
let sim = SimilarityMatrix2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
assert_relative_eq!(sim * Point2::new(2.0, 4.0), Point2::new(-11.0, 8.0), epsilon = 1.0e-6);
source§impl<N> Similarity<N, U2, Unit<Complex<N>>>where
N: Real,
impl<N> Similarity<N, U2, Unit<Complex<N>>>where
N: Real,
sourcepub fn new(
translation: Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
angle: N,
scaling: N
) -> Similarity<N, U2, Unit<Complex<N>>>
pub fn new(
translation: Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
angle: N,
scaling: N
) -> Similarity<N, U2, Unit<Complex<N>>>
Creates a new similarity from a translation and a rotation angle.
Example
let sim = Similarity2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
assert_relative_eq!(sim * Point2::new(2.0, 4.0), Point2::new(-11.0, 8.0), epsilon = 1.0e-6);
source§impl<N> Similarity<N, U3, Rotation<N, U3>>where
N: Real,
impl<N> Similarity<N, U3, Rotation<N, U3>>where
N: Real,
sourcepub fn new(
translation: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
pub fn new(
translation: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
Creates a new similarity from a translation, rotation axis-angle, and scaling factor.
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);
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::new(translation, axisangle, 3.0);
assert_relative_eq!(sim * pt, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
assert_relative_eq!(sim * vec, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
// Similarity with its rotation part represented as a Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::new(translation, axisangle, 3.0);
assert_relative_eq!(sim * pt, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
assert_relative_eq!(sim * vec, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
sourcepub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
pub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
Creates an similarity that corresponds to a scaling factor and a local frame of
an observer standing at the point eye
and looking toward target
.
It maps the view direction target - eye
to the positive z
axis 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();
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::new_observer_frame(&eye, &target, &up, 3.0);
assert_eq!(sim * Point3::origin(), eye);
assert_relative_eq!(sim * Vector3::z(), Vector3::x() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::new_observer_frame(&eye, &target, &up, 3.0);
assert_eq!(sim * Point3::origin(), eye);
assert_relative_eq!(sim * Vector3::z(), Vector3::x() * 3.0, epsilon = 1.0e-6);
sourcepub fn look_at_rh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
pub fn look_at_rh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
Builds a right-handed look-at view matrix including scaling factor.
This conforms to the common notion of right handed look-at matrix from the computer graphics community.
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();
// Similarity with its rotation part represented as a UnitQuaternion
let iso = Similarity3::look_at_rh(&eye, &target, &up, 3.0);
assert_relative_eq!(iso * Vector3::x(), -Vector3::z() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let iso = SimilarityMatrix3::look_at_rh(&eye, &target, &up, 3.0);
assert_relative_eq!(iso * Vector3::x(), -Vector3::z() * 3.0, epsilon = 1.0e-6);
sourcepub fn look_at_lh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
pub fn look_at_lh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Rotation<N, U3>>
Builds a left-handed look-at view matrix including a scaling factor.
This conforms to the common notion of left handed look-at matrix from the computer graphics community.
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();
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::look_at_lh(&eye, &target, &up, 3.0);
assert_relative_eq!(sim * Vector3::x(), Vector3::z() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::look_at_lh(&eye, &target, &up, 3.0);
assert_relative_eq!(sim * Vector3::x(), Vector3::z() * 3.0, epsilon = 1.0e-6);
source§impl<N> Similarity<N, U3, Unit<Quaternion<N>>>where
N: Real,
impl<N> Similarity<N, U3, Unit<Quaternion<N>>>where
N: Real,
sourcepub fn new(
translation: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
pub fn new(
translation: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
Creates a new similarity from a translation, rotation axis-angle, and scaling factor.
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);
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::new(translation, axisangle, 3.0);
assert_relative_eq!(sim * pt, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
assert_relative_eq!(sim * vec, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
// Similarity with its rotation part represented as a Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::new(translation, axisangle, 3.0);
assert_relative_eq!(sim * pt, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
assert_relative_eq!(sim * vec, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
sourcepub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
pub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
Creates an similarity that corresponds to a scaling factor and a local frame of
an observer standing at the point eye
and looking toward target
.
It maps the view direction target - eye
to the positive z
axis 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();
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::new_observer_frame(&eye, &target, &up, 3.0);
assert_eq!(sim * Point3::origin(), eye);
assert_relative_eq!(sim * Vector3::z(), Vector3::x() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::new_observer_frame(&eye, &target, &up, 3.0);
assert_eq!(sim * Point3::origin(), eye);
assert_relative_eq!(sim * Vector3::z(), Vector3::x() * 3.0, epsilon = 1.0e-6);
sourcepub fn look_at_rh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
pub fn look_at_rh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
Builds a right-handed look-at view matrix including scaling factor.
This conforms to the common notion of right handed look-at matrix from the computer graphics community.
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();
// Similarity with its rotation part represented as a UnitQuaternion
let iso = Similarity3::look_at_rh(&eye, &target, &up, 3.0);
assert_relative_eq!(iso * Vector3::x(), -Vector3::z() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let iso = SimilarityMatrix3::look_at_rh(&eye, &target, &up, 3.0);
assert_relative_eq!(iso * Vector3::x(), -Vector3::z() * 3.0, epsilon = 1.0e-6);
sourcepub fn look_at_lh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
pub fn look_at_lh(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
scaling: N
) -> Similarity<N, U3, Unit<Quaternion<N>>>
Builds a left-handed look-at view matrix including a scaling factor.
This conforms to the common notion of left handed look-at matrix from the computer graphics community.
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();
// Similarity with its rotation part represented as a UnitQuaternion
let sim = Similarity3::look_at_lh(&eye, &target, &up, 3.0);
assert_relative_eq!(sim * Vector3::x(), Vector3::z() * 3.0, epsilon = 1.0e-6);
// Similarity with its rotation part represented as Rotation3 (a 3x3 rotation matrix).
let sim = SimilarityMatrix3::look_at_lh(&eye, &target, &up, 3.0);
assert_relative_eq!(sim * Vector3::x(), Vector3::z() * 3.0, epsilon = 1.0e-6);
Trait Implementations§
source§impl<N, D, R> AbsDiffEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + AbsDiffEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, D, R> AbsDiffEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + AbsDiffEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_epsilon(
) -> <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
fn default_epsilon(
) -> <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
source§fn abs_diff_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
) -> bool
fn abs_diff_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
) -> bool
§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
ApproxEq::abs_diff_eq
.source§impl<N, D, R> AbstractMagma<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AbstractMagma<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn operate(&self, rhs: &Similarity<N, D, R>) -> Similarity<N, D, R>
fn operate(&self, rhs: &Similarity<N, D, R>) -> Similarity<N, D, R>
source§impl<N, D, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type NonUniformScaling = N
type NonUniformScaling = N
§type Translation = Translation<N, D>
type Translation = Translation<N, D>
source§fn decompose(&self) -> (Translation<N, D>, R, N, R)
fn decompose(&self) -> (Translation<N, D>, R, N, R)
source§fn append_translation(
&self,
t: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>
fn append_translation(
&self,
t: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>
source§fn prepend_translation(
&self,
t: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>
fn prepend_translation(
&self,
t: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>
source§fn append_rotation(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>
fn append_rotation(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>
source§fn prepend_rotation(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>
fn prepend_rotation(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>
source§fn append_scaling(
&self,
s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>
fn append_scaling(
&self,
s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>
source§fn prepend_scaling(
&self,
s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>
fn prepend_scaling(
&self,
s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>
source§fn append_rotation_wrt_point(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation,
p: &Point<N, D>
) -> Option<Similarity<N, D, R>>
fn append_rotation_wrt_point(
&self,
r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation,
p: &Point<N, D>
) -> Option<Similarity<N, D, R>>
p
, i.e., this point is left
invariant. Read moresource§impl<N, D, R> Clone for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + Clone,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Clone for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + Clone,
DefaultAllocator: Allocator<N, D, U1>,
source§fn clone(&self) -> Similarity<N, D, R>
fn clone(&self) -> Similarity<N, D, R>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<N, D, R> Debug for Similarity<N, D, R>where
N: Debug + Real,
D: Debug + DimName,
R: Debug,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Debug for Similarity<N, D, R>where
N: Debug + Real,
D: Debug + DimName,
R: Debug,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Display for Similarity<N, D, R>where
D: DimName,
N: Real + Display,
R: Rotation<Point<N, D>> + Display,
DefaultAllocator: Allocator<N, D, U1> + Allocator<usize, D, U1>,
impl<N, D, R> Display for Similarity<N, D, R>where
D: DimName,
N: Real + Display,
R: Rotation<Point<N, D>> + Display,
DefaultAllocator: Allocator<N, D, U1> + Allocator<usize, D, U1>,
source§impl<'a, 'b, N, D, R> Div<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Div<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Div<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Div<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Div<&'b R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Div<&'b R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Div<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Div<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Div<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Div<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'a, 'b, N, D, R> Div<&'b Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Div<&'b Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'b, N, D, R> Div<&'b Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Div<&'b Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <Isometry<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <Isometry<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'b, N, D, R> Div<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Div<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <Similarity<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
fn div(
self,
rhs: &'b Similarity<N, D, R>
) -> <Similarity<N, D, R> as Div<&'b Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'a, 'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'a, 'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
/
operator.source§impl<'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
/
operator.source§impl<'a, 'b, N> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, 'b, N> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn div(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
/
operation. Read moresource§impl<'b, N> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'b, N> Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn div(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Div<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
/
operation. Read moresource§impl<'a, N, D, R> Div<Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Div<Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Div<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Div<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, R> Div<R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Div<R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§impl<N, D, R> Div<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Div<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§impl<'a, N, D, R> Div<Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Div<Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Div<Similarity<N, D, R>>>::Output
fn div(
self,
rhs: Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Div<Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'a, N, D, R> Div<Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Div<Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Div<Similarity<N, D, R>>>::Output
fn div(
self,
rhs: Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Div<Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<N, D, R> Div<Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Div<Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: Similarity<N, D, R>
) -> <Isometry<N, D, R> as Div<Similarity<N, D, R>>>::Output
fn div(
self,
rhs: Similarity<N, D, R>
) -> <Isometry<N, D, R> as Div<Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<N, D, R> Div<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Div<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
/
operator.source§fn div(
self,
rhs: Similarity<N, D, R>
) -> <Similarity<N, D, R> as Div<Similarity<N, D, R>>>::Output
fn div(
self,
rhs: Similarity<N, D, R>
) -> <Similarity<N, D, R> as Div<Similarity<N, D, R>>>::Output
/
operation. Read moresource§impl<'a, N, D> Div<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'a, N, D> Div<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
/
operator.source§impl<N, D> Div<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<N, D> Div<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
/
operator.source§impl<'a, N> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, N> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Div<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn div(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Div<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
/
operation. Read moresource§impl<N> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N> Div<Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
/
operator.source§fn div(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Div<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn div(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Div<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
/
operation. Read moresource§impl<'b, N, D, R> DivAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> DivAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)
fn div_assign(&mut self, rhs: &'b Isometry<N, D, R>)
/=
operation. Read moresource§impl<'b, N, D, R> DivAssign<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> DivAssign<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: &'b R)
fn div_assign(&mut self, rhs: &'b R)
/=
operation. Read moresource§impl<'b, N, D, R> DivAssign<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> DivAssign<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: &'b Similarity<N, D, R>)
fn div_assign(&mut self, rhs: &'b Similarity<N, D, R>)
/=
operation. Read moresource§impl<N, D, R> DivAssign<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> DivAssign<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: Isometry<N, D, R>)
fn div_assign(&mut self, rhs: Isometry<N, D, R>)
/=
operation. Read moresource§impl<N, D, R> DivAssign<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> DivAssign<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: R)
fn div_assign(&mut self, rhs: R)
/=
operation. Read moresource§impl<N, D, R> DivAssign<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> DivAssign<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn div_assign(&mut self, rhs: Similarity<N, D, R>)
fn div_assign(&mut self, rhs: Similarity<N, D, R>)
/=
operation. Read moresource§impl<N, D, R> From<Similarity<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
impl<N, D, R> From<Similarity<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
source§fn from(
sim: Similarity<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
fn from(
sim: Similarity<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
source§impl<N, D, R> Hash for Similarity<N, D, R>where
N: Real + Hash,
D: DimName + Hash,
R: Hash,
DefaultAllocator: Allocator<N, D, U1>,
<DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash,
impl<N, D, R> Hash for Similarity<N, D, R>where
N: Real + Hash,
D: DimName + Hash,
R: Hash,
DefaultAllocator: Allocator<N, D, U1>,
<DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash,
source§impl<N, D, R> Identity<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Identity<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Inverse<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Inverse<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn inverse(&self) -> Similarity<N, D, R>
fn inverse(&self) -> Similarity<N, D, R>
self
, relative to the operator O
.source§fn inverse_mut(&mut self)
fn inverse_mut(&mut self)
self
.source§impl<'a, 'b, N, D, R> Mul<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Mul<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Mul<&'b Point<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Point<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Mul<&'b Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Mul<&'b R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Mul<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, 'b, N, D, C, R> Mul<&'b Similarity<N, D, R>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'a, 'b, N, D, C, R> Mul<&'b Similarity<N, D, R>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Transform<N, D, C> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <&'a Transform<N, D, C> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Similarity<N, D, R>> for &'a Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: &'b Similarity<N, D, R>
) -> <&'a Translation<N, D> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
right: &'b Similarity<N, D, R>
) -> <&'a Translation<N, D> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Isometry<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Isometry<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Similarity<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Similarity<N, D, R> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'b, N, D, C, R> Mul<&'b Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'b, N, D, C, R> Mul<&'b Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Transform<N, D, C> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: &'b Similarity<N, D, R>
) -> <Transform<N, D, C> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Similarity<N, D, R>> for Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: &'b Similarity<N, D, R>
) -> <Translation<N, D> as Mul<&'b Similarity<N, D, R>>>::Output
fn mul(
self,
right: &'b Similarity<N, D, R>
) -> <Translation<N, D> as Mul<&'b Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, 'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'a, 'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
*
operator.source§impl<'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
*
operator.source§impl<'a, 'b, N> Mul<&'b Similarity<N, U2, Unit<Complex<N>>>> for &'a Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'a, 'b, N> Mul<&'b Similarity<N, U2, Unit<Complex<N>>>> for &'a Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'b, N> Mul<&'b Similarity<N, U2, Unit<Complex<N>>>> for Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'b, N> Mul<&'b Similarity<N, U2, Unit<Complex<N>>>> for Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'a, 'b, N> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, 'b, N> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn mul(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
*
operation. Read moresource§impl<'b, N> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'b, N> Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn mul(
self,
right: &'b Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Mul<&'b Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
*
operation. Read moresource§impl<'a, 'b, N, D, C, R> Mul<&'b Transform<N, D, C>> for &'a Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
impl<'a, 'b, N, D, C, R> Mul<&'b Transform<N, D, C>> for &'a Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§impl<'b, N, D, C, R> Mul<&'b Transform<N, D, C>> for Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
impl<'b, N, D, C, R> Mul<&'b Transform<N, D, C>> for Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§impl<'a, 'b, N, D, R> Mul<&'b Translation<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Translation<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: &'b Translation<N, D>
) -> <&'a Similarity<N, D, R> as Mul<&'b Translation<N, D>>>::Output
fn mul(
self,
right: &'b Translation<N, D>
) -> <&'a Similarity<N, D, R> as Mul<&'b Translation<N, D>>>::Output
*
operation. Read moresource§impl<'b, N, D, R> Mul<&'b Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: &'b Translation<N, D>
) -> <Similarity<N, D, R> as Mul<&'b Translation<N, D>>>::Output
fn mul(
self,
right: &'b Translation<N, D>
) -> <Similarity<N, D, R> as Mul<&'b Translation<N, D>>>::Output
*
operation. Read moresource§impl<'a, N, D, R> Mul<Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Isometry<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Mul<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, R> Mul<Point<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Point<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Mul<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, R> Mul<R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<R> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§impl<N, D, R> Mul<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Isometry<N, D, R> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Similarity<N, D, R> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, N, D, C, R> Mul<Similarity<N, D, R>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'a, N, D, C, R> Mul<Similarity<N, D, R>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Transform<N, D, C> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <&'a Transform<N, D, C> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Similarity<N, D, R>> for &'a Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: Similarity<N, D, R>
) -> <&'a Translation<N, D> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
right: Similarity<N, D, R>
) -> <&'a Translation<N, D> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<N, D, R> Mul<Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Similarity<N, D, R>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Isometry<N, D, R> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Isometry<N, D, R> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<N, D, R> Mul<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Similarity<N, D, R> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Similarity<N, D, R> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<N, D, C, R> Mul<Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<N, D, C, R> Mul<Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Transform<N, D, C> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
rhs: Similarity<N, D, R>
) -> <Transform<N, D, C> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<N, D, R> Mul<Similarity<N, D, R>> for Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Similarity<N, D, R>> for Translation<N, D>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: Similarity<N, D, R>
) -> <Translation<N, D> as Mul<Similarity<N, D, R>>>::Output
fn mul(
self,
right: Similarity<N, D, R>
) -> <Translation<N, D> as Mul<Similarity<N, D, R>>>::Output
*
operation. Read moresource§impl<'a, N, D> Mul<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<'a, N, D> Mul<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
*
operator.source§impl<N, D> Mul<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
impl<N, D> Mul<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D>where
N: Real,
D: DimName,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1>,
§type Output = Similarity<N, D, Rotation<N, D>>
type Output = Similarity<N, D, Rotation<N, D>>
*
operator.source§impl<'a, N> Mul<Similarity<N, U2, Unit<Complex<N>>>> for &'a Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'a, N> Mul<Similarity<N, U2, Unit<Complex<N>>>> for &'a Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<N> Mul<Similarity<N, U2, Unit<Complex<N>>>> for Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
impl<N> Mul<Similarity<N, U2, Unit<Complex<N>>>> for Unit<Complex<N>>where
N: Real,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'a, N> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, N> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for &'a Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Mul<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn mul(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <&'a Unit<Quaternion<N>> as Mul<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
*
operation. Read moresource§impl<N> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N> Mul<Similarity<N, U3, Unit<Quaternion<N>>>> for Unit<Quaternion<N>>where
N: Real,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
§type Output = Similarity<N, U3, Unit<Quaternion<N>>>
type Output = Similarity<N, U3, Unit<Quaternion<N>>>
*
operator.source§fn mul(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Mul<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
fn mul(
self,
right: Similarity<N, U3, Unit<Quaternion<N>>>
) -> <Unit<Quaternion<N>> as Mul<Similarity<N, U3, Unit<Quaternion<N>>>>>::Output
*
operation. Read moresource§impl<'a, N, D, C, R> Mul<Transform<N, D, C>> for &'a Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
impl<'a, N, D, C, R> Mul<Transform<N, D, C>> for &'a Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§impl<N, D, C, R> Mul<Transform<N, D, C>> for Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
impl<N, D, C, R> Mul<Transform<N, D, C>> for Similarity<N, D, R>where
D: DimNameAdd<U1>,
C: TCategoryMul<TAffine>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
§type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
*
operator.source§impl<'a, N, D, R> Mul<Translation<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Translation<N, D>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: Translation<N, D>
) -> <&'a Similarity<N, D, R> as Mul<Translation<N, D>>>::Output
fn mul(
self,
right: Translation<N, D>
) -> <&'a Similarity<N, D, R> as Mul<Translation<N, D>>>::Output
*
operation. Read moresource§impl<N, D, R> Mul<Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
§type Output = Similarity<N, D, R>
type Output = Similarity<N, D, R>
*
operator.source§fn mul(
self,
right: Translation<N, D>
) -> <Similarity<N, D, R> as Mul<Translation<N, D>>>::Output
fn mul(
self,
right: Translation<N, D>
) -> <Similarity<N, D, R> as Mul<Translation<N, D>>>::Output
*
operation. Read moresource§impl<'b, N, D, R> MulAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> MulAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)
fn mul_assign(&mut self, rhs: &'b Isometry<N, D, R>)
*=
operation. Read moresource§impl<'b, N, D, R> MulAssign<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> MulAssign<&'b R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: &'b R)
fn mul_assign(&mut self, rhs: &'b R)
*=
operation. Read moresource§impl<'b, N, D, R> MulAssign<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> MulAssign<&'b Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: &'b Similarity<N, D, R>)
fn mul_assign(&mut self, rhs: &'b Similarity<N, D, R>)
*=
operation. Read moresource§impl<'b, N, D, C, R> MulAssign<&'b Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
impl<'b, N, D, C, R> MulAssign<&'b Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: &'b Similarity<N, D, R>)
fn mul_assign(&mut self, rhs: &'b Similarity<N, D, R>)
*=
operation. Read moresource§impl<'b, N, D, R> MulAssign<&'b Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> MulAssign<&'b Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: &'b Translation<N, D>)
fn mul_assign(&mut self, rhs: &'b Translation<N, D>)
*=
operation. Read moresource§impl<N, D, R> MulAssign<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> MulAssign<Isometry<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: Isometry<N, D, R>)
fn mul_assign(&mut self, rhs: Isometry<N, D, R>)
*=
operation. Read moresource§impl<N, D, R> MulAssign<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> MulAssign<R> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: R)
fn mul_assign(&mut self, rhs: R)
*=
operation. Read moresource§impl<N, D, R> MulAssign<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> MulAssign<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: Similarity<N, D, R>)
fn mul_assign(&mut self, rhs: Similarity<N, D, R>)
*=
operation. Read moresource§impl<N, D, C, R> MulAssign<Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
impl<N, D, C, R> MulAssign<Similarity<N, D, R>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: Similarity<N, D, R>)
fn mul_assign(&mut self, rhs: Similarity<N, D, R>)
*=
operation. Read moresource§impl<N, D, R> MulAssign<Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> MulAssign<Translation<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn mul_assign(&mut self, rhs: Translation<N, D>)
fn mul_assign(&mut self, rhs: Translation<N, D>)
*=
operation. Read moresource§impl<N, D, R> One for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> One for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> PartialEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + PartialEq<R>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> PartialEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + PartialEq<R>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn eq(&self, right: &Similarity<N, D, R>) -> bool
fn eq(&self, right: &Similarity<N, D, R>) -> bool
source§impl<N, D, R> ProjectiveTransformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> ProjectiveTransformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
source§impl<N, D, R> RelativeEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + RelativeEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, D, R> RelativeEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + RelativeEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_max_relative(
) -> <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
fn default_max_relative(
) -> <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
source§fn relative_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon,
max_relative: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
) -> bool
fn relative_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon,
max_relative: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon
) -> bool
§fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
ApproxEq::relative_eq
.source§impl<N, D, R> Similarity<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Similarity<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn translation(&self) -> Translation<N, D>
fn translation(&self) -> Translation<N, D>
source§fn translate_point(&self, pt: &E) -> E
fn translate_point(&self, pt: &E) -> E
source§fn rotate_point(&self, pt: &E) -> E
fn rotate_point(&self, pt: &E) -> E
source§fn scale_point(&self, pt: &E) -> E
fn scale_point(&self, pt: &E) -> E
source§fn rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn inverse_translate_point(&self, pt: &E) -> E
fn inverse_translate_point(&self, pt: &E) -> E
source§fn inverse_rotate_point(&self, pt: &E) -> E
fn inverse_rotate_point(&self, pt: &E) -> E
source§fn inverse_scale_point(&self, pt: &E) -> E
fn inverse_scale_point(&self, pt: &E) -> E
source§fn inverse_rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn inverse_rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§fn inverse_scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
fn inverse_scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
source§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 Similarity<N1, D, R>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + 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>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
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 Similarity<N1, D, R>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + 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>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
source§fn to_superset(
&self
) -> 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>
fn to_superset(
&self
) -> 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>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &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>
) -> bool
fn is_in_subset(
m: &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>
) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
m: &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>
) -> Similarity<N1, D, R>
unsafe fn from_superset_unchecked(
m: &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>
) -> Similarity<N1, D, R>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Rotation<N1, D>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>> + SupersetOf<Rotation<N1, D>>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, U1>,
impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Rotation<N1, D>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>> + SupersetOf<Rotation<N1, D>>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, U1>,
source§fn to_superset(&self) -> Similarity<N2, D, R>
fn to_superset(&self) -> Similarity<N2, D, R>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool
fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Rotation<N1, D>
unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Rotation<N1, D>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Translation<N1, D>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Translation<N1, D>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
source§fn to_superset(&self) -> Similarity<N2, D, R>
fn to_superset(&self) -> Similarity<N2, D, R>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool
fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R>
) -> Translation<N1, D>
unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R>
) -> Translation<N1, D>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1>where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
source§fn to_superset(&self) -> Similarity<N2, D, R2>
fn to_superset(&self) -> Similarity<N2, D, R2>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool
fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R2>
) -> Isometry<N1, D, R1>
unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R2>
) -> Isometry<N1, D, R1>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Similarity<N1, D, R1>where
D: DimName,
N1: Real + SubsetOf<N2>,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Similarity<N1, D, R1>where
D: DimName,
N1: Real + SubsetOf<N2>,
N2: Real + SupersetOf<N1>,
R1: Rotation<Point<N1, D>> + SubsetOf<R2>,
R2: Rotation<Point<N2, D>>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1>,
source§fn to_superset(&self) -> Similarity<N2, D, R2>
fn to_superset(&self) -> Similarity<N2, D, R2>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool
fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R2>
) -> Similarity<N1, D, R1>
unsafe fn from_superset_unchecked(
sim: &Similarity<N2, D, R2>
) -> Similarity<N1, D, R1>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for Unit<Complex<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, U2>> + SupersetOf<Unit<Complex<N1>>>,
impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for Unit<Complex<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, U2>> + SupersetOf<Unit<Complex<N1>>>,
source§fn to_superset(&self) -> Similarity<N2, U2, R>
fn to_superset(&self) -> Similarity<N2, U2, R>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, U2, R>) -> bool
fn is_in_subset(sim: &Similarity<N2, U2, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
sim: &Similarity<N2, U2, R>
) -> Unit<Complex<N1>>
unsafe fn from_superset_unchecked(
sim: &Similarity<N2, U2, R>
) -> Unit<Complex<N1>>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for Unit<Quaternion<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, U3>> + SupersetOf<Unit<Quaternion<N1>>>,
impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for Unit<Quaternion<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, U3>> + SupersetOf<Unit<Quaternion<N1>>>,
source§fn to_superset(&self) -> Similarity<N2, U3, R>
fn to_superset(&self) -> Similarity<N2, U3, R>
self
to the equivalent element of its superset.source§fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool
fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
sim: &Similarity<N2, U3, R>
) -> Unit<Quaternion<N1>>
unsafe fn from_superset_unchecked(
sim: &Similarity<N2, U3, R>
) -> Unit<Quaternion<N1>>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Similarity<N1, D, R>where
N1: Real,
N2: Real + SupersetOf<N1>,
C: SuperTCategoryOf<TAffine>,
R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + 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>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Similarity<N1, D, R>where
N1: Real,
N2: Real + SupersetOf<N1>,
C: SuperTCategoryOf<TAffine>,
R: Rotation<Point<N1, D>> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + 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>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
source§fn to_superset(&self) -> Transform<N2, D, C>
fn to_superset(&self) -> Transform<N2, D, C>
self
to the equivalent element of its superset.source§fn is_in_subset(t: &Transform<N2, D, C>) -> bool
fn is_in_subset(t: &Transform<N2, D, C>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
t: &Transform<N2, D, C>
) -> Similarity<N1, D, R>
unsafe fn from_superset_unchecked(
t: &Transform<N2, D, C>
) -> Similarity<N1, D, R>
self.to_superset
but without any property checks. Always succeeds.source§impl<N, D, R> Transformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Transformation<Point<N, D>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
source§impl<N, D, R> UlpsEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + UlpsEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, D, R> UlpsEq<Similarity<N, D, R>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + UlpsEq<R, Epsilon = <N as AbsDiffEq<N>>::Epsilon>,
DefaultAllocator: Allocator<N, D, U1>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
source§fn ulps_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon,
max_ulps: u32
) -> bool
fn ulps_eq(
&self,
other: &Similarity<N, D, R>,
epsilon: <Similarity<N, D, R> as AbsDiffEq<Similarity<N, D, R>>>::Epsilon,
max_ulps: u32
) -> bool
impl<N, D, R> AbstractGroup<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AbstractLoop<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AbstractMonoid<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AbstractQuasigroup<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> AbstractSemigroup<Multiplicative> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Copy for Similarity<N, D, R>where
N: Real,
D: DimName + Copy,
R: Rotation<Point<N, D>> + Copy,
DefaultAllocator: Allocator<N, D, U1>,
<DefaultAllocator as Allocator<N, D, U1>>::Buffer: Copy,
impl<N, D, R> Eq for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>> + Eq,
DefaultAllocator: Allocator<N, D, U1>,
Auto Trait Implementations§
impl<N, D, R> !RefUnwindSafe for Similarity<N, D, R>
impl<N, D, R> !Send for Similarity<N, D, R>
impl<N, D, R> !Sync for Similarity<N, D, R>
impl<N, D, R> !Unpin for Similarity<N, D, R>
impl<N, D, R> !UnwindSafe for Similarity<N, D, R>
Blanket Implementations§
source§impl<T> Rand for Twhere
Standard: Distribution<T>,
impl<T> Rand for Twhere
Standard: Distribution<T>,
source§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
source§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read moresource§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).source§unsafe fn to_subset_unchecked(&self) -> SS
unsafe fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.source§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.