Struct nalgebra::geometry::OPoint

#[repr(C)]
pub struct OPoint<T: Scalar, D: DimName>where
    DefaultAllocator: Allocator<T, D>,{
    pub coords: OVector<T, D>,
}

A point in an euclidean space.

The difference between a point and a vector is only semantic. See the user guide for details on the distinction. The most notable difference that vectors ignore translations. In particular, an Isometry2 or Isometry3 will transform points by applying a rotation and a translation on them. However, these isometries will only apply rotations to vectors (when doing isometry * vector, the translation part of the isometry is ignored).

Construction

• From individual components new…
• Swizzling xx, yxz…
• Other construction methods origin, from_slice, from_homogeneous…

Transformation

Transforming a point by an Isometry, rotation, etc. can be achieved by multiplication, e.g., isometry * point or rotation * point. Some of these transformation may have some other methods, e.g., isometry.inverse_transform_point(&point). See the documentation of said transformations for details.

Fields

coords: OVector<T, D>

The coordinates of this point, i.e., the shift from the origin.

Implementations

impl<T: Scalar, D: DimName> OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OPoint<T2, D>where
    DefaultAllocator: Allocator<T2, D>,

Returns a point containing the result of f applied to each of its entries.

Example

let p = Point2::new(1.0, 2.0);
assert_eq!(p.map(|e| e * 10.0), Point2::new(10.0, 20.0));

// This works in any dimension.
let p = Point3::new(1.1, 2.1, 3.1);
assert_eq!(p.map(|e| e as u32), Point3::new(1, 2, 3));

pub fn apply<F: FnMut(&mut T)>(&mut self, f: F)

Replaces each component of self by the result of a closure f applied on it.

Example

let mut p = Point2::new(1.0, 2.0);
p.apply(|e| *e = *e * 10.0);
assert_eq!(p, Point2::new(10.0, 20.0));

// This works in any dimension.
let mut p = Point3::new(1.0, 2.0, 3.0);
p.apply(|e| *e = *e * 10.0);
assert_eq!(p, Point3::new(10.0, 20.0, 30.0));

pub fn to_homogeneous(&self) -> OVector<T, DimNameSum<D, U1>>where
    T: One,
    D: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,

Converts this point into a vector in homogeneous coordinates, i.e., appends a 1 at the end of it.

This is the same as .into().

Example

let p = Point2::new(10.0, 20.0);
assert_eq!(p.to_homogeneous(), Vector3::new(10.0, 20.0, 1.0));

// This works in any dimension.
let p = Point3::new(10.0, 20.0, 30.0);
assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0));

pub fn from_coordinates(coords: OVector<T, D>) -> Self

👎Deprecated: Use Point::from(vector) instead.

Creates a new point with the given coordinates.

pub fn len(&self) -> usize

The dimension of this point.

Example

let p = Point2::new(1.0, 2.0);
assert_eq!(p.len(), 2);

