Type Definition nalgebra::geometry::UnitComplex

type UnitComplex<N> = Unit<Complex<N>>;

A complex number with a norm equal to 1.

Methods

impl<N: Real> UnitComplex<N>

fn angle(&self) -> N

The rotation angle in ]-pi; pi] of this unit complex number.

fn sin_angle(&self) -> N

The sine of the rotation angle.

fn cos_angle(&self) -> N

The cosine of the rotation angle.

fn scaled_axis(&self) -> Vector1<N>

The rotation angle returned as a 1-dimensional vector.

fn complex(&self) -> &Complex<N>

The underlying complex number.

Same as self.as_ref().

fn conjugate(&self) -> Self

Compute the conjugate of this unit complex number.

fn inverse(&self) -> Self

Inverts this complex number if it is not zero.

fn angle_to(&self, other: &Self) -> N

The rotation angle needed to make self and other coincide.

fn rotation_to(&self, other: &Self) -> Self

The unit complex number needed to make self and other coincide.

The result is such that: self.rotation_to(other) * self == other.

fn conjugate_mut(&mut self)

Compute in-place the conjugate of this unit complex number.

fn inverse_mut(&mut self)

Inverts in-place this unit complex number.

fn powf(&self, n: N) -> Self

Raise this unit complex number to a given floating power.

This returns the unit complex number that identifies a rotation angle equal to self.angle() × n.

fn to_rotation_matrix(&self) -> Rotation2<N>

Builds the rotation matrix corresponding to this unit complex number.

fn to_homogeneous(&self) -> Matrix3<N>

Converts this unit complex number into its equivalent homogeneous transformation matrix.

impl<N: Real> UnitComplex<N>

fn identity() -> Self

The unit complex number multiplicative identity.

fn new(angle: N) -> Self

Builds the unit complex number corresponding to the rotation with the angle.

fn from_angle(angle: N) -> Self

Builds the unit complex number corresponding to the rotation with the angle.

Same as Self::new(angle).

fn from_cos_sin_unchecked(cos: N, sin: N) -> Self

Builds the unit complex number frow the sinus and cosinus of the rotation angle.

The input values are not checked.

fn from_scaled_axis<SB: Storage<N, U1, U1>>(
    axisangle: Vector<N, U1, SB>
) -> Self

Builds a unit complex rotation from an angle in radian wrapped in a 1-dimensional vector.

Equivalent to Self::new(axisangle[0]).

fn from_complex(q: Complex<N>) -> Self

Creates a new unit complex number from a complex number.

The input complex number will be normalized.

fn from_complex_and_get(q: Complex<N>) -> (Self, N)

Creates a new unit complex number from a complex number.

The input complex number will be normalized. Returns the complex number norm as well.

fn from_rotation_matrix(rotmat: &Rotation<N, U2>) -> Self where
    DefaultAllocator: Allocator<N, U2, U2>, 

Builds the unit complex number from the corresponding 2D rotation matrix.

fn rotation_between<SB, SC>(
    a: &Vector<N, U2, SB>,
    b: &Vector<N, U2, SC>
) -> Self where
    SB: Storage<N, U2, U1>,
    SC: Storage<N, U2, U1>, 

The unit complex needed to make a and b be collinear and point toward the same direction.

fn scaled_rotation_between<SB, SC>(
    a: &Vector<N, U2, SB>,
    b: &Vector<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: Real> UnitComplex<N>

fn rotate<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
    &self,
    rhs: &mut Matrix<N, R2, C2, S2>
) where
    ShapeConstraint: DimEq<R2, U2>, 

Performs the multiplication rhs = self * rhs in-place.

fn rotate_rows<R2: Dim, C2: Dim, S2: StorageMut<N, R2, C2>>(
    &self,
    lhs: &mut Matrix<N, R2, C2, S2>
) where
    ShapeConstraint: DimEq<C2, U2>, 

Performs the multiplication lhs = lhs * self in-place.

Trait Implementations

impl<N: Real + Display> Display for UnitComplex<N>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<N: Real> ApproxEq for UnitComplex<N>

type Epsilon = N

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn default_max_relative() -> Self::Epsilon

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

fn default_max_ulps() -> u32

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

fn relative_eq(
    &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

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: Real> One for UnitComplex<N>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

impl<N: Real + Rand> Rand for UnitComplex<N>

fn rand<R: Rng>(rng: &mut R) -> Self

Generates a random instance of this type using the specified source of randomness.

impl<N: Real> Mul<UnitComplex<N>> for UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitComplex<N>) -> UnitComplex<N>

Performs the * operation.

impl<'a, N: Real> Mul<UnitComplex<N>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: UnitComplex<N>) -> UnitComplex<N>

Performs the * operation.

impl<'b, N: Real> Mul<&'b UnitComplex<N>> for UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> UnitComplex<N>

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b UnitComplex<N>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b UnitComplex<N>) -> UnitComplex<N>

Performs the * operation.

