Struct na::geometry::Point

#[repr(C)]
pub struct Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>,  {
    pub coords: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
}

A point in a n-dimensional euclidean space.

Fields

coords: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

Methods

impl<N, D> Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub fn to_homogeneous(
    &self
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> where
    D: DimNameAdd<U1>,
    N: One,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, 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: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Point<N, D>

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 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.

Important traits for MatrixIter<'a, N, R, C, S>

impl<'a, N, R, C, S> Iterator for MatrixIter<'a, N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: 'a + Storage<N, R, C>,  type Item = &'a N;

pub fn iter(
    &self
) -> MatrixIter<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::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) -> &N

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

Important traits for MatrixIterMut<'a, N, R, C, S>

impl<'a, N, R, C, S> Iterator for MatrixIterMut<'a, N, R, C, S> where
    C: Dim,
    N: Scalar,
    R: Dim,
    S: 'a + StorageMut<N, R, C>,  type Item = &'a mut N;

pub fn iter_mut(
    &mut self
) -> MatrixIterMut<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::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 N

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<N, D> Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

pub unsafe fn new_uninitialized() -> Point<N, D>

Creates a new point with uninitialized coordinates.

pub fn origin() -> Point<N, D> where
    N: 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: &[N]) -> Point<N, D>

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: Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>
) -> Option<Point<N, D>> where
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedDiv<N>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, 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)));

impl<N> Point<N, U1> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>, 

pub fn new(x: N) -> Point<N, U1>

Initializes this point from its components.

Example

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

impl<N> Point<N, U2> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>, 

pub fn new(x: N, y: N) -> Point<N, U2>

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<N> Point<N, U3> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>, 

pub fn new(x: N, y: N, z: N) -> Point<N, U3>

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<N> Point<N, U4> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>, 

pub fn new(x: N, y: N, z: N, w: N) -> Point<N, U4>

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<N> Point<N, U5> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>, 

pub fn new(x: N, y: N, z: N, w: N, a: N) -> Point<N, U5>

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<N> Point<N, U6> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>, 

pub fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Point<N, U6>

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<N, D> Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>,
    <D as DimName>::Value: Cmp<UTerm>,
    <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater, 

