Struct ggez::graphics::na::Rotation
[−]
[src]
#[repr(C)]pub struct Rotation<N, D> where
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>, { /* fields omitted */ }
A rotation matrix.
Methods
impl<N, D> Rotation<N, D> where
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
fn matrix(
&self
) -> &Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
[src]
&self
) -> &Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
A reference to the underlying matrix representation of this rotation.
unsafe fn matrix_mut(
&mut self
) -> &mut Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
[src]
&mut self
) -> &mut Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
A mutable reference to the underlying matrix representation of this rotation.
This is unsafe because this allows the user to replace the matrix by another one that is non-square, non-inversible, or non-orthonormal. If one of those properties is broken, subsequent method calls may be UB.
fn unwrap(
self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
[src]
self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
Unwraps the underlying matrix.
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>,
N: Zero + One,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
[src]
&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>,
N: Zero + One,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
Converts this rotation into its equivalent homogeneous transformation matrix.
fn from_matrix_unchecked(
matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Rotation<N, D>
[src]
matrix: Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Rotation<N, D>
Creates a new rotation from the given square matrix.
The matrix squareness is checked but not its orthonormality.
fn transpose(&self) -> Rotation<N, D>
[src]
Transposes self
.
fn inverse(&self) -> Rotation<N, D>
[src]
Inverts self
.
fn transpose_mut(&mut self)
[src]
Transposes self
in-place.
fn inverse_mut(&mut self)
[src]
Inverts self
in-place.
impl<N, D> Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, D, D>,
impl<N> Rotation<N, U2> where
N: Real,
[src]
N: Real,
fn new(angle: N) -> Rotation<N, U2>
[src]
Builds a 2 dimensional rotation matrix from an angle in radian.
fn from_scaled_axis<SB>(axisangle: Matrix<N, U1, U1, SB>) -> Rotation<N, U2> where
SB: Storage<N, U1, U1>,
[src]
SB: Storage<N, U1, U1>,
Builds a 2 dimensional rotation matrix from an angle in radian wrapped in a 1-dimensional vector.
Equivalent to Self::new(axisangle[0])
.
fn rotation_between<SB, SC>(
a: &Matrix<N, U2, U1, SB>,
b: &Matrix<N, U2, U1, SC>
) -> Rotation<N, U2> where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
[src]
a: &Matrix<N, U2, U1, SB>,
b: &Matrix<N, U2, U1, SC>
) -> Rotation<N, U2> where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
The rotation matrix required to align a
and b
but with its angl.
This is the rotation R
such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive()
.
fn scaled_rotation_between<SB, SC>(
a: &Matrix<N, U2, U1, SB>,
b: &Matrix<N, U2, U1, SC>,
s: N
) -> Rotation<N, U2> where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
[src]
a: &Matrix<N, U2, U1, SB>,
b: &Matrix<N, U2, U1, SC>,
s: N
) -> Rotation<N, U2> where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
The smallest rotation needed to make a
and b
collinear and point toward the same
direction, raised to the power s
.
impl<N> Rotation<N, U2> where
N: Real,
[src]
N: Real,
fn angle(&self) -> N
[src]
The rotation angle.
fn angle_to(&self, other: &Rotation<N, U2>) -> N
[src]
The rotation angle needed to make self
and other
coincide.
fn rotation_to(&self, other: &Rotation<N, U2>) -> Rotation<N, U2>
[src]
The rotation matrix needed to make self
and other
coincide.
The result is such that: self.rotation_to(other) * self == other
.
fn powf(&self, n: N) -> Rotation<N, U2>
[src]
Raise the quaternion to a given floating power, i.e., returns the rotation with the angle
of self
multiplied by n
.
fn scaled_axis(
&self
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
The rotation angle returned as a 1-dimensional vector.
impl<N> Rotation<N, U3> where
N: Real,
[src]
N: Real,
fn new<SB>(axisangle: Matrix<N, U3, U1, SB>) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
[src]
SB: Storage<N, U3, U1>,
Builds a 3 dimensional rotation matrix from an axis and an angle.
Arguments
axisangle
- A vector representing the rotation. Its magnitude is the amount of rotation in radian. Its direction is the axis of rotation.
fn from_scaled_axis<SB>(axisangle: Matrix<N, U3, U1, SB>) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
[src]
SB: Storage<N, U3, U1>,
Builds a 3D rotation matrix from an axis scaled by the rotation angle.
fn from_axis_angle<SB>(
axis: &Unit<Matrix<N, U3, U1, SB>>,
angle: N
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
[src]
axis: &Unit<Matrix<N, U3, U1, SB>>,
angle: N
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
Builds a 3D rotation matrix from an axis and a rotation angle.
fn from_euler_angles(roll: N, pitch: N, yaw: N) -> Rotation<N, U3>
[src]
Creates a new rotation from Euler angles.
The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.
fn new_observer_frame<SB, SC>(
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
[src]
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
Creates a rotation that corresponds to the local frame of an observer standing at the
origin and looking toward dir
.
It maps the view direction dir
to the positive z
axis.
Arguments
- dir - The look direction, that is, direction the matrix
z
axis will be aligned with. - up - The vertical direction. The only requirement of this parameter is to not be
collinear
to
dir
. Non-collinearity is not checked.
fn look_at_rh<SB, SC>(
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
[src]
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
Builds a right-handed look-at view matrix without translation.
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
.
fn look_at_lh<SB, SC>(
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
[src]
dir: &Matrix<N, U3, U1, SB>,
up: &Matrix<N, U3, U1, SC>
) -> Rotation<N, U3> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
Builds a left-handed look-at view matrix without translation.
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
.
fn rotation_between<SB, SC>(
a: &Matrix<N, U3, U1, SB>,
b: &Matrix<N, U3, U1, SC>
) -> Option<Rotation<N, U3>> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
[src]
a: &Matrix<N, U3, U1, SB>,
b: &Matrix<N, U3, U1, SC>
) -> Option<Rotation<N, U3>> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
The rotation matrix required to align a
and b
but with its angl.
This is the rotation R
such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive()
.
fn scaled_rotation_between<SB, SC>(
a: &Matrix<N, U3, U1, SB>,
b: &Matrix<N, U3, U1, SC>,
n: N
) -> Option<Rotation<N, U3>> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
[src]
a: &Matrix<N, U3, U1, SB>,
b: &Matrix<N, U3, U1, SC>,
n: N
) -> Option<Rotation<N, U3>> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
The smallest rotation needed to make a
and b
collinear and point toward the same
direction, raised to the power s
.
fn angle(&self) -> N
[src]
The rotation angle.
fn axis(
&self
) -> Option<Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>>
[src]
&self
) -> Option<Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>>
The rotation axis. Returns None
if the rotation angle is zero or PI.
fn scaled_axis(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
The rotation axis multiplied by the rotation angle.
fn angle_to(&self, other: &Rotation<N, U3>) -> N
[src]
The rotation angle needed to make self
and other
coincide.
fn rotation_to(&self, other: &Rotation<N, U3>) -> Rotation<N, U3>
[src]
The rotation matrix needed to make self
and other
coincide.
The result is such that: self.rotation_to(other) * self == other
.
fn powf(&self, n: N) -> Rotation<N, U3>
[src]
Raise the quaternion to a given floating power, i.e., returns the rotation with the same
axis as self
and an angle equal to self.angle()
multiplied by n
.
Trait Implementations
impl<N> Rand for Rotation<N, U2> where
N: Rand + Real,
[src]
N: Rand + Real,
impl<N> Rand for Rotation<N, U3> where
N: Rand + Real,
[src]
N: Rand + Real,
impl<N, D> Copy for Rotation<N, D> where
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Copy,
[src]
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Copy,
impl<N, D> Clone for Rotation<N, D> where
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Clone,
[src]
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Clone,
fn clone(&self) -> Rotation<N, D>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<N, D> AbstractMonoid<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<N1, N2, D, R> SubsetOf<Isometry<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>,
DefaultAllocator: Allocator<N2, D, U1>,
[src]
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>> + SupersetOf<Rotation<N1, D>>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, U1>,
fn to_superset(&self) -> Isometry<N2, D, R>
[src]
fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool
[src]
unsafe fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Rotation<N1, D>
[src]
impl<N1, N2> SubsetOf<Unit<Complex<N2>>> for Rotation<N1, U2> where
N1: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> Unit<Complex<N2>>
[src]
fn is_in_subset(q: &Unit<Complex<N2>>) -> bool
[src]
unsafe fn from_superset_unchecked(q: &Unit<Complex<N2>>) -> Rotation<N1, U2>
[src]
impl<N1, N2, D> 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 Rotation<N1, D> where
D: DimNameAdd<U1> + DimMin<D, Output = D>,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
D: DimNameAdd<U1> + DimMin<D, Output = D>,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
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>
[src]
&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 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
[src]
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
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>
) -> Rotation<N1, D>
[src]
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>
) -> Rotation<N1, D>
impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Rotation<N1, D> where
C: SuperTCategoryOf<TAffine>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
C: SuperTCategoryOf<TAffine>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
fn to_superset(&self) -> Transform<N2, D, C>
[src]
fn is_in_subset(t: &Transform<N2, D, C>) -> bool
[src]
unsafe fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Rotation<N1, D>
[src]
impl<N1, N2, D> SubsetOf<Rotation<N2, D>> for Rotation<N1, D> where
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
[src]
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, D>,
fn to_superset(&self) -> Rotation<N2, D>
[src]
fn is_in_subset(rot: &Rotation<N2, D>) -> bool
[src]
unsafe fn from_superset_unchecked(rot: &Rotation<N2, D>) -> Rotation<N1, D>
[src]
impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for Rotation<N1, U3> where
N1: Real,
N2: Real + SupersetOf<N1>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
fn to_superset(&self) -> Unit<Quaternion<N2>>
[src]
fn is_in_subset(q: &Unit<Quaternion<N2>>) -> bool
[src]
unsafe fn from_superset_unchecked(q: &Unit<Quaternion<N2>>) -> Rotation<N1, U3>
[src]
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>,
DefaultAllocator: Allocator<N2, D, U1>,
[src]
D: DimName,
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N2, D>> + SupersetOf<Rotation<N1, D>>,
DefaultAllocator: Allocator<N1, D, D>,
DefaultAllocator: Allocator<N2, D, U1>,
fn to_superset(&self) -> Similarity<N2, D, R>
[src]
fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool
[src]
unsafe fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Rotation<N1, D>
[src]
impl<N, D> Inverse<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
fn inverse(&self) -> Rotation<N, D>
[src]
fn inverse_mut(&mut self)
[src]
impl<N, D> ProjectiveTransformation<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
fn inverse_transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
[src]
fn inverse_transform_vector(
&self,
v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
[src]
&self,
v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
impl<N, D> Isometry<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D> AffineTransformation<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Rotation = Rotation<N, D>
type NonUniformScaling = Id<Multiplicative>
type Translation = Id<Multiplicative>
fn decompose(
&self
) -> (Id<Multiplicative>, Rotation<N, D>, Id<Multiplicative>, Rotation<N, D>)
[src]
&self
) -> (Id<Multiplicative>, Rotation<N, D>, Id<Multiplicative>, Rotation<N, D>)
fn append_translation(
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>
[src]
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>
fn prepend_translation(
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>
[src]
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>
fn append_rotation(
&self,
r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>
[src]
&self,
r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>
fn prepend_rotation(
&self,
r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>
[src]
&self,
r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>
fn append_scaling(
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>
[src]
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>
fn prepend_scaling(
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>
[src]
&self,
&<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>
impl<N, D> Transformation<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
fn transform_point(&self, pt: &Point<N, D>) -> Point<N, D>
[src]
fn transform_vector(
&self,
v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
[src]
&self,
v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
impl<'b, N, D> Div<&'b Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn div(
self,
right: &'b Rotation<N, D>
) -> <Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output
[src]
self,
right: &'b Rotation<N, D>
) -> <Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output
impl<N, D> Div<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn div(
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output
impl<N, D, C> Div<Transform<N, D, C>> for Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn div(
self,
rhs: Transform<N, D, C>
) -> <Rotation<N, D> as Div<Transform<N, D, C>>>::Output
[src]
self,
rhs: Transform<N, D, C>
) -> <Rotation<N, D> as Div<Transform<N, D, C>>>::Output
impl<N> Div<Unit<Quaternion<N>>> for Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn div(
self,
rhs: Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output
impl<N, D> Div<Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn div(
self,
right: Rotation<N, D>
) -> <Rotation<N, D> as Div<Rotation<N, D>>>::Output
[src]
self,
right: Rotation<N, D>
) -> <Rotation<N, D> as Div<Rotation<N, D>>>::Output
impl<'a, N> Div<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn div(
self,
rhs: Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Div<Unit<Quaternion<N>>>>::Output
impl<'b, N> Div<&'b Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn div(
self,
rhs: &'b Unit<Complex<N>>
) -> <Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output
[src]
self,
rhs: &'b Unit<Complex<N>>
) -> <Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output
impl<N> Div<Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn div(
self,
rhs: Unit<Complex<N>>
) -> <Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output
[src]
self,
rhs: Unit<Complex<N>>
) -> <Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output
impl<'b, N, D> Div<&'b Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn div(
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output
impl<'b, N, D, C> Div<&'b Transform<N, D, C>> for Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn div(
self,
rhs: &'b Transform<N, D, C>
) -> <Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output
[src]
self,
rhs: &'b Transform<N, D, C>
) -> <Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output
impl<'a, N> Div<Unit<Complex<N>>> for &'a Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn div(
self,
rhs: Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output
[src]
self,
rhs: Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Div<Unit<Complex<N>>>>::Output
impl<'a, 'b, N> Div<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn div(
self,
rhs: &'b Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output
[src]
self,
rhs: &'b Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Div<&'b Unit<Complex<N>>>>::Output
impl<N, D> Div<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn div(
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output
impl<'a, 'b, N, D> Div<&'b Rotation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn div(
self,
right: &'b Rotation<N, D>
) -> <&'a Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output
[src]
self,
right: &'b Rotation<N, D>
) -> <&'a Rotation<N, D> as Div<&'b Rotation<N, D>>>::Output
impl<'a, 'b, N, D> Div<&'b Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn div(
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<&'b Isometry<N, D, Rotation<N, D>>>>::Output
impl<'a, N, D> Div<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn div(
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<Similarity<N, D, Rotation<N, D>>>>::Output
impl<'a, 'b, N, D, C> Div<&'b Transform<N, D, C>> for &'a Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn div(
self,
rhs: &'b Transform<N, D, C>
) -> <&'a Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output
[src]
self,
rhs: &'b Transform<N, D, C>
) -> <&'a Rotation<N, D> as Div<&'b Transform<N, D, C>>>::Output
impl<'b, N> Div<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn div(
self,
rhs: &'b Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: &'b Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output
impl<'a, 'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn div(
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output
impl<'a, 'b, N> Div<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn div(
self,
rhs: &'b Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: &'b Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Div<&'b Unit<Quaternion<N>>>>::Output
impl<'a, N, D> Div<Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn div(
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Div<Isometry<N, D, Rotation<N, D>>>>::Output
impl<'a, N, D, C> Div<Transform<N, D, C>> for &'a Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn div(
self,
rhs: Transform<N, D, C>
) -> <&'a Rotation<N, D> as Div<Transform<N, D, C>>>::Output
[src]
self,
rhs: Transform<N, D, C>
) -> <&'a Rotation<N, D> as Div<Transform<N, D, C>>>::Output
impl<'b, N, D> Div<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn div(
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Div<&'b Similarity<N, D, Rotation<N, D>>>>::Output
impl<'a, N, D> Div<Rotation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn div(
self,
right: Rotation<N, D>
) -> <&'a Rotation<N, D> as Div<Rotation<N, D>>>::Output
[src]
self,
right: Rotation<N, D>
) -> <&'a Rotation<N, D> as Div<Rotation<N, D>>>::Output
impl<N, D> AbstractSemigroup<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> AbstractLoop<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<'b, N, D> DivAssign<&'b Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn div_assign(&mut self, right: &'b Rotation<N, D>)
[src]
impl<'b, N> DivAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
fn div_assign(&mut self, rhs: &'b Unit<Complex<N>>)
[src]
impl<N, D> DivAssign<Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn div_assign(&mut self, right: Rotation<N, D>)
[src]
impl<N> DivAssign<Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
fn div_assign(&mut self, rhs: Unit<Complex<N>>)
[src]
impl<N, D> ApproxEq for Rotation<N, D> where
D: DimName,
N: Scalar + ApproxEq,
DefaultAllocator: Allocator<N, D, D>,
<N as ApproxEq>::Epsilon: Copy,
[src]
D: DimName,
N: Scalar + ApproxEq,
DefaultAllocator: Allocator<N, D, D>,
<N as ApproxEq>::Epsilon: Copy,
type Epsilon = <N as ApproxEq>::Epsilon
fn default_epsilon() -> <Rotation<N, D> as ApproxEq>::Epsilon
[src]
fn default_max_relative() -> <Rotation<N, D> as ApproxEq>::Epsilon
[src]
fn default_max_ulps() -> u32
[src]
fn relative_eq(
&self,
other: &Rotation<N, D>,
epsilon: <Rotation<N, D> as ApproxEq>::Epsilon,
max_relative: <Rotation<N, D> as ApproxEq>::Epsilon
) -> bool
[src]
&self,
other: &Rotation<N, D>,
epsilon: <Rotation<N, D> as ApproxEq>::Epsilon,
max_relative: <Rotation<N, D> as ApproxEq>::Epsilon
) -> bool
fn ulps_eq(
&self,
other: &Rotation<N, D>,
epsilon: <Rotation<N, D> as ApproxEq>::Epsilon,
max_ulps: u32
) -> bool
[src]
&self,
other: &Rotation<N, D>,
epsilon: <Rotation<N, D> as ApproxEq>::Epsilon,
max_ulps: u32
) -> bool
impl<N, D> Hash for Rotation<N, D> where
D: DimName + Hash,
N: Scalar + Hash,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Hash,
[src]
D: DimName + Hash,
N: Scalar + Hash,
DefaultAllocator: Allocator<N, D, D>,
<DefaultAllocator as Allocator<N, D, D>>::Buffer: Hash,
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<N, D> Similarity<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Scaling = Id<Multiplicative>
fn translation(&self) -> Id<Multiplicative>
[src]
fn rotation(&self) -> Rotation<N, D>
[src]
fn scaling(&self) -> Id<Multiplicative>
[src]
impl<N, D> PartialEq<Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + PartialEq<N>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + PartialEq<N>,
DefaultAllocator: Allocator<N, D, D>,
fn eq(&self, right: &Rotation<N, D>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<N, D> Debug for Rotation<N, D> where
D: DimName + Debug,
N: Scalar + Debug,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName + Debug,
N: Scalar + Debug,
DefaultAllocator: Allocator<N, D, D>,
fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<N, D> Rotation<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
Subgroups of the n-dimensional rotation group SO(n)
.
fn powf(&self, N) -> Option<Rotation<N, D>>
[src]
fn rotation_between(
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Option<Rotation<N, D>>
[src]
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Option<Rotation<N, D>>
fn scaled_rotation_between(
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
N
) -> Option<Rotation<N, D>>
[src]
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
&Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
N
) -> Option<Rotation<N, D>>
impl<N, D> DirectIsometry<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D> AbstractQuasigroup<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> AbstractGroup<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> One for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Index<(usize, usize)> for Rotation<N, D> where
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Identity<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Eq for Rotation<N, D> where
D: DimName,
N: Scalar + Eq,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Eq,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> OrthogonalTransformation<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N> MulAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
fn mul_assign(&mut self, rhs: &'b Unit<Complex<N>>)
[src]
impl<'b, N, D> MulAssign<&'b Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn mul_assign(&mut self, right: &'b Rotation<N, D>)
[src]
impl<N> MulAssign<Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
fn mul_assign(&mut self, rhs: Unit<Complex<N>>)
[src]
impl<N, D> MulAssign<Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn mul_assign(&mut self, right: Rotation<N, D>)
[src]
impl<N, D> AbstractMagma<Multiplicative> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
impl<'b, N, D> Mul<&'b Translation<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Translation<N, D>
) -> <Rotation<N, D> as Mul<&'b Translation<N, D>>>::Output
[src]
self,
right: &'b Translation<N, D>
) -> <Rotation<N, D> as Mul<&'b Translation<N, D>>>::Output
impl<'a, N, D> Mul<Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn mul(
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<Similarity<N, D, Rotation<N, D>>>>::Output
impl<N> Mul<Unit<Quaternion<N>>> for Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn mul(
self,
rhs: Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Mul<Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Mul<Unit<Quaternion<N>>>>::Output
impl<'a, N, D, C> Mul<Transform<N, D, C>> for &'a Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn mul(
self,
rhs: Transform<N, D, C>
) -> <&'a Rotation<N, D> as Mul<Transform<N, D, C>>>::Output
[src]
self,
rhs: Transform<N, D, C>
) -> <&'a Rotation<N, D> as Mul<Transform<N, D, C>>>::Output
impl<'b, N, D> Mul<&'b Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = Point<N, D>
fn mul(
self,
right: &'b Point<N, D>
) -> <Rotation<N, D> as Mul<&'b Point<N, D>>>::Output
[src]
self,
right: &'b Point<N, D>
) -> <Rotation<N, D> as Mul<&'b Point<N, D>>>::Output
impl<N, D> Mul<Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<Isometry<N, D, Rotation<N, D>>>>::Output
impl<N> Mul<Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn mul(
self,
rhs: Unit<Complex<N>>
) -> <Rotation<N, U2> as Mul<Unit<Complex<N>>>>::Output
[src]
self,
rhs: Unit<Complex<N>>
) -> <Rotation<N, U2> as Mul<Unit<Complex<N>>>>::Output
impl<'b, N> Mul<&'b Unit<Quaternion<N>>> for Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn mul(
self,
rhs: &'b Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Mul<&'b Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: &'b Unit<Quaternion<N>>
) -> <Rotation<N, U3> as Mul<&'b Unit<Quaternion<N>>>>::Output
impl<'a, 'b, N, D> Mul<&'b Rotation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn mul(
self,
right: &'b Rotation<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Rotation<N, D>>>::Output
[src]
self,
right: &'b Rotation<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Rotation<N, D>>>::Output
impl<'a, N, D> Mul<Translation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: Translation<N, D>
) -> <&'a Rotation<N, D> as Mul<Translation<N, D>>>::Output
[src]
self,
right: Translation<N, D>
) -> <&'a Rotation<N, D> as Mul<Translation<N, D>>>::Output
impl<'b, N> Mul<&'b Unit<Complex<N>>> for Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn mul(
self,
rhs: &'b Unit<Complex<N>>
) -> <Rotation<N, U2> as Mul<&'b Unit<Complex<N>>>>::Output
[src]
self,
rhs: &'b Unit<Complex<N>>
) -> <Rotation<N, U2> as Mul<&'b Unit<Complex<N>>>>::Output
impl<'a, 'b, N> Mul<&'b Unit<Complex<N>>> for &'a Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn mul(
self,
rhs: &'b Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Mul<&'b Unit<Complex<N>>>>::Output
[src]
self,
rhs: &'b Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Mul<&'b Unit<Complex<N>>>>::Output
impl<N, D> Mul<Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn mul(
self,
right: Rotation<N, D>
) -> <Rotation<N, D> as Mul<Rotation<N, D>>>::Output
[src]
self,
right: Rotation<N, D>
) -> <Rotation<N, D> as Mul<Rotation<N, D>>>::Output
impl<'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = Matrix<N, D1, C2, <DefaultAllocator as Allocator<N, D1, C2>>::Buffer>
fn mul(
self,
right: &'b Matrix<N, R2, C2, SB>
) -> <Rotation<N, D1> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
right: &'b Matrix<N, R2, C2, SB>
) -> <Rotation<N, D1> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
impl<'b, N, D> Mul<&'b Rotation<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn mul(
self,
right: &'b Rotation<N, D>
) -> <Rotation<N, D> as Mul<&'b Rotation<N, D>>>::Output
[src]
self,
right: &'b Rotation<N, D>
) -> <Rotation<N, D> as Mul<&'b Rotation<N, D>>>::Output
impl<'a, N, D> Mul<Rotation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
type Output = Rotation<N, D>
fn mul(
self,
right: Rotation<N, D>
) -> <&'a Rotation<N, D> as Mul<Rotation<N, D>>>::Output
[src]
self,
right: Rotation<N, D>
) -> <&'a Rotation<N, D> as Mul<Rotation<N, D>>>::Output
impl<'a, N> Mul<Unit<Complex<N>>> for &'a Rotation<N, U2> where
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U2, U2>,
type Output = Unit<Complex<N>>
fn mul(
self,
rhs: Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Mul<Unit<Complex<N>>>>::Output
[src]
self,
rhs: Unit<Complex<N>>
) -> <&'a Rotation<N, U2> as Mul<Unit<Complex<N>>>>::Output
impl<'a, N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = Matrix<N, D1, C2, <DefaultAllocator as Allocator<N, D1, C2>>::Buffer>
fn mul(
self,
right: Matrix<N, R2, C2, SB>
) -> <&'a Rotation<N, D1> as Mul<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
right: Matrix<N, R2, C2, SB>
) -> <&'a Rotation<N, D1> as Mul<Matrix<N, R2, C2, SB>>>::Output
impl<N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = Matrix<N, D1, C2, <DefaultAllocator as Allocator<N, D1, C2>>::Buffer>
fn mul(
self,
right: Matrix<N, R2, C2, SB>
) -> <Rotation<N, D1> as Mul<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
right: Matrix<N, R2, C2, SB>
) -> <Rotation<N, D1> as Mul<Matrix<N, R2, C2, SB>>>::Output
impl<'a, 'b, N, D> Mul<&'b Translation<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Translation<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Translation<N, D>>>::Output
[src]
self,
right: &'b Translation<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Translation<N, D>>>::Output
impl<'a, 'b, N, D> Mul<&'b Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<&'b Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<&'b Isometry<N, D, Rotation<N, D>>>>::Output
impl<'a, 'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<&'b Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<&'b Similarity<N, D, Rotation<N, D>>>>::Output
impl<'a, N> Mul<Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn mul(
self,
rhs: Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Mul<Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Mul<Unit<Quaternion<N>>>>::Output
impl<'a, 'b, N, D> Mul<&'b Point<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = Point<N, D>
fn mul(
self,
right: &'b Point<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Point<N, D>>>::Output
[src]
self,
right: &'b Point<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Point<N, D>>>::Output
impl<'a, 'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
C2: Dim,
D1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, D1>,
DefaultAllocator: Allocator<N, R2, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = Matrix<N, D1, C2, <DefaultAllocator as Allocator<N, D1, C2>>::Buffer>
fn mul(
self,
right: &'b Matrix<N, R2, C2, SB>
) -> <&'a Rotation<N, D1> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
right: &'b Matrix<N, R2, C2, SB>
) -> <&'a Rotation<N, D1> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
impl<N, D> Mul<Translation<N, D>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: Translation<N, D>
) -> <Rotation<N, D> as Mul<Translation<N, D>>>::Output
[src]
self,
right: Translation<N, D>
) -> <Rotation<N, D> as Mul<Translation<N, D>>>::Output
impl<N, D, C> Mul<Transform<N, D, C>> for Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn mul(
self,
rhs: Transform<N, D, C>
) -> <Rotation<N, D> as Mul<Transform<N, D, C>>>::Output
[src]
self,
rhs: Transform<N, D, C>
) -> <Rotation<N, D> as Mul<Transform<N, D, C>>>::Output
impl<'b, N, D, C> Mul<&'b Transform<N, D, C>> for Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn mul(
self,
rhs: &'b Transform<N, D, C>
) -> <Rotation<N, D> as Mul<&'b Transform<N, D, C>>>::Output
[src]
self,
rhs: &'b Transform<N, D, C>
) -> <Rotation<N, D> as Mul<&'b Transform<N, D, C>>>::Output
impl<'a, N, D> Mul<Isometry<N, D, Rotation<N, D>>> for &'a Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Isometry<N, D, Rotation<N, D>>
) -> <&'a Rotation<N, D> as Mul<Isometry<N, D, Rotation<N, D>>>>::Output
impl<'a, 'b, N> Mul<&'b Unit<Quaternion<N>>> for &'a Rotation<N, U3> where
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Real,
DefaultAllocator: Allocator<N, U3, U3>,
DefaultAllocator: Allocator<N, U4, U1>,
type Output = Unit<Quaternion<N>>
fn mul(
self,
rhs: &'b Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Mul<&'b Unit<Quaternion<N>>>>::Output
[src]
self,
rhs: &'b Unit<Quaternion<N>>
) -> <&'a Rotation<N, U3> as Mul<&'b Unit<Quaternion<N>>>>::Output
impl<'a, 'b, N, D, C> Mul<&'b Transform<N, D, C>> for &'a Rotation<N, D> where
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
[src]
C: TCategoryMul<TAffine>,
D: DimNameAdd<U1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimNameAdd<U1>>::Output>,
type Output = Transform<N, D, <C as TCategoryMul<TAffine>>::Representative>
fn mul(
self,
rhs: &'b Transform<N, D, C>
) -> <&'a Rotation<N, D> as Mul<&'b Transform<N, D, C>>>::Output
[src]
self,
rhs: &'b Transform<N, D, C>
) -> <&'a Rotation<N, D> as Mul<&'b Transform<N, D, C>>>::Output
impl<'b, N, D> Mul<&'b Isometry<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Isometry<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<&'b Isometry<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Isometry<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<&'b Isometry<N, D, Rotation<N, D>>>>::Output
impl<'b, N, D> Mul<&'b Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn mul(
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<&'b Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: &'b Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<&'b Similarity<N, D, Rotation<N, D>>>>::Output
impl<N, D> Mul<Point<N, D>> for Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = Point<N, D>
fn mul(self, right: Point<N, D>) -> <Rotation<N, D> as Mul<Point<N, D>>>::Output
[src]
impl<N, D> Mul<Similarity<N, D, Rotation<N, D>>> for Rotation<N, D> where
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: DimName,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
type Output = Similarity<N, D, Rotation<N, D>>
fn mul(
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<Similarity<N, D, Rotation<N, D>>>>::Output
[src]
self,
right: Similarity<N, D, Rotation<N, D>>
) -> <Rotation<N, D> as Mul<Similarity<N, D, Rotation<N, D>>>>::Output
impl<'a, N, D> Mul<Point<N, D>> for &'a Rotation<N, D> where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = Point<N, D>
fn mul(
self,
right: Point<N, D>
) -> <&'a Rotation<N, D> as Mul<Point<N, D>>>::Output
[src]
self,
right: Point<N, D>
) -> <&'a Rotation<N, D> as Mul<Point<N, D>>>::Output
impl<N, D> Display for Rotation<N, D> where
D: DimName,
N: Real + Display,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<usize, D, D>,
[src]
D: DimName,
N: Real + Display,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<usize, D, D>,