impl<N: Real> Div<UnitComplex<N>> for UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitComplex<N>) -> UnitComplex<N>

Performs the / operation.

impl<'a, N: Real> Div<UnitComplex<N>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: UnitComplex<N>) -> UnitComplex<N>

Performs the / operation.

impl<'b, N: Real> Div<&'b UnitComplex<N>> for UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> UnitComplex<N>

Performs the / operation.

impl<'a, 'b, N: Real> Div<&'b UnitComplex<N>> for &'a UnitComplex<N>

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b UnitComplex<N>) -> UnitComplex<N>

Performs the / operation.

impl<N: Real> Mul<Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotation<N, U2>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Rotation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Rotation<N, U2>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Rotation<N, U2>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Rotation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Rotation<N, U2>) -> Self::Output

Performs the * operation.

impl<N: Real> Div<Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotation<N, U2>) -> Self::Output

Performs the / operation.

impl<'a, N: Real> Div<Rotation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: Rotation<N, U2>) -> Self::Output

Performs the / operation.

impl<'b, N: Real> Div<&'b Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rotation<N, U2>) -> Self::Output

Performs the / operation.

impl<'a, 'b, N: Real> Div<&'b Rotation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

type Output = UnitComplex<N>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Rotation<N, U2>) -> Self::Output

Performs the / operation.

impl<N: Real> Mul<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Point2<N>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Point2<N>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Point2<N>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point2<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Point2<N>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point2<N>) -> Self::Output

Performs the * operation.

impl<N: Real, S: Storage<N, U2>> Mul<Vector<N, U2, S>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Vector2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<N, U2, S>) -> Self::Output

Performs the * operation.

impl<'a, N: Real, S: Storage<N, U2>> Mul<Vector<N, U2, S>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Vector2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<N, U2, S>) -> Self::Output

Performs the * operation.

impl<'b, N: Real, S: Storage<N, U2>> Mul<&'b Vector<N, U2, S>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Vector2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Vector<N, U2, S>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real, S: Storage<N, U2>> Mul<&'b Vector<N, U2, S>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Vector2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Vector<N, U2, S>) -> Self::Output

Performs the * operation.

impl<N: Real, S: Storage<N, U2>> Mul<Unit<Vector<N, U2, S>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'a, N: Real, S: Storage<N, U2>> Mul<Unit<Vector<N, U2, S>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real, S: Storage<N, U2>> Mul<&'b Unit<Vector<N, U2, S>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real, S: Storage<N, U2>> Mul<&'b Unit<Vector<N, U2, S>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Unit<Vector2<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Unit<Vector<N, U2, S>>) -> Self::Output

Performs the * operation.

impl<N: Real> Mul<Isometry<N, U2, UnitComplex<N>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: Isometry<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Isometry<N, U2, UnitComplex<N>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: Isometry<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Isometry<N, U2, UnitComplex<N>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Isometry<N, U2, UnitComplex<N>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Real> Mul<Similarity<N, U2, UnitComplex<N>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Similarity<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Similarity<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Similarity<N, U2, UnitComplex<N>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Similarity<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: Similarity<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Similarity<N, U2, UnitComplex<N>>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Similarity<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Similarity<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Similarity<N, U2, UnitComplex<N>>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Similarity<N, U2, UnitComplex<N>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Similarity<N, U2, UnitComplex<N>>) -> Self::Output

Performs the * operation.

impl<N: Real> Mul<Translation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: Translation<N, U2>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Translation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: Translation<N, U2>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Translation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Translation<N, U2>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Translation<N, U2>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

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

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Translation<N, U2>) -> Self::Output

Performs the * operation.

impl<N: Real> MulAssign<UnitComplex<N>> for UnitComplex<N>

fn mul_assign(&mut self, rhs: UnitComplex<N>)

Performs the *= operation.

impl<'b, N: Real> MulAssign<&'b UnitComplex<N>> for UnitComplex<N>

fn mul_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the *= operation.

impl<N: Real> DivAssign<UnitComplex<N>> for UnitComplex<N>

fn div_assign(&mut self, rhs: UnitComplex<N>)

Performs the /= operation.

impl<'b, N: Real> DivAssign<&'b UnitComplex<N>> for UnitComplex<N>