pub fn xx(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn xxx(&self) -> Point<N, U3>

Builds a new point from components of self.

impl<N, D> Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>,
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

pub fn xy(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn yx(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn yy(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn xxy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xyx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xyy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yxx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yxy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yyx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yyy(&self) -> Point<N, U3>

Builds a new point from components of self.

impl<N, D> Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>,
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

pub fn xz(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn yz(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn zx(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn zy(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn zz(&self) -> Point<N, U2>

Builds a new point from components of self.

pub fn xxz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xyz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xzx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xzy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn xzz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yxz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yyz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yzx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yzy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn yzz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zxx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zxy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zxz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zyx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zyy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zyz(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zzx(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zzy(&self) -> Point<N, U3>

Builds a new point from components of self.

pub fn zzz(&self) -> Point<N, U3>

Builds a new point from components of self.

Trait Implementations

impl<N, D1, D2, SB> AddAssign<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>, 

fn add_assign(&mut self, right: Matrix<N, D2, U1, SB>)

Performs the += operation.

impl<'b, N, D1, D2, SB> AddAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>, 

fn add_assign(&mut self, right: &'b Matrix<N, D2, U1, SB>)

Performs the += operation.

impl<N, D> JoinSemilattice for Point<N, D> where
    D: DimName,
    N: Scalar + JoinSemilattice,
    DefaultAllocator: Allocator<N, D, U1>, 

fn join(&self, other: &Point<N, D>) -> Point<N, D>

Returns the join (aka. supremum) of two values.

impl<N, D> MulAssign<N> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

fn mul_assign(&mut self, right: N)

Performs the *= operation.

impl<N, D> Copy for Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Copy, 

impl<N, D> Clone for Point<N, D> where
    D: DimName + Clone,
    N: Scalar + Clone,
    DefaultAllocator: Allocator<N, D, U1>, 

fn clone(&self) -> Point<N, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N, D> RelativeEq<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + RelativeEq<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    <N as AbsDiffEq<N>>::Epsilon: Copy, 

fn default_max_relative() -> <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon

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

fn relative_eq(
    &self,
    other: &Point<N, D>,
    epsilon: <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon,
    max_relative: <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

default fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<N, D> Transformation<Point<N, <D as DimNameSub<U1>>::Output>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
    D: DimNameSub<U1>,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>, 

fn transform_vector(
    &self,
    v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>

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

fn transform_point(
    &self,
    pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>

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

impl<N> Transformation<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>

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

impl<N> Transformation<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>

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

impl<N, D> Transformation<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D, C> Transformation<Point<N, D>> for Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D> Transformation<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D, R> Transformation<Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D, R> Transformation<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D> Display for Point<N, D> where
    D: DimName,
    N: Scalar + Display,
    DefaultAllocator: Allocator<N, D, U1>, 

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

Formats the value using the given formatter.

impl<N, D, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type NonUniformScaling = N

Type of the non-uniform scaling to be applied.

type Rotation = R

Type of the first rotation to be applied.

type Translation = Translation<N, D>

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

fn decompose(&self) -> (Translation<N, D>, R, N, 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: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    t: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Similarity<N, D, R>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Similarity<N, D, R>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    s: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Similarity<N, D, R>

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(
    &self,
    r: &<Similarity<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation,
    p: &Point<N, D>
) -> Option<Similarity<N, D, R>>

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

impl<N> AffineTransformation<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

type Rotation = Unit<Quaternion<N>>

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<Multiplicative>, Unit<Quaternion<N>>, Id<Multiplicative>, Unit<Quaternion<N>>)

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,
    &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::Translation
) -> Unit<Quaternion<N>>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::Translation
) -> Unit<Quaternion<N>>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    r: &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::Rotation
) -> Unit<Quaternion<N>>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    r: &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::Rotation
) -> Unit<Quaternion<N>>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::NonUniformScaling
) -> Unit<Quaternion<N>>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    &<Unit<Quaternion<N>> as AffineTransformation<Point<N, U3>>>::NonUniformScaling
) -> Unit<Quaternion<N>>

Prepends a scaling factor to this similarity.

default fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &E
) -> Option<Self>

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

impl<N, D> AffineTransformation<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Rotation = Rotation<N, 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<Multiplicative>, Rotation<N, D>, Id<Multiplicative>, Rotation<N, D>)

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,
    &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Rotation<N, D>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    r: &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Rotation<N, D>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    &<Rotation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Rotation<N, D>

Prepends a scaling factor to this similarity.

default fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &E
) -> Option<Self>

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

impl<N, D> AffineTransformation<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

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<N, D>

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

fn decompose(
    &self
) -> (Translation<N, D>, Id<Multiplicative>, Id<Multiplicative>, Id<Multiplicative>)

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: &<Translation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Translation<N, D>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    t: &<Translation<N, D> as AffineTransformation<Point<N, D>>>::Translation
) -> Translation<N, D>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    &<Translation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Translation<N, D>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    &<Translation<N, D> as AffineTransformation<Point<N, D>>>::Rotation
) -> Translation<N, D>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    &<Translation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Translation<N, D>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    &<Translation<N, D> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Translation<N, D>

Prepends a scaling factor to this similarity.

default fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &E
) -> Option<Self>

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

impl<N, D, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

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<N, D>

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

fn decompose(
    &self
) -> (<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Translation, R, Id<Multiplicative>, 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: &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Isometry<N, D, R>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    t: &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Translation
) -> Isometry<N, D, R>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    r: &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Isometry<N, D, R>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    r: &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation
) -> Isometry<N, D, R>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Isometry<N, D, R>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::NonUniformScaling
) -> Isometry<N, D, R>

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(
    &self,
    r: &<Isometry<N, D, R> as AffineTransformation<Point<N, D>>>::Rotation,
    p: &Point<N, D>
) -> Option<Isometry<N, D, R>>

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

impl<N> AffineTransformation<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Rotation = Unit<Complex<N>>

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<Multiplicative>, Unit<Complex<N>>, Id<Multiplicative>, Unit<Complex<N>>)

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,
    &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::Translation
) -> Unit<Complex<N>>

Appends a translation to this similarity.

fn prepend_translation(
    &self,
    &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::Translation
) -> Unit<Complex<N>>

Prepends a translation to this similarity.

fn append_rotation(
    &self,
    r: &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::Rotation
) -> Unit<Complex<N>>

Appends a rotation to this similarity.

fn prepend_rotation(
    &self,
    r: &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::Rotation
) -> Unit<Complex<N>>

Prepends a rotation to this similarity.

fn append_scaling(
    &self,
    &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::NonUniformScaling
) -> Unit<Complex<N>>

Appends a scaling factor to this similarity.

fn prepend_scaling(
    &self,
    &<Unit<Complex<N>> as AffineTransformation<Point<N, U2>>>::NonUniformScaling
) -> Unit<Complex<N>>

Prepends a scaling factor to this similarity.

