Struct nalgebra::geometry::RotationBase
[−]
[src]
#[repr(C)]pub struct RotationBase<N: Scalar, D: DimName, S> { /* fields omitted */ }
A rotation matrix.
Methods
impl<N: Scalar, D: DimName, S: Storage<N, D, D>> RotationBase<N, D, S> where
N: Scalar,
S: Storage<N, D, D>,
[src]
N: Scalar,
S: Storage<N, D, D>,
fn matrix(&self) -> &SquareMatrix<N, D, S>
A reference to the underlying matrix representation of this rotation.
unsafe fn matrix_mut(&mut self) -> &mut SquareMatrix<N, D, S>
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) -> SquareMatrix<N, D, S>
Unwraps the underlying matrix.
fn to_homogeneous(&self) -> OwnedSquareMatrix<N, DimNameSum<D, U1>, S::Alloc> where
N: Zero + One,
D: DimNameAdd<U1>,
S::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
N: Zero + One,
D: DimNameAdd<U1>,
S::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
Converts this rotation into its equivalent homogeneous transformation matrix.
impl<N: Scalar, D: DimName, S: Storage<N, D, D>> RotationBase<N, D, S>
[src]
fn from_matrix_unchecked(matrix: SquareMatrix<N, D, S>) -> RotationBase<N, D, S>
Creates a new rotation from the given square matrix.
The matrix squareness is checked but not its orthonormality.
fn transpose(&self) -> OwnedRotation<N, D, S::Alloc>
Transposes self
.
fn inverse(&self) -> OwnedRotation<N, D, S::Alloc>
Inverts self
.
impl<N: Scalar, D: DimName, S: StorageMut<N, D, D>> RotationBase<N, D, S>
[src]
fn transpose_mut(&mut self)
Transposes self
in-place.
fn inverse_mut(&mut self)
Inverts self
in-place.
impl<N, D: DimName, S> RotationBase<N, D, S> where
N: Scalar + Zero + One,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Scalar + Zero + One,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn identity() -> RotationBase<N, D, S>
Creates a new square identity rotation of the given dimension
.
impl<N, S> RotationBase<N, U2, S> where
N: Real,
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
N: Real,
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn new(angle: N) -> Self
Builds a 2 dimensional rotation matrix from an angle in radian.
fn from_scaled_axis<SB: Storage<N, U1, U1>>(
axisangle: ColumnVector<N, U1, SB>
) -> Self
axisangle: ColumnVector<N, U1, SB>
) -> Self
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: &ColumnVector<N, U2, SB>,
b: &ColumnVector<N, U2, SC>
) -> Self where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
a: &ColumnVector<N, U2, SB>,
b: &ColumnVector<N, U2, SC>
) -> Self 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: &ColumnVector<N, U2, SB>,
b: &ColumnVector<N, U2, SC>,
s: N
) -> Self where
SB: Storage<N, U2, U1>,
SC: Storage<N, U2, U1>,
a: &ColumnVector<N, U2, SB>,
b: &ColumnVector<N, U2, SC>,
s: N
) -> Self 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, S> RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
fn angle(&self) -> N
The rotation angle.
fn angle_to<SB: Storage<N, U2, U2>>(&self, other: &RotationBase<N, U2, SB>) -> N
The rotation angle needed to make self
and other
coincide.
fn rotation_to<SB>(
&self,
other: &RotationBase<N, U2, SB>
) -> OwnedRotation<N, U2, SB::Alloc> where
SB: Storage<N, U2, U2>,
&self,
other: &RotationBase<N, U2, SB>
) -> OwnedRotation<N, U2, SB::Alloc> where
SB: Storage<N, U2, U2>,
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) -> OwnedRotation<N, U2, S::Alloc>
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) -> OwnedColumnVector<N, U1, S::Alloc> where
S::Alloc: Allocator<N, U1, U1>,
S::Alloc: Allocator<N, U1, U1>,
The rotation angle returned as a 1-dimensional vector.
impl<N, S> RotationBase<N, U3, S> where
N: Real,
S: OwnedStorage<N, U3, U3>,
S::Alloc: OwnedAllocator<N, U3, U3, S>,
[src]
N: Real,
S: OwnedStorage<N, U3, U3>,
S::Alloc: OwnedAllocator<N, U3, U3, S>,
fn new<SB: Storage<N, U3, U1>>(axisangle: ColumnVector<N, U3, SB>) -> Self
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: Storage<N, U3, U1>>(
axisangle: ColumnVector<N, U3, SB>
) -> Self
axisangle: ColumnVector<N, U3, SB>
) -> Self
Builds a 3D rotation matrix from an axis scaled by the rotation angle.
fn from_axis_angle<SB>(axis: &Unit<ColumnVector<N, U3, SB>>, angle: N) -> Self where
SB: Storage<N, U3, U1>,
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) -> Self
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: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
dir: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self 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: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
dir: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self 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: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
dir: &ColumnVector<N, U3, SB>,
up: &ColumnVector<N, U3, SC>
) -> Self 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: &ColumnVector<N, U3, SB>,
b: &ColumnVector<N, U3, SC>
) -> Option<Self> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
a: &ColumnVector<N, U3, SB>,
b: &ColumnVector<N, U3, SC>
) -> Option<Self> 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: &ColumnVector<N, U3, SB>,
b: &ColumnVector<N, U3, SC>,
n: N
) -> Option<Self> where
SB: Storage<N, U3, U1>,
SC: Storage<N, U3, U1>,
a: &ColumnVector<N, U3, SB>,
b: &ColumnVector<N, U3, SC>,
n: N
) -> Option<Self> 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
.
impl<N, S> RotationBase<N, U3, S> where
N: Real,
S: Storage<N, U3, U3>,
[src]
N: Real,
S: Storage<N, U3, U3>,
fn angle(&self) -> N
The rotation angle.
impl<N, S> RotationBase<N, U3, S> where
N: Real,
S: Storage<N, U3, U3>,
S::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
S: Storage<N, U3, U3>,
S::Alloc: Allocator<N, U3, U1>,
fn axis(&self) -> Option<Unit<OwnedColumnVector<N, U3, S::Alloc>>>
The rotation axis. Returns None
if the rotation angle is zero or PI.
fn scaled_axis(&self) -> OwnedColumnVector<N, U3, S::Alloc>
The rotation axis multiplied by the rotation angle.
fn angle_to<SB: Storage<N, U3, U3>>(&self, other: &RotationBase<N, U3, SB>) -> N
The rotation angle needed to make self
and other
coincide.
fn rotation_to<SB>(
&self,
other: &RotationBase<N, U3, SB>
) -> OwnedRotation<N, U3, SB::Alloc> where
SB: Storage<N, U3, U3>,
&self,
other: &RotationBase<N, U3, SB>
) -> OwnedRotation<N, U3, SB::Alloc> where
SB: Storage<N, U3, U3>,
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) -> OwnedRotation<N, U3, S::Alloc>
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: Hash + Scalar, D: Hash + DimName, S: Hash> Hash for RotationBase<N, D, S>
[src]
fn hash<__HNDS: Hasher>(&self, __arg_0: &mut __HNDS)
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<N: Debug + Scalar, D: Debug + DimName, S: Debug> Debug for RotationBase<N, D, S>
[src]
impl<N: Clone + Scalar, D: Clone + DimName, S: Clone> Clone for RotationBase<N, D, S>
[src]
fn clone(&self) -> RotationBase<N, D, S>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<N: Copy + Scalar, D: Copy + DimName, S: Copy> Copy for RotationBase<N, D, S>
[src]
impl<N: Scalar + Eq, D: DimName, S: Storage<N, D, D>> Eq for RotationBase<N, D, S>
[src]
impl<N: Scalar + PartialEq, D: DimName, S: Storage<N, D, D>> PartialEq for RotationBase<N, D, S>
[src]
fn eq(&self, right: &RotationBase<N, D, S>) -> bool
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
This method tests for !=
.
impl<N, D: DimName, S> ApproxEq for RotationBase<N, D, S> where
N: Scalar + ApproxEq,
S: Storage<N, D, D>,
N::Epsilon: Copy,
[src]
N: Scalar + ApproxEq,
S: Storage<N, D, D>,
N::Epsilon: Copy,
type Epsilon = N::Epsilon
Used for specifying relative comparisons.
fn default_epsilon() -> Self::Epsilon
The default tolerance to use when testing values that are close together. Read more
fn default_max_relative() -> Self::Epsilon
The default relative tolerance for testing values that are far-apart. Read more
fn default_max_ulps() -> u32
The default ULPs to tolerate when testing values that are far-apart. Read more
fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
A test for equality that uses a relative comparison if the values are far apart.
fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
A test for equality that uses units in the last place (ULP) if the values are far apart.
fn relative_ne(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of ApproxEq::relative_eq
.
fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
The inverse of ApproxEq::ulps_eq
.
impl<N, D: DimName, S> Display for RotationBase<N, D, S> where
N: Real + Display,
S: Storage<N, D, D>,
S::Alloc: Allocator<usize, D, D>,
[src]
N: Real + Display,
S: Storage<N, D, D>,
S::Alloc: Allocator<usize, D, D>,
impl<N, D: DimName, S> One for RotationBase<N, D, S> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
impl<N: Scalar, D: DimName, S: Storage<N, D, D>> Index<(usize, usize)> for RotationBase<N, D, S>
[src]
type Output = N
The returned type after indexing
fn index(&self, row_col: (usize, usize)) -> &N
The method for the indexing (container[index]
) operation
impl<N, D: DimName, SA, SB> Mul<RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the *
operator
fn mul(self, right: RotationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimName, SA, SB> Mul<RotationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the *
operator
fn mul(self, right: RotationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimName, SA, SB> Mul<&'b RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the *
operator
fn mul(self, right: &'b RotationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimName, SA, SB> Mul<&'b RotationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the *
operator
fn mul(self, right: &'b RotationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> Div<RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the /
operator
fn div(self, right: RotationBase<N, D, SB>) -> Self::Output
The method for the /
operator
impl<'a, N, D: DimName, SA, SB> Div<RotationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the /
operator
fn div(self, right: RotationBase<N, D, SB>) -> Self::Output
The method for the /
operator
impl<'b, N, D: DimName, SA, SB> Div<&'b RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the /
operator
fn div(self, right: &'b RotationBase<N, D, SB>) -> Self::Output
The method for the /
operator
impl<'a, 'b, N, D: DimName, SA, SB> Div<&'b RotationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, D>,
type Output = OwnedRotation<N, D, SA::Alloc>
The resulting type after applying the /
operator
fn div(self, right: &'b RotationBase<N, D, SB>) -> Self::Output
The method for the /
operator
impl<N, D1: DimName, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for RotationBase<N, D1, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMul<N, D1, D1, C2, SA>
The resulting type after applying the *
operator
fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output
The method for the *
operator
impl<'a, N, D1: DimName, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a RotationBase<N, D1, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMul<N, D1, D1, C2, SA>
The resulting type after applying the *
operator
fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output
The method for the *
operator
impl<'b, N, D1: DimName, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for RotationBase<N, D1, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMul<N, D1, D1, C2, SA>
The resulting type after applying the *
operator
fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D1: DimName, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a RotationBase<N, D1, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D1, D1>,
SB: Storage<N, R2, C2>,
SA::Alloc: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMul<N, D1, D1, C2, SA>
The resulting type after applying the *
operator
fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> Mul<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = PointMul<N, D, D, SA>
The resulting type after applying the *
operator
fn mul(self, right: PointBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimName, SA, SB> Mul<PointBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = PointMul<N, D, D, SA>
The resulting type after applying the *
operator
fn mul(self, right: PointBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimName, SA, SB> Mul<&'b PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = PointMul<N, D, D, SA>
The resulting type after applying the *
operator
fn mul(self, right: &'b PointBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimName, SA, SB> Mul<&'b PointBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: Storage<N, D, D>,
SB: Storage<N, D, U1>,
SA::Alloc: Allocator<N, D, U1>,
ShapeConstraint: AreMultipliable<D, D, D, U1>,
type Output = PointMul<N, D, D, SA>
The resulting type after applying the *
operator
fn mul(self, right: &'b PointBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> MulAssign<RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
fn mul_assign(&mut self, right: RotationBase<N, D, SB>)
The method for the *=
operator
impl<'b, N, D: DimName, SA, SB> MulAssign<&'b RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
fn mul_assign(&mut self, right: &'b RotationBase<N, D, SB>)
The method for the *=
operator
impl<N, D: DimName, SA, SB> DivAssign<RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
fn div_assign(&mut self, right: RotationBase<N, D, SB>)
The method for the /=
operator
impl<'b, N, D: DimName, SA, SB> DivAssign<&'b RotationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
SA: OwnedStorage<N, D, D>,
SB: Storage<N, D, D>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
fn div_assign(&mut self, right: &'b RotationBase<N, D, SB>)
The method for the /=
operator
impl<N, D: DimName, S> Identity<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn identity() -> Self
The identity element.
impl<N, D: DimName, S> Inverse<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn inverse(&self) -> Self
Returns the inverse of self
, relative to the operator O
.
fn inverse_mut(&mut self)
In-place inversin of self
.
impl<N, D: DimName, S> AbstractMagma<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn operate(&self, rhs: &Self) -> Self
Performs an operation.
fn op(&self, O, lhs: &Self) -> Self
Performs specific operation.
impl<N, D: DimName, S> AbstractSemigroup<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
Self: ApproxEq,
Self: ApproxEq,
Returns true
if associativity holds for the given arguments. Approximate equality is used for verifications. Read more
fn prop_is_associative(args: (Self, Self, Self)) -> bool where
Self: Eq,
Self: Eq,
Returns true
if associativity holds for the given arguments.
impl<N, D: DimName, S> AbstractMonoid<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn prop_operating_identity_element_is_noop_approx(a: Self) -> bool where
Self: ApproxEq,
Self: ApproxEq,
Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications. Read more
fn prop_operating_identity_element_is_noop(a: Self) -> bool where
Self: Eq,
Self: Eq,
Checks whether operating with the identity element is a no-op for the given argument. Read more
impl<N, D: DimName, S> AbstractQuasigroup<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
Self: ApproxEq,
Self: ApproxEq,
Returns true
if latin squareness holds for the given arguments. Approximate equality is used for verifications. Read more
fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where
Self: Eq,
Self: Eq,
Returns true
if latin squareness holds for the given arguments.
impl<N, D: DimName, S> AbstractLoop<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
impl<N, D: DimName, S> AbstractGroup<Multiplicative> for RotationBase<N, D, S> where
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
[src]
N: Real,
S: OwnedStorage<N, D, D>,
S::Alloc: OwnedAllocator<N, D, D, S>,
impl<N, D: DimName, SA, SB> Transformation<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
fn transform_point(&self, pt: &PointBase<N, D, SB>) -> PointBase<N, D, SB>
Applies this group's action on a point from the euclidean space.
fn transform_vector(&self, v: &ColumnVector<N, D, SB>) -> ColumnVector<N, D, SB>
Applies this group's action on a vector from the euclidean space. Read more
impl<N, D: DimName, SA, SB> ProjectiveTransformation<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
fn inverse_transform_point(
&self,
pt: &PointBase<N, D, SB>
) -> PointBase<N, D, SB>
&self,
pt: &PointBase<N, D, SB>
) -> PointBase<N, D, SB>
Applies this group's inverse action on a point from the euclidean space.
fn inverse_transform_vector(
&self,
v: &ColumnVector<N, D, SB>
) -> ColumnVector<N, D, SB>
&self,
v: &ColumnVector<N, D, SB>
) -> ColumnVector<N, D, SB>
Applies this group's inverse action on a vector from the euclidean space. Read more
impl<N, D: DimName, SA, SB> AffineTransformation<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Rotation = Self
Type of the first rotation to be applied.
type NonUniformScaling = Id
Type of the non-uniform scaling to be applied.
type Translation = Id
The type of the pure translation part of this affine transformation.
fn decompose(&self) -> (Id, Self, Id, Self)
Decomposes this affine transformation into a rotation followed by a non-uniform scaling, followed by a rotation, followed by a translation. Read more
fn append_translation(&self, _: &Self::Translation) -> Self
Appends a translation to this similarity.
fn prepend_translation(&self, _: &Self::Translation) -> Self
Prepends a translation to this similarity.
fn append_rotation(&self, r: &Self::Rotation) -> Self
Appends a rotation to this similarity.
fn prepend_rotation(&self, r: &Self::Rotation) -> Self
Prepends a rotation to this similarity.
fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self
Appends a scaling factor to this similarity.
fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self
Prepends a scaling factor to this similarity.
fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>
Appends to this similarity a rotation centered at the point p
, i.e., this point is left invariant. Read more
impl<N, D: DimName, SA, SB> Similarity<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Scaling = Id
The type of the pure (uniform) scaling part of this similarity transformation.
fn translation(&self) -> Id
The pure translational component of this similarity transformation.
fn rotation(&self) -> Self
The pure rotational component of this similarity transformation.
fn scaling(&self) -> Id
The pure scaling component of this similarity transformation.
fn translate_point(&self, pt: &E) -> E
Applies this transformation's pure translational part to a point.
fn rotate_point(&self, pt: &E) -> E
Applies this transformation's pure rotational part to a point.
fn scale_point(&self, pt: &E) -> E
Applies this transformation's pure scaling part to a point.
fn rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation's pure rotational part to a vector.
fn scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation's pure scaling part to a vector.
fn inverse_translate_point(&self, pt: &E) -> E
Applies this transformation inverse's pure translational part to a point.
fn inverse_rotate_point(&self, pt: &E) -> E
Applies this transformation inverse's pure rotational part to a point.
fn inverse_scale_point(&self, pt: &E) -> E
Applies this transformation inverse's pure scaling part to a point.
fn inverse_rotate_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation inverse's pure rotational part to a vector.
fn inverse_scale_vector(
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
&self,
pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
Applies this transformation inverse's pure scaling part to a vector.
impl<N, D: DimName, SA, SB> Isometry<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
impl<N, D: DimName, SA, SB> DirectIsometry<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
impl<N, D: DimName, SA, SB> OrthogonalTransformation<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
impl<N, D: DimName, SA, SB> Rotation<PointBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
Subgroups of the n-dimensional rotation group SO(n)
.
fn powf(&self, _: N) -> Option<Self>
Raises this rotation to a power. If this is a simple rotation, the result must be equivalent to multiplying the rotation angle by n
. Read more
fn rotation_between(
_: &ColumnVector<N, D, SB>,
_: &ColumnVector<N, D, SB>
) -> Option<Self>
_: &ColumnVector<N, D, SB>,
_: &ColumnVector<N, D, SB>
) -> Option<Self>
Computes a simple rotation that makes the angle between a
and b
equal to zero, i.e., b.angle(a * delta_rotation(a, b)) = 0
. If a
and b
are collinear, the computed rotation may not be unique. Returns None
if no such simple rotation exists in the subgroup represented by Self
. Read more
fn scaled_rotation_between(
_: &ColumnVector<N, D, SB>,
_: &ColumnVector<N, D, SB>,
_: N
) -> Option<Self>
_: &ColumnVector<N, D, SB>,
_: &ColumnVector<N, D, SB>,
_: N
) -> Option<Self>
Computes the rotation between a
and b
and raises it to the power n
. Read more
impl<N1, N2, D: DimName, SA, SB> SubsetOf<RotationBase<N2, D, SB>> for RotationBase<N1, D, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, D>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, D, SB>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, D>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, D, SB>,
fn to_superset(&self) -> RotationBase<N2, D, SB>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(rot: &RotationBase<N2, D, SB>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(rot: &RotationBase<N2, D, SB>) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, SA, SB> SubsetOf<UnitQuaternionBase<N2, SB>> for RotationBase<N1, U3, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, U3, U3>,
SB: OwnedStorage<N2, U4, U1>,
SA::Alloc: OwnedAllocator<N1, U3, U3, SA> + Allocator<N1, U4, U1> + Allocator<N1, U3, U1>,
SB::Alloc: OwnedAllocator<N2, U4, U1, SB> + Allocator<N2, U3, U3>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, U3, U3>,
SB: OwnedStorage<N2, U4, U1>,
SA::Alloc: OwnedAllocator<N1, U3, U3, SA> + Allocator<N1, U4, U1> + Allocator<N1, U3, U1>,
SB::Alloc: OwnedAllocator<N2, U4, U1, SB> + Allocator<N2, U3, U3>,
fn to_superset(&self) -> UnitQuaternionBase<N2, SB>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(q: &UnitQuaternionBase<N2, SB>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(q: &UnitQuaternionBase<N2, SB>) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D: DimName, SA, SB, R> SubsetOf<IsometryBase<N2, D, SB, R>> for RotationBase<N1, D, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, U1>,
R: AlgaRotation<PointBase<N2, D, SB>> + SupersetOf<RotationBase<N1, D, SA>>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, U1, SB>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, U1>,
R: AlgaRotation<PointBase<N2, D, SB>> + SupersetOf<RotationBase<N1, D, SA>>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, U1, SB>,
fn to_superset(&self) -> IsometryBase<N2, D, SB, R>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(iso: &IsometryBase<N2, D, SB, R>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(iso: &IsometryBase<N2, D, SB, R>) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D: DimName, SA, SB, R> SubsetOf<SimilarityBase<N2, D, SB, R>> for RotationBase<N1, D, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, U1>,
R: AlgaRotation<PointBase<N2, D, SB>> + SupersetOf<RotationBase<N1, D, SA>>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, U1, SB>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, D, U1>,
R: AlgaRotation<PointBase<N2, D, SB>> + SupersetOf<RotationBase<N1, D, SA>>,
SA::Alloc: OwnedAllocator<N1, D, D, SA>,
SB::Alloc: OwnedAllocator<N2, D, U1, SB>,
fn to_superset(&self) -> SimilarityBase<N2, D, SB, R>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(sim: &SimilarityBase<N2, D, SB, R>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(sim: &SimilarityBase<N2, D, SB, R>) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D, SA, SB, C> SubsetOf<TransformBase<N2, D, SB, C>> for RotationBase<N1, D, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
C: SuperTCategoryOf<TAffine>,
D: DimNameAdd<U1>,
SA::Alloc: OwnedAllocator<N1, D, D, SA> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, U1, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
C: SuperTCategoryOf<TAffine>,
D: DimNameAdd<U1>,
SA::Alloc: OwnedAllocator<N1, D, D, SA> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, U1, D>,
fn to_superset(&self) -> TransformBase<N2, D, SB, C>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(t: &TransformBase<N2, D, SB, C>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(t: &TransformBase<N2, D, SB, C>) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N1, N2, D, SA, SB> SubsetOf<SquareMatrix<N2, DimNameSum<D, U1>, SB>> for RotationBase<N1, D, SA> where
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
D: DimNameAdd<U1>,
SA::Alloc: OwnedAllocator<N1, D, D, SA> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, U1, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
SA: OwnedStorage<N1, D, D>,
SB: OwnedStorage<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
D: DimNameAdd<U1>,
SA::Alloc: OwnedAllocator<N1, D, D, SA> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SB::Alloc: OwnedAllocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>, SB> + Allocator<N2, D, D> + Allocator<N2, U1, D>,
fn to_superset(&self) -> SquareMatrix<N2, DimNameSum<D, U1>, SB>
The inclusion map: converts self
to the equivalent element of its superset.
fn is_in_subset(m: &SquareMatrix<N2, DimNameSum<D, U1>, SB>) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
unsafe fn from_superset_unchecked(
m: &SquareMatrix<N2, DimNameSum<D, U1>, SB>
) -> Self
m: &SquareMatrix<N2, DimNameSum<D, U1>, SB>
) -> Self
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its superset. Read more
impl<N, S> Rand for RotationBase<N, U2, S> where
N: Real + Rand,
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
N: Real + Rand,
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn rand<R: Rng>(rng: &mut R) -> Self
Generates a random instance of this type using the specified source of randomness. Read more
impl<N, S> Rand for RotationBase<N, U3, S> where
N: Real + Rand,
S: OwnedStorage<N, U3, U3>,
S::Alloc: OwnedAllocator<N, U3, U3, S> + Allocator<N, U3, U1>,
[src]
N: Real + Rand,
S: OwnedStorage<N, U3, U3>,
S::Alloc: OwnedAllocator<N, U3, U3, S> + Allocator<N, U3, U1>,
fn rand<R: Rng>(rng: &mut R) -> Self
Generates a random instance of this type using the specified source of randomness. Read more
impl<'a, 'b, N, SA, SB> Mul<&'b UnitQuaternionBase<N, SB>> for &'a RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output
The method for the *
operator
impl<'a, N, SA, SB> Mul<UnitQuaternionBase<N, SB>> for &'a RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the *
operator
fn mul(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output
The method for the *
operator
impl<'b, N, SA, SB> Mul<&'b UnitQuaternionBase<N, SB>> for RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output
The method for the *
operator
impl<N, SA, SB> Mul<UnitQuaternionBase<N, SB>> for RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the *
operator
fn mul(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, SA, SB> Div<&'b UnitQuaternionBase<N, SB>> for &'a RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the /
operator
fn div(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output
The method for the /
operator
impl<'a, N, SA, SB> Div<UnitQuaternionBase<N, SB>> for &'a RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the /
operator
fn div(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output
The method for the /
operator
impl<'b, N, SA, SB> Div<&'b UnitQuaternionBase<N, SB>> for RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the /
operator
fn div(self, rhs: &'b UnitQuaternionBase<N, SB>) -> Self::Output
The method for the /
operator
impl<N, SA, SB> Div<UnitQuaternionBase<N, SB>> for RotationBase<N, U3, SA> where
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
[src]
N: Real,
SA: Storage<N, U3, U3>,
SB: Storage<N, U4, U1>,
SA::Alloc: Allocator<N, U3, U1>,
SB::Alloc: Allocator<N, U3, U1>,
type Output = OwnedUnitQuaternionBase<N, SB::Alloc>
The resulting type after applying the /
operator
fn div(self, rhs: UnitQuaternionBase<N, SB>) -> Self::Output
The method for the /
operator
impl<N, S> Mul<UnitComplex<N>> for RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator
fn mul(self, rhs: UnitComplex<N>) -> Self::Output
The method for the *
operator
impl<'a, N, S> Mul<UnitComplex<N>> for &'a RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator
fn mul(self, rhs: UnitComplex<N>) -> Self::Output
The method for the *
operator
impl<'b, N, S> Mul<&'b UnitComplex<N>> for RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, S> Mul<&'b UnitComplex<N>> for &'a RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b UnitComplex<N>) -> Self::Output
The method for the *
operator
impl<N, S> Div<UnitComplex<N>> for RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator
fn div(self, rhs: UnitComplex<N>) -> Self::Output
The method for the /
operator
impl<'a, N, S> Div<UnitComplex<N>> for &'a RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator
fn div(self, rhs: UnitComplex<N>) -> Self::Output
The method for the /
operator
impl<'b, N, S> Div<&'b UnitComplex<N>> for RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator
fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output
The method for the /
operator
impl<'a, 'b, N, S> Div<&'b UnitComplex<N>> for &'a RotationBase<N, U2, S> where
N: Real,
S: Storage<N, U2, U2>,
[src]
N: Real,
S: Storage<N, U2, U2>,
type Output = UnitComplex<N>
The resulting type after applying the /
operator
fn div(self, rhs: &'b UnitComplex<N>) -> Self::Output
The method for the /
operator
impl<N: Real, S> MulAssign<UnitComplex<N>> for RotationBase<N, U2, S> where
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn mul_assign(&mut self, rhs: UnitComplex<N>)
The method for the *=
operator
impl<'b, N: Real, S: Storage<N, U2, U2>> MulAssign<&'b UnitComplex<N>> for RotationBase<N, U2, S> where
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)
The method for the *=
operator
impl<N: Real, S> DivAssign<UnitComplex<N>> for RotationBase<N, U2, S> where
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn div_assign(&mut self, rhs: UnitComplex<N>)
The method for the /=
operator
impl<'b, N: Real, S: Storage<N, U2, U2>> DivAssign<&'b UnitComplex<N>> for RotationBase<N, U2, S> where
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
[src]
S: OwnedStorage<N, U2, U2>,
S::Alloc: OwnedAllocator<N, U2, U2, S>,
fn div_assign(&mut self, rhs: &'b UnitComplex<N>)
The method for the /=
operator
impl<N, D: DimName, SA, SB> Mul<TranslationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(self, right: TranslationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimName, SA, SB> Mul<TranslationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(self, right: TranslationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimName, SA, SB> Mul<&'b TranslationBase<N, D, SB>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(self, right: &'b TranslationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimName, SA, SB> Mul<&'b TranslationBase<N, D, SB>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(self, right: &'b TranslationBase<N, D, SB>) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> Mul<IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimName, SA, SB> Mul<IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimName, SA, SB> Mul<&'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimName, SA, SB> Mul<&'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> Div<IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'a, N, D: DimName, SA, SB> Div<IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'b, N, D: DimName, SA, SB> Div<&'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'a, 'b, N, D: DimName, SA, SB> Div<&'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = IsometryBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b IsometryBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<N, D: DimName, SA, SB> Mul<SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimName, SA, SB> Mul<SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimName, SA, SB> Mul<&'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimName, SA, SB> Mul<&'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the *
operator
fn mul(
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the *
operator
impl<N, D: DimName, SA, SB> Div<SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'a, N, D: DimName, SA, SB> Div<SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'b, N, D: DimName, SA, SB> Div<&'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<'a, 'b, N, D: DimName, SA, SB> Div<&'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>> for &'a RotationBase<N, D, SA> where
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
[src]
N: Real,
SA: OwnedStorage<N, D, D>,
SB: OwnedStorage<N, D, U1, Alloc = SA::Alloc>,
SA::Alloc: OwnedAllocator<N, D, D, SA>,
SB::Alloc: OwnedAllocator<N, D, U1, SB>,
type Output = SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
The resulting type after applying the /
operator
fn div(
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
self,
right: &'b SimilarityBase<N, D, SB, RotationBase<N, D, SA>>
) -> Self::Output
The method for the /
operator
impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<TransformBase<N, D, SB, C>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the *
operator
fn mul(self, rhs: TransformBase<N, D, SB, C>) -> Self::Output
The method for the *
operator
impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<TransformBase<N, D, SB, C>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the *
operator
fn mul(self, rhs: TransformBase<N, D, SB, C>) -> Self::Output
The method for the *
operator
impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b TransformBase<N, D, SB, C>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b TransformBase<N, D, SB, C>) -> Self::Output
The method for the *
operator
impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Mul<&'b TransformBase<N, D, SB, C>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the *
operator
fn mul(self, rhs: &'b TransformBase<N, D, SB, C>) -> Self::Output
The method for the *
operator
impl<N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<TransformBase<N, D, SB, C>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the /
operator
fn div(self, rhs: TransformBase<N, D, SB, C>) -> Self::Output
The method for the /
operator
impl<'a, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<TransformBase<N, D, SB, C>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the /
operator
fn div(self, rhs: TransformBase<N, D, SB, C>) -> Self::Output
The method for the /
operator
impl<'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b TransformBase<N, D, SB, C>> for RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the /
operator
fn div(self, rhs: &'b TransformBase<N, D, SB, C>) -> Self::Output
The method for the /
operator
impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategoryMul<TAffine>, SA, SB> Div<&'b TransformBase<N, D, SB, C>> for &'a RotationBase<N, D, SA> where
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul + One,
SA: Storage<N, D, D>,
SB: Storage<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
SA::Alloc: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>,
type Output = OwnedTransform<N, D, SA::Alloc, C::Representative>
The resulting type after applying the /
operator
fn div(self, rhs: &'b TransformBase<N, D, SB, C>) -> Self::Output
The method for the /
operator