fn div_assign(&mut self, rhs: &'b UnitComplex<N>)

Performs the /= operation.

impl<N: Real> MulAssign<Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn mul_assign(&mut self, rhs: Rotation<N, U2>)

Performs the *= operation.

impl<'b, N: Real> MulAssign<&'b Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn mul_assign(&mut self, rhs: &'b Rotation<N, U2>)

Performs the *= operation.

impl<N: Real> DivAssign<Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn div_assign(&mut self, rhs: Rotation<N, U2>)

Performs the /= operation.

impl<'b, N: Real> DivAssign<&'b Rotation<N, U2>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U2>, 

fn div_assign(&mut self, rhs: &'b Rotation<N, U2>)

Performs the /= operation.

impl<N: Real> Identity<Multiplicative> for UnitComplex<N>

fn identity() -> Self

The identity element.

fn id(O) -> Self

Specific identity.

impl<N: Real> AbstractMagma<Multiplicative> for UnitComplex<N>

fn operate(&self, rhs: &Self) -> Self

Performs an operation.

fn op(&self, O, lhs: &Self) -> Self

Performs specific operation.

impl<N: Real> Inverse<Multiplicative> for UnitComplex<N>

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: Real> AbstractSemigroup<Multiplicative> for UnitComplex<N>

fn prop_is_associative_approx(args: (Self, Self, Self)) -> bool where
    Self: ApproxEq, 

Returns true if associativity holds for the given arguments. Approximate equality is used for verifications.

fn prop_is_associative(args: (Self, Self, Self)) -> bool where
    Self: Eq, 

Returns true if associativity holds for the given arguments.

impl<N: Real> AbstractQuasigroup<Multiplicative> for UnitComplex<N>

fn prop_inv_is_latin_square_approx(args: (Self, Self)) -> bool where
    Self: ApproxEq, 

Returns true if latin squareness holds for the given arguments. Approximate equality is used for verifications.

fn prop_inv_is_latin_square(args: (Self, Self)) -> bool where
    Self: Eq, 

Returns true if latin squareness holds for the given arguments.

impl<N: Real> AbstractMonoid<Multiplicative> for UnitComplex<N>

fn prop_operating_identity_element_is_noop_approx(args: (Self,)) -> bool where
    Self: ApproxEq, 

Checks whether operating with the identity element is a no-op for the given argument. Approximate equality is used for verifications.

fn prop_operating_identity_element_is_noop(args: (Self,)) -> bool where
    Self: Eq, 

Checks whether operating with the identity element is a no-op for the given argument.

impl<N: Real> AbstractLoop<Multiplicative> for UnitComplex<N>

impl<N: Real> AbstractGroup<Multiplicative> for UnitComplex<N>

impl<N: Real> Transformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn transform_point(&self, pt: &Point2<N>) -> Point2<N>

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

fn transform_vector(&self, v: &Vector2<N>) -> Vector2<N>

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

impl<N: Real> ProjectiveTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn inverse_transform_point(&self, pt: &Point2<N>) -> Point2<N>

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

fn inverse_transform_vector(&self, v: &Vector2<N>) -> Vector2<N>

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

impl<N: Real> AffineTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

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.

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.

impl<N: Real> Similarity<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

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

Applies this transformation's pure rotational part to a vector.

fn scale_vector(
    &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

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

Applies this transformation inverse's pure scaling part to a vector.

impl<N: Real> Isometry<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> DirectIsometry<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> OrthogonalTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> Rotation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn powf(&self, n: 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.

fn rotation_between(a: &Vector2<N>, b: &Vector2<N>) -> 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.

fn scaled_rotation_between(a: &Vector2<N>, b: &Vector2<N>, s: N) -> Option<Self>

Computes the rotation between a and b and raises it to the power n.

impl<N1, N2> SubsetOf<UnitComplex<N2>> for UnitComplex<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 

fn to_superset(&self) -> UnitComplex<N2>

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

fn is_in_subset(uq: &UnitComplex<N2>) -> bool

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

unsafe fn from_superset_unchecked(uq: &UnitComplex<N2>) -> 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.

impl<N1, N2> SubsetOf<Rotation2<N2>> for UnitComplex<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 

fn to_superset(&self) -> Rotation2<N2>

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

fn is_in_subset(rot: &Rotation2<N2>) -> bool

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

unsafe fn from_superset_unchecked(rot: &Rotation2<N2>) -> 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.

impl<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for UnitComplex<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R: AlgaRotation<Point2<N2>> + SupersetOf<UnitComplex<N1>>, 

fn to_superset(&self) -> Isometry<N2, U2, R>

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

fn is_in_subset(iso: &Isometry<N2, U2, R>) -> bool

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

unsafe fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Self

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.

impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for UnitComplex<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    R: AlgaRotation<Point2<N2>> + SupersetOf<UnitComplex<N1>>, 

fn to_superset(&self) -> Similarity<N2, U2, R>

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

fn is_in_subset(sim: &Similarity<N2, U2, R>) -> bool

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

unsafe fn from_superset_unchecked(sim: &Similarity<N2, U2, 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.

impl<N1, N2, C> SubsetOf<Transform<N2, U2, C>> for UnitComplex<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>,
    C: SuperTCategoryOf<TAffine>, 

fn to_superset(&self) -> Transform<N2, U2, C>

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

fn is_in_subset(t: &Transform<N2, U2, C>) -> bool

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

unsafe fn from_superset_unchecked(t: &Transform<N2, U2, 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.

impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix3<N2>> for UnitComplex<N1>

fn to_superset(&self) -> Matrix3<N2>

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

fn is_in_subset(m: &Matrix3<N2>) -> bool

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

unsafe fn from_superset_unchecked(m: &Matrix3<N2>) -> 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.