default fn append_rotation_wrt_point(
    &self,
    r: &Self::Rotation,
    p: &E
) -> Option<Self>

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

impl<N, D> PartialEq<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

fn eq(&self, right: &Point<N, D>) -> bool

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

#[must_use]

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

This method tests for !=.

impl<N, D> Hash for Point<N, D> where
    D: DimName + Hash,
    N: Scalar + Hash,
    DefaultAllocator: Allocator<N, D, U1>,
    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<N, D> AffineSpace for Point<N, D> where
    D: DimName,
    N: Scalar + Field + Scalar + Field,
    DefaultAllocator: Allocator<N, D, U1>, 

type Translation = Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

The associated vector space.

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

Same as *self + *t. Applies the additive group action of this affine space's associated vector space on self.

default fn subtract(&self, right: &Self) -> Self::Translation

Same as *self - *other. Returns the unique element v of the associated vector space such that self = right + v.

impl<N, D> AbsDiffEq<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + AbsDiffEq<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    <N as AbsDiffEq<N>>::Epsilon: Copy, 

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

Used for specifying relative comparisons.

fn default_epsilon() -> <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon

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

fn abs_diff_eq(
    &self,
    other: &Point<N, D>,
    epsilon: <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon
) -> bool

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

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

The inverse of ApproxEq::abs_diff_eq.

impl<N, D> DivAssign<N> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedDiv<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

fn div_assign(&mut self, right: N)

Performs the /= operation.

impl<N1, N2, D> SubsetOf<Point<N2, D>> for Point<N1, D> where
    D: DimName,
    N1: Scalar,
    N2: Scalar + SupersetOf<N1>,
    DefaultAllocator: Allocator<N2, D, U1>,
    DefaultAllocator: Allocator<N1, D, U1>, 

fn to_superset(&self) -> Point<N2, D>

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

fn is_in_subset(m: &Point<N2, D>) -> bool

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

unsafe fn from_superset_unchecked(m: &Point<N2, D>) -> Point<N1, D>

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

default fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>> for Point<N1, D> where
    D: DimNameAdd<U1>,
    N1: Scalar,
    N2: Scalar + Zero + One + ClosedDiv<N2> + SupersetOf<N1>,
    DefaultAllocator: Allocator<N1, D, U1>,
    DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N2, D, U1>, 

fn to_superset(
    &self
) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>

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

fn is_in_subset(
    v: &Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>
) -> bool

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

unsafe fn from_superset_unchecked(
    v: &Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>
) -> Point<N1, D>

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

default fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N, D> Neg for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedNeg,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the - operator.

fn neg(self) -> <Point<N, D> as Neg>::Output

Performs the unary - operation.

impl<'a, N, D> Neg for &'a Point<N, D> where
    D: DimName,
    N: Scalar + ClosedNeg,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the - operator.

fn neg(self) -> <&'a Point<N, D> as Neg>::Output

Performs the unary - operation.

impl<N, D> Lattice for Point<N, D> where
    D: DimName,
    N: Scalar + Lattice,
    DefaultAllocator: Allocator<N, D, U1>, 

fn meet_join(&self, other: &Point<N, D>) -> (Point<N, D>, Point<N, D>)

Returns the infimum and the supremum simultaneously.

default fn partial_min(&'a self, other: &'a Self) -> Option<&'a Self>

Return the minimum of self and other if they are comparable.

default fn partial_max(&'a self, other: &'a Self) -> Option<&'a Self>

Return the maximum of self and other if they are comparable.

default fn partial_sort2(
    &'a self,
    other: &'a Self
) -> Option<(&'a Self, &'a Self)>

Sorts two values in increasing order using a partial ordering.

default fn partial_clamp(
    &'a self,
    min: &'a Self,
    max: &'a Self
) -> Option<&'a Self>

Clamp value between min and max. Returns None if value is not comparable to min or max.

impl<N, D> PartialOrd<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + PartialOrd<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

fn partial_cmp(&self, other: &Point<N, D>) -> Option<Ordering>

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

fn lt(&self, right: &Point<N, D>) -> bool

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

fn le(&self, right: &Point<N, D>) -> bool

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

fn gt(&self, right: &Point<N, D>) -> bool

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

fn ge(&self, right: &Point<N, D>) -> bool

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

impl<N, D> Bounded for Point<N, D> where
    D: DimName,
    N: Scalar + Bounded,
    DefaultAllocator: Allocator<N, D, U1>, 

fn max_value() -> Point<N, D>

returns the largest finite number this type can represent

fn min_value() -> Point<N, D>

returns the smallest finite number this type can represent