// This works in any dimension.
let p = Point3::new(10.0, 20.0, 30.0);
assert_eq!(p.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the point contains no elements.

Example

let p = Point2::new(1.0, 2.0);
assert!(!p.is_empty());

pub fn stride(&self) -> usize

👎Deprecated: This methods is no longer significant and will always return 1.

The stride of this point. This is the number of buffer element separating each component of this point.

pub fn iter(
    &self
) -> MatrixIter<'_, T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>

Iterates through this point coordinates.

Example

let p = Point3::new(1.0, 2.0, 3.0);
let mut it = p.iter().cloned();

assert_eq!(it.next(), Some(1.0));
assert_eq!(it.next(), Some(2.0));
assert_eq!(it.next(), Some(3.0));
assert_eq!(it.next(), None);

pub unsafe fn get_unchecked(&self, i: usize) -> &T

Gets a reference to i-th element of this point without bound-checking.

pub fn iter_mut(
    &mut self
) -> MatrixIterMut<'_, T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>

Mutably iterates through this point coordinates.

Example

let mut p = Point3::new(1.0, 2.0, 3.0);

for e in p.iter_mut() {
    *e *= 10.0;
}

assert_eq!(p, Point3::new(10.0, 20.0, 30.0));

pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut T

Gets a mutable reference to i-th element of this point without bound-checking.

pub unsafe fn swap_unchecked(&mut self, i1: usize, i2: usize)

Swaps two entries without bound-checking.

impl<T: Scalar + SimdPartialOrd, D: DimName> OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

pub fn inf(&self, other: &Self) -> OPoint<T, D>

Computes the infimum (aka. componentwise min) of two points.

pub fn sup(&self, other: &Self) -> OPoint<T, D>

Computes the supremum (aka. componentwise max) of two points.

pub fn inf_sup(&self, other: &Self) -> (OPoint<T, D>, OPoint<T, D>)

Computes the (infimum, supremum) of two points.

impl<T: Scalar, D: DimName> OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

Other construction methods

pub fn origin() -> Selfwhere
    T: Zero,

Creates a new point with all coordinates equal to zero.

Example

// This works in any dimension.
// The explicit crate::<f32> type annotation may not always be needed,
// depending on the context of type inference.
let pt = Point2::<f32>::origin();
assert!(pt.x == 0.0 && pt.y == 0.0);

let pt = Point3::<f32>::origin();
assert!(pt.x == 0.0 && pt.y == 0.0 && pt.z == 0.0);

pub fn from_slice(components: &[T]) -> Self

Creates a new point from a slice.

Example

let data = [ 1.0, 2.0, 3.0 ];

let pt = Point2::from_slice(&data[..2]);
assert_eq!(pt, Point2::new(1.0, 2.0));

let pt = Point3::from_slice(&data);
assert_eq!(pt, Point3::new(1.0, 2.0, 3.0));

pub fn from_homogeneous(v: OVector<T, DimNameSum<D, U1>>) -> Option<Self>where
    T: Scalar + Zero + One + ClosedDiv,
    D: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,

Creates a new point from its homogeneous vector representation.

In practice, this builds a D-dimensional points with the same first D component as v divided by the last component of v. Returns None if this divisor is zero.

Example

let coords = Vector4::new(1.0, 2.0, 3.0, 1.0);
let pt = Point3::from_homogeneous(coords);
assert_eq!(pt, Some(Point3::new(1.0, 2.0, 3.0)));

// All component of the result will be divided by the
// last component of the vector, here 2.0.
let coords = Vector4::new(1.0, 2.0, 3.0, 2.0);
let pt = Point3::from_homogeneous(coords);
assert_eq!(pt, Some(Point3::new(0.5, 1.0, 1.5)));

// Fails because the last component is zero.
let coords = Vector4::new(1.0, 2.0, 3.0, 0.0);
let pt = Point3::from_homogeneous(coords);
assert!(pt.is_none());

// Works also in other dimensions.
let coords = Vector3::new(1.0, 2.0, 1.0);
let pt = Point2::from_homogeneous(coords);
assert_eq!(pt, Some(Point2::new(1.0, 2.0)));

pub fn cast<To: Scalar>(self) -> OPoint<To, D>where
    OPoint<To, D>: SupersetOf<Self>,
    DefaultAllocator: Allocator<To, D>,

Cast the components of self to another type.

Example

let pt = Point2::new(1.0f64, 2.0);
let pt2 = pt.cast::<f32>();
assert_eq!(pt2, Point2::new(1.0f32, 2.0));

impl<T: Scalar> OPoint<T, Const<1>>

Construction from individual components

pub fn new(x: T) -> Self

Initializes this point from its components.

Example

let p = Point1::new(1.0);
assert_eq!(p.x, 1.0);

impl<T: Scalar> OPoint<T, Const<2>>

pub fn new(x: T, y: T) -> Self

Initializes this point from its components.

Example

let p = Point2::new(1.0, 2.0);
assert!(p.x == 1.0 && p.y == 2.0);

impl<T: Scalar> OPoint<T, Const<3>>

pub fn new(x: T, y: T, z: T) -> Self

Initializes this point from its components.

Example

let p = Point3::new(1.0, 2.0, 3.0);
assert!(p.x == 1.0 && p.y == 2.0 && p.z == 3.0);

impl<T: Scalar> OPoint<T, Const<4>>

pub fn new(x: T, y: T, z: T, w: T) -> Self

Initializes this point from its components.

Example

let p = Point4::new(1.0, 2.0, 3.0, 4.0);
assert!(p.x == 1.0 && p.y == 2.0 && p.z == 3.0 && p.w == 4.0);

impl<T: Scalar> OPoint<T, Const<5>>

pub fn new(x: T, y: T, z: T, w: T, a: T) -> Self

Initializes this point from its components.

Example

let p = Point5::new(1.0, 2.0, 3.0, 4.0, 5.0);
assert!(p.x == 1.0 && p.y == 2.0 && p.z == 3.0 && p.w == 4.0 && p.a == 5.0);

impl<T: Scalar> OPoint<T, Const<6>>

pub fn new(x: T, y: T, z: T, w: T, a: T, b: T) -> Self

Initializes this point from its components.

Example

let p = Point6::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
assert!(p.x == 1.0 && p.y == 2.0 && p.z == 3.0 && p.w == 4.0 && p.a == 5.0 && p.b == 6.0);

impl<T: Scalar, const D: usize> OPoint<T, Const<D>>where
    Const<D>: ToTypenum,

Swizzling

pub fn xx(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U0, Output = Greater>,

Builds a new point from components of self.

pub fn xxx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U0, Output = Greater>,

Builds a new point from components of self.

pub fn xy(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yx(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yy(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn xxy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn xyx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn xyy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yxx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yxy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yyx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn yyy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U1, Output = Greater>,

Builds a new point from components of self.

pub fn xz(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yz(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zx(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zy(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zz(&self) -> Point2<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn xxz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn xyz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn xzx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn xzy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn xzz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yxz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yyz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yzx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yzy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn yzz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zxx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zxy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zxz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zyx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zyy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zyz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zzx(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zzy(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

pub fn zzz(&self) -> Point3<T>where
    <Const<D> as ToTypenum>::Typenum: Cmp<U2, Output = Greater>,

Builds a new point from components of self.

Trait Implementations

impl<T: Scalar + AbsDiffEq, D: DimName> AbsDiffEq<OPoint<T, D>> for OPoint<T, D>where
    T::Epsilon: Clone,
    DefaultAllocator: Allocator<T, D>,

type Epsilon = <T as AbsDiffEq<T>>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

fn add(self, right: &'b Vector<T, D2, SB>) -> Self::Output

Performs the + operation.

impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

fn add(self, right: &'b Vector<T, D2, SB>) -> Self::Output

Performs the + operation.

impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

fn add(self, right: Vector<T, D2, SB>) -> Self::Output

Performs the + operation.

impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

fn add(self, right: Vector<T, D2, SB>) -> Self::Output

Performs the + operation.

impl<'b, T, D1: DimName, D2: Dim, SB> AddAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    SB: Storage<T, D2>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    DefaultAllocator: Allocator<T, D1>,

fn add_assign(&mut self, right: &'b Vector<T, D2, SB>)

Performs the += operation.

impl<T, D1: DimName, D2: Dim, SB> AddAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedAdd,
    SB: Storage<T, D2>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    DefaultAllocator: Allocator<T, D1>,

fn add_assign(&mut self, right: Vector<T, D2, SB>)

Performs the += operation.

impl<T: RealField + RealField> AffineTransformation<OPoint<T, Const<2>>> for UnitComplex<T>

type Rotation = Unit<Complex<T>>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Id<Multiplicative>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Id, 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<T: RealField + RealField> AffineTransformation<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

type Rotation = Unit<Quaternion<T>>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Translation<T, 3>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Self::Translation, Self::Rotation, Id, Self::Rotation)

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, translation: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, translation: &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<T: RealField + RealField> AffineTransformation<OPoint<T, Const<3>>> for UnitQuaternion<T>

type Rotation = Unit<Quaternion<T>>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Id<Multiplicative>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Id, 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<T: RealField + RealField, R, const D: usize> AffineTransformation<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

type Rotation = R

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Translation<T, D>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Self::Translation, R, Id, R)

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, t: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, t: &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: &Point<T, D>
) -> Option<Self>

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant.

impl<T: RealField + RealField, const D: usize> AffineTransformation<OPoint<T, Const<D>>> for Rotation<T, D>

type Rotation = Rotation<T, D>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Id<Multiplicative>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Id, 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<T: RealField + RealField, R, const D: usize> AffineTransformation<OPoint<T, Const<D>>> for Similarity<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

type NonUniformScaling = T

Type of the non-uniform scaling to be applied.

type Rotation = R

Type of the first rotation to be applied.

type Translation = Translation<T, D>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Translation<T, D>, R, T, R)

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, t: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, t: &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, s: &Self::NonUniformScaling) -> Self

Appends a scaling factor to this similarity.

fn prepend_scaling(&self, s: &Self::NonUniformScaling) -> Self

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &Point<T, D>
) -> Option<Self>

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant.

impl<T: RealField + RealField, const D: usize> AffineTransformation<OPoint<T, Const<D>>> for Translation<T, D>

type Rotation = Id<Multiplicative>

Type of the first rotation to be applied.

type NonUniformScaling = Id<Multiplicative>

Type of the non-uniform scaling to be applied.

type Translation = Translation<T, D>

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Self, Id, Id, Id)

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, t: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, t: &Self::Translation) -> Self

Prepends a translation to this similarity.

fn append_rotation(&self, _: &Self::Rotation) -> Self

Appends a rotation to this similarity.

fn prepend_rotation(&self, _: &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<T: Scalar + Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D>where
    <DefaultAllocator as Allocator<T, D>>::Buffer: Send,
    DefaultAllocator: Allocator<T, D>,

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self> + 'static, Global>

Return an iterator of values that are smaller than itself.

impl<T: Scalar, D: DimName> Archive for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: Archive,

type Archived = ArchivedOPoint<T, D>

The archived representation of this type.

type Resolver = OPointResolver<T, D>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve(
    &self,
    pos: usize,
    resolver: Self::Resolver,
    out: *mut Self::Archived
)

Creates the archived version of this value at the given position and writes it to the given output.

impl<T: Scalar + Bounded, D: DimName> Bounded for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn max_value() -> Self

returns the largest finite number this type can represent

fn min_value() -> Self

returns the smallest finite number this type can represent

impl<__C: ?Sized, T: Scalar, D: DimName> CheckBytes<__C> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: CheckBytes<__C>,

type Error = StructCheckError

The error that may result from checking the type.

unsafe fn check_bytes<'__bytecheck>(
    value: *const Self,
    context: &mut __C
) -> Result<&'__bytecheck Self, StructCheckError>

Checks whether the given pointer points to a valid value within the given context.

impl<T: Clone + Scalar, D: Clone + DimName> Clone for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn clone(&self) -> OPoint<T, D>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Scalar + Debug, D: DimName> Debug for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T: Scalar + Zero, D: DimName> Default for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn default() -> Self

Returns the “default value” for a type.

impl<T: Scalar> Deref for OPoint<T, U1>

type Target = X<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> Deref for OPoint<T, U2>

type Target = XY<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> Deref for OPoint<T, U3>

type Target = XYZ<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> Deref for OPoint<T, U4>

type Target = XYZW<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> Deref for OPoint<T, U5>

type Target = XYZWA<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> Deref for OPoint<T, U6>

type Target = XYZWAB<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U1>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U2>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U3>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U4>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U5>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Scalar> DerefMut for OPoint<T, U6>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T: Scalar, D: DimName> Deserialize<'a> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    <DefaultAllocator as Allocator<T, D>>::Buffer: Deserialize<'a>,

fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>where
    Des: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized, T: Scalar, D: DimName> Deserialize<OPoint<T, D>, __D> for Archived<OPoint<T, D>>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: Archive,
    Archived<OVector<T, D>>: Deserialize<OVector<T, D>, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<OPoint<T, D>, __D::Error>

Deserializes using the given deserializer

impl<T: Scalar + Display, D: DimName> Display for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

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

Formats the value using the given formatter.

impl<T: Scalar, D: DimName> Distribution<OPoint<T, D>> for Standardwhere
    Standard: Distribution<T>,
    DefaultAllocator: Allocator<T, D>,

fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> OPoint<T, D>

Generate a Point where each coordinate is an independent variate from [0, 1).

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where
    F: Fn(T) -> S,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<'a, T: Scalar + ClosedDiv, D: DimName> Div<T> for &'a OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the / operator.

fn div(self, right: T) -> Self::Output

Performs the / operation.

impl<T: Scalar + ClosedDiv, D: DimName> Div<T> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the / operator.

fn div(self, right: T) -> Self::Output

Performs the / operation.

impl<T: Scalar + ClosedDiv, D: DimName> DivAssign<T> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn div_assign(&mut self, right: T)

Performs the /= operation.

impl<T: Scalar, D: DimName> From<Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D, Const<1>>>::Buffer>> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn from(coords: OVector<T, D>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const D: usize> From<OPoint<T, Const<D>>> for [T; D]

fn from(p: Point<T, D>) -> Self

Converts to this type from the input type.

impl<T: SimdRealField, R, const D: usize> From<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: AbstractRotation<T, D>,

fn from(coords: Point<T, D>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const D: usize> From<OPoint<T, Const<D>>> for Scale<T, D>

fn from(pt: Point<T, D>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const D: usize> From<OPoint<T, Const<D>>> for Translation<T, D>

fn from(pt: Point<T, D>) -> Self

Converts to this type from the input type.

impl<T: Scalar + Zero + One, D: DimName> From<OPoint<T, D>> for OVector<T, DimNameSum<D, U1>>where
    D: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<D, U1>> + Allocator<T, D>,

fn from(t: OPoint<T, D>) -> Self

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<2>>> for BVec2

fn from(e: Point2<bool>) -> BVec2

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<3>>> for BVec3

fn from(e: Point3<bool>) -> BVec3

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<bool, Const<4>>> for BVec4

fn from(e: Point4<bool>) -> BVec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<2>>> for Vec2

fn from(e: Point2<f32>) -> Vec2

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3

fn from(e: Point3<f32>) -> Vec3

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<3>>> for Vec3A

fn from(e: Point3<f32>) -> Vec3A

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f32, Const<4>>> for Vec4

fn from(e: Point4<f32>) -> Vec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<2>>> for DVec2

fn from(e: Point2<f64>) -> DVec2

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<3>>> for DVec3

fn from(e: Point3<f64>) -> DVec3

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<f64, Const<4>>> for DVec4

fn from(e: Point4<f64>) -> DVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<2>>> for IVec2

fn from(e: Point2<i32>) -> IVec2

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<3>>> for IVec3

fn from(e: Point3<i32>) -> IVec3

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<i32, Const<4>>> for IVec4

fn from(e: Point4<i32>) -> IVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<2>>> for UVec2

fn from(e: Point2<u32>) -> UVec2

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<3>>> for UVec3

fn from(e: Point3<u32>) -> UVec3

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl From<OPoint<u32, Const<4>>> for UVec4

fn from(e: Point4<u32>) -> UVec4

Converts to this type from the input type.

impl<T: Scalar + Hash, D: DimName> Hash for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl<T: Scalar, D: DimName> Index<usize> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Scalar, D: DimName> IndexMut<usize> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn index_mut(&mut self, i: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, 'b, T: SimdRealField> Mul<&'b OPoint<T, Const<2>>> for &'a UnitComplex<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T: SimdRealField> Mul<&'b OPoint<T, Const<2>>> for UnitComplex<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for &'a UnitDualQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for &'a UnitQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for UnitDualQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T: SimdRealField> Mul<&'b OPoint<T, Const<3>>> for UnitQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Isometry<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Rotation<T, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Scale<T, D>where
    T: Scalar + ClosedMul,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Similarity<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Transform<T, C, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    Const<D>: DimNameAdd<U1>,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Translation<T, D>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Isometry<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Rotation<T, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Scale<T, D>where
    T: Scalar + ClosedMul,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Similarity<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Transform<T, C, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    Const<D>: DimNameAdd<U1>,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Translation<T, D>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, 'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SA: Storage<T, Const<R1>, Const<C1>>,
    ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,

type Output = OPoint<T, Const<R1>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D2>) -> Self::Output

Performs the * operation.

impl<'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SA: Storage<T, Const<R1>, Const<C1>>,
    ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,

type Output = OPoint<T, Const<R1>>

The resulting type after applying the * operator.

fn mul(self, right: &'b Point<T, D2>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<f32, D>> for f32where
    DefaultAllocator: Allocator<f32, D>,

type Output = OPoint<f32, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<f32, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<f64, D>> for f64where
    DefaultAllocator: Allocator<f64, D>,

type Output = OPoint<f64, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<f64, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<i16, D>> for i16where
    DefaultAllocator: Allocator<i16, D>,

type Output = OPoint<i16, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<i16, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<i32, D>> for i32where
    DefaultAllocator: Allocator<i32, D>,

type Output = OPoint<i32, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<i32, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<i64, D>> for i64where
    DefaultAllocator: Allocator<i64, D>,

type Output = OPoint<i64, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<i64, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<i8, D>> for i8where
    DefaultAllocator: Allocator<i8, D>,

type Output = OPoint<i8, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<i8, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<isize, D>> for isizewhere
    DefaultAllocator: Allocator<isize, D>,

type Output = OPoint<isize, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<isize, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<u16, D>> for u16where
    DefaultAllocator: Allocator<u16, D>,

type Output = OPoint<u16, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<u16, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<u32, D>> for u32where
    DefaultAllocator: Allocator<u32, D>,

type Output = OPoint<u32, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<u32, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<u64, D>> for u64where
    DefaultAllocator: Allocator<u64, D>,

type Output = OPoint<u64, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<u64, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<u8, D>> for u8where
    DefaultAllocator: Allocator<u8, D>,

type Output = OPoint<u8, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<u8, D>) -> Self::Output

Performs the * operation.

impl<'b, D: DimName> Mul<&'b OPoint<usize, D>> for usizewhere
    DefaultAllocator: Allocator<usize, D>,

type Output = OPoint<usize, D>

The resulting type after applying the * operator.

fn mul(self, right: &'b OPoint<usize, D>) -> Self::Output

Performs the * operation.

impl<'a, T: SimdRealField> Mul<OPoint<T, Const<2>>> for &'a UnitComplex<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: SimdRealField> Mul<OPoint<T, Const<2>>> for UnitComplex<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<2>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: SimdRealField> Mul<OPoint<T, Const<3>>> for &'a UnitDualQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the * operation.

impl<'a, T: SimdRealField> Mul<OPoint<T, Const<3>>> for &'a UnitQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the * operation.

impl<T: SimdRealField> Mul<OPoint<T, Const<3>>> for UnitDualQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the * operation.

impl<T: SimdRealField> Mul<OPoint<T, Const<3>>> for UnitQuaternion<T>where
    T::Element: SimdRealField,

type Output = OPoint<T, Const<3>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point3<T>) -> Self::Output

Performs the * operation.

impl<'a, T: SimdRealField, R, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Isometry<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Rotation<T, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Scale<T, D>where
    T: Scalar + ClosedMul,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T: SimdRealField, R, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Similarity<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T, C, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Transform<T, C, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    Const<D>: DimNameAdd<U1>,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Translation<T, D>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T: SimdRealField, R, const D: usize> Mul<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T, const D: usize> Mul<OPoint<T, Const<D>>> for Rotation<T, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T, const D: usize> Mul<OPoint<T, Const<D>>> for Scale<T, D>where
    T: Scalar + ClosedMul,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T: SimdRealField, R, const D: usize> Mul<OPoint<T, Const<D>>> for Similarity<T, R, D>where
    T::Element: SimdRealField,
    R: AbstractRotation<T, D>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T, C, const D: usize> Mul<OPoint<T, Const<D>>> for Transform<T, C, D>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    Const<D>: DimNameAdd<U1>,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T, D>) -> Self::Output

Performs the * operation.

impl<T, const D: usize> Mul<OPoint<T, Const<D>>> for Translation<T, D>where
    T: Scalar + ClosedAdd,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,

type Output = OPoint<T, Const<D>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D>) -> Self::Output

Performs the * operation.

impl<'a, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SA: Storage<T, Const<R1>, Const<C1>>,
    ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,

type Output = OPoint<T, Const<R1>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D2>) -> Self::Output

Performs the * operation.

impl<T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>where
    T: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SA: Storage<T, Const<R1>, Const<C1>>,
    ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,

type Output = OPoint<T, Const<R1>>

The resulting type after applying the * operator.

fn mul(self, right: Point<T, D2>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<f32, D>> for f32where
    DefaultAllocator: Allocator<f32, D>,

type Output = OPoint<f32, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<f32, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<f64, D>> for f64where
    DefaultAllocator: Allocator<f64, D>,

type Output = OPoint<f64, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<f64, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<i16, D>> for i16where
    DefaultAllocator: Allocator<i16, D>,

type Output = OPoint<i16, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<i16, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<i32, D>> for i32where
    DefaultAllocator: Allocator<i32, D>,

type Output = OPoint<i32, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<i32, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<i64, D>> for i64where
    DefaultAllocator: Allocator<i64, D>,

type Output = OPoint<i64, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<i64, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<i8, D>> for i8where
    DefaultAllocator: Allocator<i8, D>,

type Output = OPoint<i8, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<i8, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<isize, D>> for isizewhere
    DefaultAllocator: Allocator<isize, D>,

type Output = OPoint<isize, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<isize, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<u16, D>> for u16where
    DefaultAllocator: Allocator<u16, D>,

type Output = OPoint<u16, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<u16, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<u32, D>> for u32where
    DefaultAllocator: Allocator<u32, D>,

type Output = OPoint<u32, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<u32, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<u64, D>> for u64where
    DefaultAllocator: Allocator<u64, D>,

type Output = OPoint<u64, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<u64, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<u8, D>> for u8where
    DefaultAllocator: Allocator<u8, D>,

type Output = OPoint<u8, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<u8, D>) -> Self::Output

Performs the * operation.

impl<D: DimName> Mul<OPoint<usize, D>> for usizewhere
    DefaultAllocator: Allocator<usize, D>,

type Output = OPoint<usize, D>

The resulting type after applying the * operator.

fn mul(self, right: OPoint<usize, D>) -> Self::Output

Performs the * operation.

impl<'a, T: Scalar + ClosedMul, D: DimName> Mul<T> for &'a OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the * operator.

fn mul(self, right: T) -> Self::Output

Performs the * operation.

impl<T: Scalar + ClosedMul, D: DimName> Mul<T> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the * operator.

fn mul(self, right: T) -> Self::Output

Performs the * operation.

impl<T: Scalar + ClosedMul, D: DimName> MulAssign<T> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn mul_assign(&mut self, right: T)

Performs the *= operation.

impl<'a, T: Scalar + ClosedNeg, D: DimName> Neg for &'a OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Scalar + ClosedNeg, D: DimName> Neg for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Scalar, D: DimName> PartialEq<OPoint<T, D>> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn eq(&self, right: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Scalar + PartialOrd, D: DimName> PartialOrd<OPoint<T, D>> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, right: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, right: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, right: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, right: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: RealField + RealField> ProjectiveTransformation<OPoint<T, Const<2>>> for UnitComplex<T>

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

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

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

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

impl<T: RealField + RealField> ProjectiveTransformation<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T>

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

fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

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

impl<T: RealField + RealField> ProjectiveTransformation<OPoint<T, Const<3>>> for UnitQuaternion<T>

fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T>

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

fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

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

impl<T: RealField + RealField, R, const D: usize> ProjectiveTransformation<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, const D: usize> ProjectiveTransformation<OPoint<T, Const<D>>> for Rotation<T, D>

fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, R, const D: usize> ProjectiveTransformation<OPoint<T, Const<D>>> for Similarity<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T, C, const D: usize> ProjectiveTransformation<OPoint<T, Const<D>>> for Transform<T, C, D>where
    Const<D>: DimNameAdd<U1>,
    T: RealField + RealField,
    C: SubTCategoryOf<TProjective>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, DimNameSum<Const<D>, U1>>,

fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, const D: usize> ProjectiveTransformation<OPoint<T, Const<D>>> for Translation<T, D>

fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: Scalar + RelativeEq, D: DimName> RelativeEq<OPoint<T, D>> for OPoint<T, D>where
    T::Epsilon: Clone,
    DefaultAllocator: Allocator<T, D>,

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for 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 relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: RealField + RealField> Rotation<OPoint<T, Const<2>>> for UnitComplex<T>

fn powf(&self, n: T) -> 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<T>, b: &Vector2<T>) -> 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<T>, b: &Vector2<T>, s: T) -> Option<Self>

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

impl<T: RealField + RealField> Rotation<OPoint<T, Const<3>>> for UnitQuaternion<T>

fn powf(&self, n: T) -> 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: &Vector3<T>, b: &Vector3<T>) -> 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: &Vector3<T>, b: &Vector3<T>, s: T) -> Option<Self>

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

impl<T: RealField + RealField, const D: usize> Rotation<OPoint<T, Const<D>>> for Rotation<T, D>

Subgroups of the n-dimensional rotation group SO(n).

fn powf(&self, _: T) -> 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(_: &SVector<T, D>, _: &SVector<T, D>) -> 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(
    _: &SVector<T, D>,
    _: &SVector<T, D>,
    _: T
) -> Option<Self>

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

impl<__S: Fallible + ?Sized, T: Scalar, D: DimName> Serialize<__S> for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T: Scalar, D: DimName> Serialize for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    <DefaultAllocator as Allocator<T, D>>::Buffer: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: RealField + RealField> Similarity<OPoint<T, Const<2>>> for UnitComplex<T>

type Scaling = Id<Multiplicative>

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<T: RealField + RealField> Similarity<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

type Scaling = Id<Multiplicative>

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> Translation3<T>

The pure translational component of this similarity transformation.

fn rotation(&self) -> UnitQuaternion<T>

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<T: RealField + RealField> Similarity<OPoint<T, Const<3>>> for UnitQuaternion<T>

type Scaling = Id<Multiplicative>

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<T: RealField + RealField, R, const D: usize> Similarity<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

type Scaling = Id<Multiplicative>

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> Translation<T, D>

The pure translational component of this similarity transformation.

fn rotation(&self) -> R

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<T: RealField + RealField, const D: usize> Similarity<OPoint<T, Const<D>>> for Rotation<T, D>

type Scaling = Id<Multiplicative>

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<T: RealField + RealField, R, const D: usize> Similarity<OPoint<T, Const<D>>> for Similarity<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

type Scaling = T

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> Translation<T, D>

The pure translational component of this similarity transformation.

fn rotation(&self) -> R

The pure rotational component of this similarity transformation.

fn scaling(&self) -> T

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<T: RealField + RealField, const D: usize> Similarity<OPoint<T, Const<D>>> for Translation<T, D>

type Scaling = Id<Multiplicative>

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> Self

The pure translational component of this similarity transformation.

fn rotation(&self) -> Id

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<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

fn sub(self, right: &'b Vector<T, D2, SB>) -> Self::Output

Performs the - operation.

impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

fn sub(self, right: &'b Vector<T, D2, SB>) -> Self::Output

Performs the - operation.

impl<'a, 'b, T, D> Sub<&'b OPoint<T, D>> for &'a OPoint<T, D>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,

type Output = Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D, Const<1>>>::Buffer>

The resulting type after applying the - operator.

fn sub(self, right: &'b OPoint<T, D>) -> Self::Output

Performs the - operation.

impl<'b, T, D> Sub<&'b OPoint<T, D>> for OPoint<T, D>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,

type Output = Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D, Const<1>>>::Buffer>

The resulting type after applying the - operator.

fn sub(self, right: &'b OPoint<T, D>) -> Self::Output

Performs the - operation.

impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

fn sub(self, right: Vector<T, D2, SB>) -> Self::Output

Performs the - operation.

impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D1: DimName,
    D2: Dim,
    SB: Storage<T, D2>,
    DefaultAllocator: Allocator<T, D1>,

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

fn sub(self, right: Vector<T, D2, SB>) -> Self::Output

Performs the - operation.

impl<'a, T, D> Sub<OPoint<T, D>> for &'a OPoint<T, D>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,

type Output = Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D, Const<1>>>::Buffer>

The resulting type after applying the - operator.

fn sub(self, right: OPoint<T, D>) -> Self::Output

Performs the - operation.

impl<T, D> Sub<OPoint<T, D>> for OPoint<T, D>where
    T: Scalar + ClosedSub,
    ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<U1, U1, Representative = U1>,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,

type Output = Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D, Const<1>>>::Buffer>

The resulting type after applying the - operator.

fn sub(self, right: OPoint<T, D>) -> Self::Output

Performs the - operation.

impl<'b, T, D1: DimName, D2: Dim, SB> SubAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedSub,
    SB: Storage<T, D2>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    DefaultAllocator: Allocator<T, D1>,

fn sub_assign(&mut self, right: &'b Vector<T, D2, SB>)

Performs the -= operation.

impl<T, D1: DimName, D2: Dim, SB> SubAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
    T: Scalar + ClosedSub,
    SB: Storage<T, D2>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    DefaultAllocator: Allocator<T, D1>,

fn sub_assign(&mut self, right: Vector<T, D2, SB>)

Performs the -= operation.

impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>>>::Buffer>> for OPoint<T1, D>where
    D: DimNameAdd<U1>,
    T1: Scalar,
    T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
    DefaultAllocator: Allocator<T1, D> + Allocator<T2, D> + Allocator<T1, DimNameSum<D, U1>> + Allocator<T2, DimNameSum<D, U1>>,

fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>>

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

fn is_in_subset(v: &OVector<T2, DimNameSum<D, U1>>) -> bool

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

fn from_superset_unchecked(v: &OVector<T2, DimNameSum<D, U1>>) -> 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<T1, T2, D: DimName> SubsetOf<OPoint<T2, D>> for OPoint<T1, D>where
    T1: Scalar,
    T2: Scalar + SupersetOf<T1>,
    DefaultAllocator: Allocator<T1, D> + Allocator<T2, D>,

fn to_superset(&self) -> OPoint<T2, D>

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

fn is_in_subset(m: &OPoint<T2, D>) -> bool

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

fn from_superset_unchecked(m: &OPoint<T2, D>) -> 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<T: RealField + RealField> Transformation<OPoint<T, Const<2>>> for UnitComplex<T>

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

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

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

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

impl<T: RealField + RealField> Transformation<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

fn transform_point(&self, pt: &Point3<T>) -> Point3<T>

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

fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

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

impl<T: RealField + RealField> Transformation<OPoint<T, Const<3>>> for UnitQuaternion<T>

fn transform_point(&self, pt: &Point3<T>) -> Point3<T>

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

fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T>

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

impl<T: RealField + RealField, R, const D: usize> Transformation<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, const D: usize> Transformation<OPoint<T, Const<D>>> for Rotation<T, D>

fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, R, const D: usize> Transformation<OPoint<T, Const<D>>> for Similarity<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T, C, const D: usize> Transformation<OPoint<T, Const<D>>> for Transform<T, C, D>where
    Const<D>: DimNameAdd<U1>,
    T: RealField + RealField,
    C: TCategory,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T, DimNameSum<Const<D>, U1>>,

fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, const D: usize> Transformation<OPoint<T, Const<D>>> for Translation<T, D>

fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

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

fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>

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

impl<T: RealField + RealField, const D: usize> Translation<OPoint<T, Const<D>>> for Translation<T, D>

Subgroups of the n-dimensional translation group T(n).

fn to_vector(&self) -> SVector<T, D>

Converts this translation to a vector.

fn from_vector(v: SVector<T, D>) -> Option<Self>

Attempts to convert a vector to this translation. Returns None if the translation represented by v is not part of the translation subgroup represented by Self.

fn powf(&self, n: T) -> Option<Self>

Raises the translation to a power. The result must be equivalent to self.to_superset() * n. Returns None if the result is not representable by Self.

fn translation_between(a: &Point<T, D>, b: &Point<T, D>) -> Option<Self>

The translation needed to make a coincide with b, i.e., b = a * translation_to(a, b).

impl<T: Scalar + UlpsEq, D: DimName> UlpsEq<OPoint<T, D>> for OPoint<T, D>where
    T::Epsilon: Clone,
    DefaultAllocator: Allocator<T, D>,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that 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 ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T: Scalar, D: DimName> Zeroable for OPoint<T, D>where
    OVector<T, D>: Zeroable,
    DefaultAllocator: Allocator<T, D>,

fn zeroed() -> Self

Calls zeroed.

impl<T: Scalar + Copy, D: DimName> Copy for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: Copy,

impl<T: Scalar + DeviceCopy, D: DimName> DeviceCopy for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,
    OVector<T, D>: DeviceCopy,

impl<T: RealField + RealField> DirectIsometry<OPoint<T, Const<2>>> for UnitComplex<T>

impl<T: RealField + RealField> DirectIsometry<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

impl<T: RealField + RealField> DirectIsometry<OPoint<T, Const<3>>> for UnitQuaternion<T>

impl<T: RealField + RealField, R, const D: usize> DirectIsometry<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

impl<T: RealField + RealField, const D: usize> DirectIsometry<OPoint<T, Const<D>>> for Rotation<T, D>

impl<T: RealField + RealField, const D: usize> DirectIsometry<OPoint<T, Const<D>>> for Translation<T, D>

impl<T: Scalar + Eq, D: DimName> Eq for OPoint<T, D>where
    DefaultAllocator: Allocator<T, D>,

impl<T: RealField + RealField> Isometry<OPoint<T, Const<2>>> for UnitComplex<T>

impl<T: RealField + RealField> Isometry<OPoint<T, Const<3>>> for UnitDualQuaternion<T>

impl<T: RealField + RealField> Isometry<OPoint<T, Const<3>>> for UnitQuaternion<T>

impl<T: RealField + RealField, R, const D: usize> Isometry<OPoint<T, Const<D>>> for Isometry<T, R, D>where
    R: Rotation<Point<T, D>> + AbstractRotation<T, D>,

impl<T: RealField + RealField, const D: usize> Isometry<OPoint<T, Const<D>>> for Rotation<T, D>

impl<T: RealField + RealField, const D: usize> Isometry<OPoint<T, Const<D>>> for Translation<T, D>

impl<T: RealField + RealField> OrthogonalTransformation<OPoint<T, Const<2>>> for UnitComplex<T>

impl<T: RealField + RealField> OrthogonalTransformation<OPoint<T, Const<3>>> for UnitQuaternion<T>

impl<T: RealField + RealField, const D: usize> OrthogonalTransformation<OPoint<T, Const<D>>> for Rotation<T, D>

impl<T: Scalar, D: DimName> Pod for OPoint<T, D>where
    T: Copy,
    OVector<T, D>: Pod,
    DefaultAllocator: Allocator<T, D>,