impl<'b, N> Mul<&'b Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, U2>
) -> <Unit<Complex<N>> as Mul<&'b Point<N, U2>>>::Output

Performs the * operation.

impl<'a, N> Mul<Point<N, U2>> for &'a Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, U2>
) -> <&'a Unit<Complex<N>> as Mul<Point<N, U2>>>::Output

Performs the * operation.

impl<'a, N, D> Mul<Point<N, D>> for &'a Rotation<N, D> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <&'a Rotation<N, D> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'a, N, R1, C1, D2, SA> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output

Performs the * operation.

impl<'a, N, D, R> Mul<Point<N, D>> for &'a Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <&'a Isometry<N, D, R> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<N> Mul<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, U3>
) -> <Unit<Quaternion<N>> as Mul<Point<N, U3>>>::Output

Performs the * operation.

impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output

Performs the * operation.

impl<'b, N, D, R> Mul<&'b Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <Similarity<N, D, R> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output

Performs the * operation.

impl<N, D, C> Mul<Point<N, D>> for Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, D>
) -> <Transform<N, D, C> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N> Mul<&'b Point<N, U2>> for &'a Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, U2>
) -> <&'a Unit<Complex<N>> as Mul<&'b Point<N, U2>>>::Output

Performs the * operation.

impl<'b, N, D, C> Mul<&'b Point<N, D>> for Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, D>
) -> <Transform<N, D, C> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'b, N, D, R> Mul<&'b Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <Isometry<N, D, R> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, N, D, R> Mul<Point<N, D>> for &'a Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <&'a Similarity<N, D, R> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
    C1: Dim,
    D2: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    R1: DimName,
    SA: Storage<N, R1, C1>,
    DefaultAllocator: Allocator<N, R1, C1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: Allocator<N, R1, U1>,
    ShapeConstraint: AreMultipliable<R1, C1, D2, U1>, 

type Output = Point<N, R1>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output

Performs the * operation.

impl<'a, N> Mul<Point<N, U3>> for &'a Unit<Quaternion<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, U3>
) -> <&'a Unit<Quaternion<N>> as Mul<Point<N, U3>>>::Output

Performs the * operation.

impl<N, D> Mul<N> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(self, right: N) -> <Point<N, D> as Mul<N>>::Output

Performs the * operation.

impl<N, D, R> Mul<Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <Similarity<N, D, R> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<N, D, R> Mul<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <Isometry<N, D, R> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<N, D> Mul<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(self, right: Point<N, D>) -> <Rotation<N, D> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'b, N> Mul<&'b Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, U3>
) -> <Unit<Quaternion<N>> as Mul<&'b Point<N, U3>>>::Output

Performs the * operation.

impl<'a, N, D> Mul<Point<N, D>> for &'a Translation<N, D> where
    D: DimName,
    N: Scalar + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D, D>>::Representative == D, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <&'a Translation<N, D> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N> Mul<&'b Point<N, U3>> for &'a Unit<Quaternion<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, U3>
) -> <&'a Unit<Quaternion<N>> as Mul<&'b Point<N, U3>>>::Output

Performs the * operation.

impl<N> Mul<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, U2>
) -> <Unit<Complex<N>> as Mul<Point<N, U2>>>::Output

Performs the * operation.

impl<N, D> Mul<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: Scalar + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D, D>>::Representative == D, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: Point<N, D>
) -> <Translation<N, D> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N, D, C> Mul<&'b Point<N, D>> for &'a Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &'b Point<N, D>
) -> <&'a Transform<N, D, C> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, N, D> Mul<N> for &'a Point<N, D> where
    D: DimName,
    N: Scalar + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(self, right: N) -> <&'a Point<N, D> as Mul<N>>::Output

Performs the * operation.

impl<'a, 'b, N, D> Mul<&'b Point<N, D>> for &'a Rotation<N, D> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <&'a Rotation<N, D> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N, D, R> Mul<&'b Point<N, D>> for &'a Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <&'a Similarity<N, D, R> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N, D, R> Mul<&'b Point<N, D>> for &'a Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <&'a Isometry<N, D, R> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'b, N, D> Mul<&'b Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: AreMultipliable<D, D, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <Rotation<N, D> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'b, N, D> Mul<&'b Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: Scalar + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D, D>>::Representative == D, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <Translation<N, D> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, 'b, N, D> Mul<&'b Point<N, D>> for &'a Translation<N, D> where
    D: DimName,
    N: Scalar + ClosedAdd<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D, D>>::Representative == D, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    right: &'b Point<N, D>
) -> <&'a Translation<N, D> as Mul<&'b Point<N, D>>>::Output

Performs the * operation.

impl<'a, N, D, C> Mul<Point<N, D>> for &'a Transform<N, D, C> where
    C: TCategory,
    D: DimNameAdd<U1>,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: Point<N, D>
) -> <&'a Transform<N, D, C> as Mul<Point<N, D>>>::Output

Performs the * operation.

impl<N, D> ProjectiveTransformation<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D, R> ProjectiveTransformation<Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D> ProjectiveTransformation<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N, D, R> ProjectiveTransformation<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N> ProjectiveTransformation<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>

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

impl<N, D, C> ProjectiveTransformation<Point<N, D>> for Transform<N, D, C> where
    C: SubTCategoryOf<TProjective>,
    D: DimNameAdd<U1>,
    N: RealField,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

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

impl<N> ProjectiveTransformation<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

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

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

fn inverse_transform_vector(
    &self,
    v: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>

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

impl<N, D> Translation<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

Subgroups of the n-dimensional translation group T(n).

fn to_vector(
    &self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

Converts this translation to a vector.

fn from_vector(
    v: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Option<Translation<N, D>>

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: N) -> Option<Translation<N, D>>

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<N, D>,
    b: &Point<N, D>
) -> Option<Translation<N, D>>

The translation needed to make a coincide with b, i.e., b = a * translation_to(a, b).

impl<N, D> Rotation<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

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

fn powf(&self, N) -> Option<Rotation<N, D>>

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(
    &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
    &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Option<Rotation<N, D>>

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(
    &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
    &Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>,
    N
) -> Option<Rotation<N, D>>

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

impl<N> Rotation<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

fn powf(&self, n: N) -> Option<Unit<Quaternion<N>>>

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: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
    b: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Option<Unit<Quaternion<N>>>

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: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
    b: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
    s: N
) -> Option<Unit<Quaternion<N>>>

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

impl<N> Rotation<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

fn powf(&self, n: N) -> Option<Unit<Complex<N>>>

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: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
    b: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
) -> Option<Unit<Complex<N>>>

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: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
    b: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>,
    s: N
) -> Option<Unit<Complex<N>>>

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

impl<'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the + operator.

fn add(
    self,
    right: &'b Matrix<N, D2, U1, SB>
) -> <Point<N, D1> as Add<&'b Matrix<N, D2, U1, SB>>>::Output

Performs the + operation.

impl<N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the + operator.

fn add(
    self,
    right: Matrix<N, D2, U1, SB>
) -> <Point<N, D1> as Add<Matrix<N, D2, U1, SB>>>::Output

Performs the + operation.

impl<'a, N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the + operator.

fn add(
    self,
    right: Matrix<N, D2, U1, SB>
) -> <&'a Point<N, D1> as Add<Matrix<N, D2, U1, SB>>>::Output

Performs the + operation.

impl<'a, 'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedAdd<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the + operator.

fn add(
    self,
    right: &'b Matrix<N, D2, U1, SB>
) -> <&'a Point<N, D1> as Add<&'b Matrix<N, D2, U1, SB>>>::Output

Performs the + operation.

impl<N> Isometry<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

impl<N, D> Isometry<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N> Isometry<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

impl<N, D, R> Isometry<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N, D> Isometry<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N, D> MeetSemilattice for Point<N, D> where
    D: DimName,
    N: Scalar + MeetSemilattice,
    DefaultAllocator: Allocator<N, D, U1>, 

fn meet(&self, other: &Point<N, D>) -> Point<N, D>

Returns the meet (aka. infimum) of two values.

impl<N> Deref for Point<N, U6> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>, 

type Target = XYZWAB<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U6> as Deref>::Target

Dereferences the value.

impl<N> Deref for Point<N, U1> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>, 

type Target = X<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U1> as Deref>::Target

Dereferences the value.

impl<N> Deref for Point<N, U5> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>, 

type Target = XYZWA<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U5> as Deref>::Target

Dereferences the value.

impl<N> Deref for Point<N, U2> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Target = XY<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U2> as Deref>::Target

Dereferences the value.

impl<N> Deref for Point<N, U3> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Target = XYZ<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U3> as Deref>::Target

Dereferences the value.

impl<N> Deref for Point<N, U4> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Target = XYZW<N>

The resulting type after dereferencing.

fn deref(&self) -> &<Point<N, U4> as Deref>::Target

Dereferences the value.

impl<N> Similarity<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Scaling = Id<Multiplicative>

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

fn translation(&self) -> Id<Multiplicative>

The pure translational component of this similarity transformation.

fn rotation(&self) -> Unit<Complex<N>>

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id<Multiplicative>

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N, D, R> Similarity<Point<N, D>> for Similarity<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Scaling = N

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

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

The pure translational component of this similarity transformation.

fn rotation(&self) -> R

The pure rotational component of this similarity transformation.

fn scaling(&self) -> N

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N, D> Similarity<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Scaling = Id<Multiplicative>

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

fn translation(&self) -> Id<Multiplicative>

The pure translational component of this similarity transformation.

fn rotation(&self) -> Rotation<N, D>

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id<Multiplicative>

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N, D, R> Similarity<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Scaling = Id<Multiplicative>

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

fn translation(&self) -> Translation<N, 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<Multiplicative>

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N, D> Similarity<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Scaling = Id<Multiplicative>

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

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

The pure translational component of this similarity transformation.

fn rotation(&self) -> Id<Multiplicative>

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id<Multiplicative>

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N> Similarity<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

type Scaling = Id<Multiplicative>

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

fn translation(&self) -> Id<Multiplicative>

The pure translational component of this similarity transformation.

fn rotation(&self) -> Unit<Quaternion<N>>

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id<Multiplicative>

The pure scaling component of this similarity transformation.

default fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

default fn rotate_point(&self, pt: &E) -> E

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

default fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

default fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

default fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

default fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

default fn inverse_scale_point(&self, pt: &E) -> E

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

default 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.

default fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

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

impl<N> DerefMut for Point<N, U5> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U5, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U5> as Deref>::Target

Mutably dereferences the value.

impl<N> DerefMut for Point<N, U6> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U6, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U6> as Deref>::Target

Mutably dereferences the value.

impl<N> DerefMut for Point<N, U3> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U3, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U3> as Deref>::Target

Mutably dereferences the value.

impl<N> DerefMut for Point<N, U1> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U1, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U1> as Deref>::Target

Mutably dereferences the value.

impl<N> DerefMut for Point<N, U2> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U2, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U2> as Deref>::Target

Mutably dereferences the value.

impl<N> DerefMut for Point<N, U4> where
    N: Scalar,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn deref_mut(&mut self) -> &mut <Point<N, U4> as Deref>::Target

Mutably dereferences the value.

impl<N, D1, D2, SB> SubAssign<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>, 

fn sub_assign(&mut self, right: Matrix<N, D2, U1, SB>)

Performs the -= operation.

impl<'b, N, D1, D2, SB> SubAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>, 

fn sub_assign(&mut self, right: &'b Matrix<N, D2, U1, SB>)

Performs the -= operation.

impl<'a, N, D> Div<N> for &'a Point<N, D> where
    D: DimName,
    N: Scalar + ClosedDiv<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the / operator.

fn div(self, right: N) -> <&'a Point<N, D> as Div<N>>::Output

Performs the / operation.

impl<N, D> Div<N> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedDiv<N>,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the / operator.

fn div(self, right: N) -> <Point<N, D> as Div<N>>::Output

Performs the / operation.

impl<N, D> Debug for Point<N, D> where
    D: DimName + Debug,
    N: Scalar + Debug,
    DefaultAllocator: Allocator<N, D, U1>, 

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

Formats the value using the given formatter.

impl<N, D> IndexMut<usize> for Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

fn index_mut(&mut self, i: usize) -> &mut <Point<N, D> as Index<usize>>::Output

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

impl<N, D> Index<usize> for Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = N

The returned type after indexing.

fn index(&self, i: usize) -> &<Point<N, D> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<'a, N, D> Sub<Point<N, D>> for &'a Point<N, D> where
    D: DimName,
    N: Scalar + ClosedSub<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>, 

type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, U1, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, <ShapeConstraint as SameNumberOfColumns<U1, U1>>::Representative>>::Buffer>

The resulting type after applying the - operator.

fn sub(
    self,
    right: Point<N, D>
) -> <&'a Point<N, D> as Sub<Point<N, D>>>::Output

Performs the - operation.

impl<'a, N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the - operator.

fn sub(
    self,
    right: Matrix<N, D2, U1, SB>
) -> <&'a Point<N, D1> as Sub<Matrix<N, D2, U1, SB>>>::Output

Performs the - operation.

impl<N, D> Sub<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedSub<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>, 

type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, U1, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, <ShapeConstraint as SameNumberOfColumns<U1, U1>>::Representative>>::Buffer>

The resulting type after applying the - operator.

fn sub(self, right: Point<N, D>) -> <Point<N, D> as Sub<Point<N, D>>>::Output

Performs the - operation.

impl<N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the - operator.

fn sub(
    self,
    right: Matrix<N, D2, U1, SB>
) -> <Point<N, D1> as Sub<Matrix<N, D2, U1, SB>>>::Output

Performs the - operation.

impl<'a, 'b, N, D> Sub<&'b Point<N, D>> for &'a Point<N, D> where
    D: DimName,
    N: Scalar + ClosedSub<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>, 

type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, U1, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, <ShapeConstraint as SameNumberOfColumns<U1, U1>>::Representative>>::Buffer>

The resulting type after applying the - operator.

fn sub(
    self,
    right: &'b Point<N, D>
) -> <&'a Point<N, D> as Sub<&'b Point<N, D>>>::Output

Performs the - operation.

impl<'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the - operator.

fn sub(
    self,
    right: &'b Matrix<N, D2, U1, SB>
) -> <Point<N, D1> as Sub<&'b Matrix<N, D2, U1, SB>>>::Output

Performs the - operation.

impl<'a, 'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    D1: DimName,
    D2: Dim,
    N: Scalar + ClosedSub<N>,
    SB: Storage<N, D2, U1>,
    DefaultAllocator: Allocator<N, D1, U1>,
    DefaultAllocator: Allocator<N, D2, U1>,
    DefaultAllocator: SameShapeAllocator<N, D1, U1, D2, U1>,
    ShapeConstraint: SameNumberOfRows<D1, D2>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>,
    <ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1, 

type Output = Point<N, D1>

The resulting type after applying the - operator.

fn sub(
    self,
    right: &'b Matrix<N, D2, U1, SB>
) -> <&'a Point<N, D1> as Sub<&'b Matrix<N, D2, U1, SB>>>::Output

Performs the - operation.

impl<'b, N, D> Sub<&'b Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + ClosedSub<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: SameShapeAllocator<N, D, U1, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D>,
    ShapeConstraint: SameNumberOfColumns<U1, U1>, 

type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, U1, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<D, D>>::Representative, <ShapeConstraint as SameNumberOfColumns<U1, U1>>::Representative>>::Buffer>

The resulting type after applying the - operator.

fn sub(
    self,
    right: &'b Point<N, D>
) -> <Point<N, D> as Sub<&'b Point<N, D>>>::Output

Performs the - operation.

impl<N, D> Eq for Point<N, D> where
    D: DimName,
    N: Scalar + Eq,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N> From<[N; 2]> for Point<N, U2> where
    N: Scalar, 

fn from(coords: [N; 2]) -> Point<N, U2>

Performs the conversion.

impl<N> From<[N; 4]> for Point<N, U4> where
    N: Scalar, 

fn from(coords: [N; 4]) -> Point<N, U4>

Performs the conversion.

impl<N, D> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D> where
    D: DimName,
    N: Scalar,
    DefaultAllocator: Allocator<N, D, U1>, 

fn from(
    coords: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Point<N, D>

Performs the conversion.

impl<N> From<[N; 1]> for Point<N, U1> where
    N: Scalar, 

fn from(coords: [N; 1]) -> Point<N, U1>

Performs the conversion.

impl<N> From<[N; 6]> for Point<N, U6> where
    N: Scalar, 

fn from(coords: [N; 6]) -> Point<N, U6>

Performs the conversion.

impl<N> From<[N; 3]> for Point<N, U3> where
    N: Scalar, 

fn from(coords: [N; 3]) -> Point<N, U3>

Performs the conversion.

impl<N, D> From<Point<N, D>> for Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> where
    D: DimName + DimNameAdd<U1>,
    N: Scalar + Zero + One,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 

fn from(
    t: Point<N, D>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>

Performs the conversion.

impl<N> From<[N; 5]> for Point<N, U5> where
    N: Scalar, 

fn from(coords: [N; 5]) -> Point<N, U5>

Performs the conversion.

impl<N, D> EuclideanSpace for Point<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Coordinates = Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>

The underlying finite vector space.

type RealField = N

The underlying reals.

fn origin() -> Point<N, D>

The preferred origin of this euclidean space.

fn coordinates(&self) -> <Point<N, D> as EuclideanSpace>::Coordinates

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

fn from_coordinates(
    coords: <Point<N, D> as EuclideanSpace>::Coordinates
) -> Point<N, D>

Builds a point from its coordinates relative to the origin.

fn scale_by(&self, n: N) -> Point<N, D>

Multiplies the distance of this point to Self::origin() by s.

default fn distance_squared(&self, b: &Self) -> Self::RealField

The distance between two points.

default fn distance(&self, b: &Self) -> Self::RealField

The distance between two points.

impl<N, D> UlpsEq<Point<N, D>> for Point<N, D> where
    D: DimName,
    N: Scalar + UlpsEq<N>,
    DefaultAllocator: Allocator<N, D, U1>,
    <N as AbsDiffEq<N>>::Epsilon: Copy, 

fn default_max_ulps() -> u32

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

fn ulps_eq(
    &self,
    other: &Point<N, D>,
    epsilon: <Point<N, D> as AbsDiffEq<Point<N, D>>>::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

default fn ulps_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_ulps: u32
) -> bool

The inverse of ApproxEq::ulps_eq.

impl<N, D, R> DirectIsometry<Point<N, D>> for Isometry<N, D, R> where
    D: DimName,
    N: RealField,
    R: Rotation<Point<N, D>>,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N, D> DirectIsometry<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N> DirectIsometry<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

impl<N> DirectIsometry<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

impl<N, D> DirectIsometry<Point<N, D>> for Translation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<N> OrthogonalTransformation<Point<N, U3>> for Unit<Quaternion<N>> where
    N: RealField, 

impl<N> OrthogonalTransformation<Point<N, U2>> for Unit<Complex<N>> where
    N: RealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

impl<N, D> OrthogonalTransformation<Point<N, D>> for Rotation<N, D> where
    D: DimName,
    N: RealField,
    DefaultAllocator: Allocator<N, D, D>,
    DefaultAllocator: Allocator<N, D, U1>, 

impl<T: BaseNum> JoinPnt<T, Point<T, U2>> for T

type Output = Point3<T>

fn join(self, v: Point2<T>) -> Point3<T>

impl<T: BaseNum> JoinPnt<T, Point<T, U3>> for T

type Output = Point4<T>

fn join(self, v: Point3<T>) -> Point4<T>

impl<T: BaseNum> JoinPnt<T, Point<T, U2>> for Point2<T>

type Output = Point4<T>

fn join(self, v: Point2<T>) -> Point4<T>

impl<T: Scalar> IntoPnt<Point<T, U2>> for T

fn into_pnt(self) -> Point2<T>

impl<T: Scalar> IntoPnt<Point<T, U2>> for [T; 2]

fn into_pnt(self) -> Point2<T>

impl<'a, T: Scalar> IntoPnt<Point<T, U2>> for &'a [T]

fn into_pnt(self) -> Point2<T>

impl<T: Scalar> IntoPnt<Point<T, U3>> for T

fn into_pnt(self) -> Point3<T>

impl<T: Scalar> IntoPnt<Point<T, U3>> for [T; 3]

fn into_pnt(self) -> Point3<T>

impl<'a, T: Scalar> IntoPnt<Point<T, U3>> for &'a [T]

fn into_pnt(self) -> Point3<T>

impl<T: Scalar> IntoPnt<Point<T, U4>> for T

fn into_pnt(self) -> Point4<T>

impl<T: Scalar> IntoPnt<Point<T, U4>> for [T; 4]

fn into_pnt(self) -> Point4<T>

impl<'a, T: Scalar> IntoPnt<Point<T, U4>> for &'a [T]

fn into_pnt(self) -> Point4<T>

impl<T: RealField> ToPnt<Point<T, U1>> for Vector1<T>

fn to_pnt(self) -> Point1<T>

impl<T: RealField> ToPnt<Point<T, U2>> for Vector2<T>

fn to_pnt(self) -> Point2<T>

impl<T: RealField> ToPnt<Point<T, U3>> for Vector3<T>

fn to_pnt(self) -> Point3<T>

impl<T: RealField> ToPnt<Point<T, U4>> for Vector4<T>

fn to_pnt(self) -> Point4<T>

impl<T: RealField> ToPnt<Point<T, U5>> for Vector5<T>

fn to_pnt(self) -> Point5<T>

impl<T: RealField> ToPnt<Point<T, U6>> for Vector6<T>

fn to_pnt(self) -> Point6<T>

impl<T: RealField> AsPnt<Point<T, U1>> for Vector1<T>

fn as_pnt(&self) -> &Point1<T>

impl<T: RealField> AsPnt<Point<T, U2>> for Vector2<T>

fn as_pnt(&self) -> &Point2<T>

impl<T: RealField> AsPnt<Point<T, U3>> for Vector3<T>

fn as_pnt(&self) -> &Point3<T>

impl<T: RealField> AsPnt<Point<T, U4>> for Vector4<T>

fn as_pnt(&self) -> &Point4<T>

impl<T: RealField> AsPnt<Point<T, U5>> for Vector5<T>

fn as_pnt(&self) -> &Point5<T>

impl<T: RealField> AsPnt<Point<T, U6>> for Vector6<T>

fn as_pnt(&self) -> &Point6<T>