Struct rin::math::Point

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

A point in an euclidean space.

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

Construction

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

Transformation

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

Fields

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

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

Implementations

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

pub fn map<N2, F>(&self, f: F) -> Point<N2, D> where
    F: FnMut(N) -> N2,
    N2: Scalar,
    DefaultAllocator: Allocator<N2, D, U1>, 

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

Example

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

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

pub fn apply<F>(&mut self, f: F) where
    F: FnMut(N) -> N, 

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

Example

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

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

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
    N: One,
    D: DimNameAdd<U1>,
    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 is_empty(&self) -> bool

Returns true if the point contains no elements.

Example

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

pub fn stride(&self) -> usize

👎 Deprecated:

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

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

pub fn iter(
    &self
) -> MatrixIter<'_, 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.

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

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

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

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

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

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

Computes the (infimum, supremum) of two points.

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

Other construction methods

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
    N: Scalar + Zero + One + ClosedDiv<N>,
    D: DimNameAdd<U1>,
    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, 

Construction from individual components

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

Initializes this point from its components.

Example

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

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

Swizzling

pub fn xx(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UTerm>,
    <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater, 

Builds a new point from components of self.

pub fn xxx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UTerm>,
    <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater, 

Builds a new point from components of self.

pub fn xy(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yx(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yy(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xxy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xyx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xyy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yxx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yxy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yyx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yyy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UTerm, B1>>,
    <<D as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xz(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yz(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zx(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zy(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zz(&self) -> Point<N, U2> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xxz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xyz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xzx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xzy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn xzz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yxz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yyz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yzx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yzy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn yzz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zxx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zxy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zxz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zyx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zyy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zyz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zzx(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zzy(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

pub fn zzz(&self) -> Point<N, U3> where
    <D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<D as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater, 

Builds a new point from components of self.

impl<N> Point<N, U2> where
    N: Scalar, 

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, 

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, 

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, 

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, 

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);

Trait Implementations

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

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

Used for specifying relative comparisons.

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

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

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

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

The inverse of AbsDiffEq::abs_diff_eq.

impl<'a, 'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedAdd<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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<'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedAdd<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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<'a, N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
    N: Scalar + ClosedAdd<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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<N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedAdd<N>,
    D2: Dim,
    D1: DimName,
    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.

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

Performs the + operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

impl<N> AsBytes for Point<N, U2> where
    N: RealField, 

pub fn as_bytes(&'a self) -> &'a [u8]

impl<N> AsBytes for Point<N, U3> where
    N: RealField, 

pub fn as_bytes(&'a self) -> &'a [u8]

impl<T> AsPnt<Point<T, U1>> for Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U1>

impl<T> AsPnt<Point<T, U2>> for Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U2>

impl<T> AsPnt<Point<T, U3>> for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U3>

impl<T> AsPnt<Point<T, U4>> for Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U4>

impl<T> AsPnt<Point<T, U5>> for Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U5>

impl<T> AsPnt<Point<T, U6>> for Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer> where
    T: Scalar, 

pub fn as_pnt(&self) -> &Point<T, U6>

impl<T> AsVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point<T, U1> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>

impl<T> AsVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point<T, U2> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>

impl<T> AsVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point<T, U3> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>

impl<T> AsVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point<T, U4> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>

impl<T> AsVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point<T, U5> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>

impl<T> AsVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point<T, U6> where
    T: Scalar, 

pub fn as_vec(
    &self
) -> &Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>

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

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

returns the largest finite number this type can represent

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

returns the smallest finite number this type can represent

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

type Target = X<N>

The resulting type after dereferencing.

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

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

Dereferences the value.

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

type Target = XYZWAB<N>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<N, U6> 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.

pub fn deref(&self) -> &<Point<N, U4> 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.

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

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

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

Mutably dereferences the value.

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

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

Mutably dereferences the value.

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

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

Mutably dereferences the value.

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

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

Mutably dereferences the value.

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

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

Mutably dereferences the value.

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

pub fn deserialize<Des>(
    deserializer: Des
) -> Result<Point<N, D>, <Des as Deserializer<'a>>::Error> where
    Des: Deserializer<'a>, 

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

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

type Output = Point<N, D>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Point<N, D>

The resulting type after applying the / operator.

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

Performs the / operation.

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

pub fn div_assign(&mut self, right: N)

Performs the /= operation.

impl<N> FloatPnt for Point<N, U4> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U4>

pub fn distance(&self, b: &Point<N, U4>) -> <Point<N, U4> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U4>
) -> <Point<N, U4> as NumPnt>::Field

impl<N> FloatPnt for Point<N, U1> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U1>

pub fn distance(&self, b: &Point<N, U1>) -> <Point<N, U1> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U1>
) -> <Point<N, U1> as NumPnt>::Field

impl<N> FloatPnt for Point<N, U2> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U2>

pub fn distance(&self, b: &Point<N, U2>) -> <Point<N, U2> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U2>
) -> <Point<N, U2> as NumPnt>::Field

impl<N> FloatPnt for Point<N, U5> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U5>

pub fn distance(&self, b: &Point<N, U5>) -> <Point<N, U5> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U5>
) -> <Point<N, U5> as NumPnt>::Field

impl<N> FloatPnt for Point<N, U3> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U3>

pub fn distance(&self, b: &Point<N, U3>) -> <Point<N, U3> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U3>
) -> <Point<N, U3> as NumPnt>::Field

impl<N> FloatPnt for Point<N, U6> where
    N: BaseNum + RealField, 

pub fn origin() -> Point<N, U6>

pub fn distance(&self, b: &Point<N, U6>) -> <Point<N, U6> as NumPnt>::Field

pub fn distance_squared(
    &self,
    b: &Point<N, U6>
) -> <Point<N, U6> as NumPnt>::Field

impl<'a> From<&'a Point<f32, U2>> for Model

pub fn from(pos: &Point<f32, U2>) -> Model

Performs the conversion.

impl<'a> From<&'a Point<f32, U3>> for Model

pub fn from(pos: &Point<f32, U3>) -> Model

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<N, D> From<[Point<<N as SimdValue>::Element, D>; 16]> for Point<N, D> where
    N: Scalar + Copy + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 16]>,
    D: DimName,
    <N as SimdValue>::Element: Scalar,
    <N as SimdValue>::Element: Copy,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<<N as SimdValue>::Element, D, U1>,
    <DefaultAllocator as Allocator<<N as SimdValue>::Element, D, U1>>::Buffer: Copy, 

pub fn from(arr: [Point<<N as SimdValue>::Element, D>; 16]) -> Point<N, D>

Performs the conversion.

impl<N, D> From<[Point<<N as SimdValue>::Element, D>; 2]> for Point<N, D> where
    N: Scalar + Copy + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 2]>,
    D: DimName,
    <N as SimdValue>::Element: Scalar,
    <N as SimdValue>::Element: Copy,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<<N as SimdValue>::Element, D, U1>,
    <DefaultAllocator as Allocator<<N as SimdValue>::Element, D, U1>>::Buffer: Copy, 

pub fn from(arr: [Point<<N as SimdValue>::Element, D>; 2]) -> Point<N, D>

Performs the conversion.

impl<N, D> From<[Point<<N as SimdValue>::Element, D>; 4]> for Point<N, D> where
    N: Scalar + Copy + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 4]>,
    D: DimName,
    <N as SimdValue>::Element: Scalar,
    <N as SimdValue>::Element: Copy,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<<N as SimdValue>::Element, D, U1>,
    <DefaultAllocator as Allocator<<N as SimdValue>::Element, D, U1>>::Buffer: Copy, 

pub fn from(arr: [Point<<N as SimdValue>::Element, D>; 4]) -> Point<N, D>

Performs the conversion.

impl<N, D> From<[Point<<N as SimdValue>::Element, D>; 8]> for Point<N, D> where
    N: Scalar + Copy + PrimitiveSimdValue + From<[<N as SimdValue>::Element; 8]>,
    D: DimName,
    <N as SimdValue>::Element: Scalar,
    <N as SimdValue>::Element: Copy,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<<N as SimdValue>::Element, D, U1>,
    <DefaultAllocator as Allocator<<N as SimdValue>::Element, D, U1>>::Buffer: Copy, 

pub fn from(arr: [Point<<N as SimdValue>::Element, D>; 8]) -> Point<N, D>

Performs the conversion.

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

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

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
    N: Scalar + Zero + One,
    D: DimName + DimNameAdd<U1>,
    DefaultAllocator: Allocator<N, D, U1>,
    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, 

pub 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 From<Point<f32, U3>> for Node

pub fn from(pos: Point<f32, U3>) -> Node

Performs the conversion.

impl<T> FromIterator<Point<T, U2>> for Polyline<T> where
    T: RealField, 

pub fn from_iter<I>(iter: I) -> Polyline<T> where
    I: IntoIterator<Item = Point<T, U2>>, 

Creates a value from an iterator.

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

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

Feeds this value into the given Hasher.

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

type Output = N

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<T> InsidePolygon<T> for Point<T, U2> where
    T: RealField + NumCast, 

pub fn inside_polygon(&self, polygon: &Polyline<T>, bound: bool) -> bool

impl<T> InsideRect<T> for Point<T, U2> where
    T: Float + BaseNum, 

pub fn inside(&self, rect: &Rect<T>) -> bool

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

pub fn into_pnt(self) -> Point<T, U2>

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

pub fn into_pnt(self) -> Point<T, U2>

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

pub fn into_pnt(self) -> Point<T, U2>

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

pub fn into_pnt(self) -> Point<T, U3>

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

pub fn into_pnt(self) -> Point<T, U3>

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

pub fn into_pnt(self) -> Point<T, U3>

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

pub fn into_pnt(self) -> Point<T, U4>

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

pub fn into_pnt(self) -> Point<T, U4>

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

pub fn into_pnt(self) -> Point<T, U4>

impl<T> JoinPnt<T, Point<T, U2>> for T where
    T: Scalar, 

type Output = Point<T, U3>

pub fn join(self, v: Point<T, U2>) -> Point<T, U3>

impl<T> JoinPnt<T, Point<T, U2>> for Point<T, U2> where
    T: Scalar, 

type Output = Point<T, U4>

pub fn join(self, v: Point<T, U2>) -> Point<T, U4>

impl<T> JoinPnt<T, Point<T, U3>> for T where
    T: Scalar, 

type Output = Point<T, U4>

pub fn join(self, v: Point<T, U3>) -> Point<T, U4>

impl<T> JoinPnt<T, T> for Point<T, U3> where
    T: Scalar, 

type Output = Point<T, U4>

pub fn join(self, v: T) -> Point<T, U4>

impl<T> JoinPnt<T, T> for Point<T, U2> where
    T: Scalar, 

type Output = Point<T, U3>

pub fn join(self, v: T) -> Point<T, U3>

impl<'b, N, D> Mul<&'b Point<N, D>> for Translation<N, D> where
    N: Scalar + ClosedAdd<N>,
    D: DimName,
    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.

pub 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, C> Mul<&'b Point<N, D>> for &'a Transform<N, D, C> where
    C: TCategory,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    D: DimNameAdd<U1>,
    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.

pub 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, 'b, N, D> Mul<&'b Point<N, D>> for &'a Translation<N, D> where
    N: Scalar + ClosedAdd<N>,
    D: DimName,
    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.

pub fn mul(
    self,
    right: &'b Point<N, D>
) -> <&'a 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 Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D: DimName,
    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.

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

Performs the * operation.

impl<'b, N, D, C> Mul<&'b Point<N, D>> for Transform<N, D, C> where
    C: TCategory,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    D: DimNameAdd<U1>,
    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.

pub 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> Mul<&'b Point<N, D>> for Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D: DimName,
    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.

pub fn mul(
    self,
    right: &'b Point<N, D>
) -> <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
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub 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
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub 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, R> Mul<&'b Point<N, D>> for Similarity<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub 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, D, R> Mul<&'b Point<N, D>> for Isometry<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub fn mul(
    self,
    right: &'b Point<N, D>
) -> <Isometry<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
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D2: DimName,
    C1: Dim,
    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.

pub fn mul(
    self,
    right: &'b Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::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
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D2: DimName,
    C1: Dim,
    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.

pub 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<'b, N> Mul<&'b Point<N, U2>> for Unit<Complex<N>> where
    N: SimdRealField,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<N, U2>

The resulting type after applying the * operator.

pub 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> Mul<&'b Point<N, U3>> for Unit<Quaternion<N>> where
    N: SimdRealField,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<N, U3>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, D> Mul<&'b Point<f32, D>> for f32 where
    D: DimName,
    DefaultAllocator: Allocator<f32, D, U1>, 

type Output = Point<f32, D>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<N, D>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<N, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N, D, R> Mul<Point<N, D>> for Isometry<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub 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
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D: DimName,
    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.

pub fn mul(
    self,
    right: Point<N, D>
) -> <Rotation<N, D> as Mul<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,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    D: DimNameAdd<U1>,
    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.

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

Performs the * operation.

impl<'a, N, D> Mul<Point<N, D>> for &'a Translation<N, D> where
    N: Scalar + ClosedAdd<N>,
    D: DimName,
    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.

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

Performs the * operation.

impl<'a, N, D, R> Mul<Point<N, D>> for &'a Similarity<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N, D, C> Mul<Point<N, D>> for Transform<N, D, C> where
    C: TCategory,
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + RealField,
    D: DimNameAdd<U1>,
    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.

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

Performs the * operation.

impl<N, D, R> Mul<Point<N, D>> for Similarity<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, N, D> Mul<Point<N, D>> for &'a Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D: DimName,
    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.

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

Performs the * operation.

impl<N, D> Mul<Point<N, D>> for Translation<N, D> where
    N: Scalar + ClosedAdd<N>,
    D: DimName,
    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.

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

Performs the * operation.

impl<'a, N, D, R> Mul<Point<N, D>> for &'a Isometry<N, D, R> where
    N: SimdRealField,
    D: DimName,
    R: AbstractRotation<N, D>,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1>, 

type Output = Point<N, D>

The resulting type after applying the * operator.

pub fn mul(
    self,
    right: Point<N, D>
) -> <&'a Isometry<N, D, R> 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
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D2: DimName,
    C1: Dim,
    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.

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

Performs the * operation.

impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where
    N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
    D2: DimName,
    C1: Dim,
    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.

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

Performs the * operation.

impl<'a, N> Mul<Point<N, U2>> for &'a Unit<Complex<N>> where
    N: SimdRealField,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N> Mul<Point<N, U2>> for Unit<Complex<N>> where
    N: SimdRealField,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point<N, U2>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N> Mul<Point<N, U3>> for Unit<Quaternion<N>> where
    N: SimdRealField,
    <N as SimdValue>::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U3, U1>, 

type Output = Point<N, U3>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<N, U3>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D> Mul<Point<f32, D>> for f32 where
    D: DimName,
    DefaultAllocator: Allocator<f32, D, U1>, 

type Output = Point<f32, D>

The resulting type after applying the * operator.

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

Performs the * operation.

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

pub fn mul_assign(&mut self, right: N)

Performs the *= operation.

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

type Output = Point<N, D>

The resulting type after applying the - operator.

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

Performs the unary - operation.

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

type Output = Point<N, D>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<N> NumPnt for Point<N, U5> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U5> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U5> as NumPnt>::Coordinates
) -> Point<N, U5>

impl<N> NumPnt for Point<N, U3> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U3> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U3> as NumPnt>::Coordinates
) -> Point<N, U3>

impl<N> NumPnt for Point<N, U2> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U2> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U2> as NumPnt>::Coordinates
) -> Point<N, U2>

impl<N> NumPnt for Point<N, U4> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U4> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U4> as NumPnt>::Coordinates
) -> Point<N, U4>

impl<N> NumPnt for Point<N, U6> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U6> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U6> as NumPnt>::Coordinates
) -> Point<N, U6>

impl<N> NumPnt for Point<N, U1> where
    N: BaseNum, 

type Field = N

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

pub fn coordinates(&self) -> <Point<N, U1> as NumPnt>::Coordinates

pub fn from_coordiantes(
    coords: <Point<N, U1> as NumPnt>::Coordinates
) -> Point<N, U1>

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

pub 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]

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

This method tests for !=.

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

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

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

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

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

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

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

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

pub 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> RelativeEq<Point<N, D>> for Point<N, D> where
    N: Scalar + RelativeEq<N>,
    D: DimName,
    DefaultAllocator: Allocator<N, D, U1>,
    <N as AbsDiffEq<N>>::Epsilon: Copy, 

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

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

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

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

The inverse of RelativeEq::relative_eq.

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

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

Serialize this value into the given Serde serializer.

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

type Element = Point<<N as SimdValue>::Element, D>

The type of the elements of each lane of this SIMD value.

type SimdBool = <N as SimdValue>::SimdBool

Type of the result of comparing two SIMD values like self.

pub fn lanes() -> usize

The number of lanes of this SIMD value.

pub fn splat(val: <Point<N, D> as SimdValue>::Element) -> Point<N, D>

Initializes an SIMD value with each lanes set to val.

pub fn extract(&self, i: usize) -> <Point<N, D> as SimdValue>::Element

Extracts the i-th lane of self.

pub unsafe fn extract_unchecked(
    &self,
    i: usize
) -> <Point<N, D> as SimdValue>::Element

Extracts the i-th lane of self without bound-checking.

pub fn replace(&mut self, i: usize, val: <Point<N, D> as SimdValue>::Element)

Replaces the i-th lane of self by val.

pub unsafe fn replace_unchecked(
    &mut self,
    i: usize,
    val: <Point<N, D> as SimdValue>::Element
)

Replaces the i-th lane of self by val without bound-checking.

pub fn select(
    self,
    cond: <Point<N, D> as SimdValue>::SimdBool,
    other: Point<N, D>
) -> Point<N, D>

Merges self and other depending on the lanes of cond.

pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self where
    Self: Clone, 

Applies a function to each lane of self.

pub fn zip_map_lanes(
    self,
    b: Self,
    f: impl Fn(Self::Element, Self::Element) -> Self::Element
) -> Self where
    Self: Clone, 

Applies a function to each lane of self paired with the corresponding lane of b.

impl<T> Std140 for Point<T, U2> where
    T: Scalar + Std140, 

pub const ALIGNMENT: usize

impl<T> Std140 for Point<T, U4> where
    T: Scalar + Std140, 

pub const ALIGNMENT: usize

impl<T> Std140 for Point<T, U3> where
    T: Scalar + Std140, 

pub const ALIGNMENT: usize

impl<'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedSub<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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
    N: Scalar + ClosedSub<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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
    N: Scalar + ClosedSub<N>,
    D: DimName,
    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.

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

Performs the - operation.

impl<'a, 'b, N, D> Sub<&'b Point<N, D>> for &'a Point<N, D> where
    N: Scalar + ClosedSub<N>,
    D: DimName,
    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.

pub fn sub(
    self,
    right: &'b Point<N, D>
) -> <&'a Point<N, D> as Sub<&'b 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
    N: Scalar + ClosedSub<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1> where
    N: Scalar + ClosedSub<N>,
    D2: Dim,
    D1: DimName,
    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.

pub 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, N, D> Sub<Point<N, D>> for &'a Point<N, D> where
    N: Scalar + ClosedSub<N>,
    D: DimName,
    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.

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

Performs the - operation.

impl<N, D> Sub<Point<N, D>> for Point<N, D> where
    N: Scalar + ClosedSub<N>,
    D: DimName,
    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.

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

Performs the - operation.

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

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

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

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

pub 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<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>, 

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

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

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

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

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

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

impl<T> Swizzles2<T> for Point<T, U3> where
    T: Scalar, 

type Swizzle2 = Point<T, U2>

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

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

impl<T> Swizzles2<T> for Point<T, U4> where
    T: Scalar, 

type Swizzle2 = Point<T, U2>

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

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

impl<T> Swizzles2<T> for Point<T, U5> where
    T: Scalar, 

type Swizzle2 = Point<T, U2>

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

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

impl<T> Swizzles2<T> for Point<T, U6> where
    T: Scalar, 

type Swizzle2 = Point<T, U2>

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

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

impl<T> Swizzles2<T> for Point<T, U2> where
    T: Scalar, 

type Swizzle2 = Point<T, U2>

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

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

impl<T> Swizzles2Mut<T> for Point<T, U5> where
    T: Scalar, 

pub fn set_xy(&mut self, right: &Point<T, U2>)

pub fn set_yx(&mut self, right: &Point<T, U2>)

impl<T> Swizzles2Mut<T> for Point<T, U3> where
    T: Scalar, 

pub fn set_xy(&mut self, right: &Point<T, U2>)

pub fn set_yx(&mut self, right: &Point<T, U2>)

impl<T> Swizzles2Mut<T> for Point<T, U4> where
    T: Scalar, 

pub fn set_xy(&mut self, right: &Point<T, U2>)

pub fn set_yx(&mut self, right: &Point<T, U2>)

impl<T> Swizzles2Mut<T> for Point<T, U2> where
    T: Scalar, 

pub fn set_xy(&mut self, right: &Point<T, U2>)

pub fn set_yx(&mut self, right: &Point<T, U2>)

impl<T> Swizzles2Mut<T> for Point<T, U6> where
    T: Scalar, 

pub fn set_xy(&mut self, right: &Point<T, U2>)

pub fn set_yx(&mut self, right: &Point<T, U2>)

impl<T> Swizzles3<T> for Point<T, U4> where
    T: Scalar, 

type Swizzle3 = Point<T, U3>

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

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

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

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

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

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

pub fn yz(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn xz(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn zy(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn zx(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles3<T> for Point<T, U3> where
    T: Scalar, 

type Swizzle3 = Point<T, U3>

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

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

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

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

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

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

pub fn yz(&self) -> <Point<T, U3> as Swizzles2<T>>::Swizzle2

pub fn xz(&self) -> <Point<T, U3> as Swizzles2<T>>::Swizzle2

pub fn zy(&self) -> <Point<T, U3> as Swizzles2<T>>::Swizzle2

pub fn zx(&self) -> <Point<T, U3> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles3<T> for Point<T, U5> where
    T: Scalar, 

type Swizzle3 = Point<T, U3>

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

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

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

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

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

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

pub fn yz(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn xz(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn zy(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn zx(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles3<T> for Point<T, U6> where
    T: Scalar, 

type Swizzle3 = Point<T, U3>

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

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

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

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

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

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

pub fn yz(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn xz(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn zy(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn zx(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles3Mut<T> for Point<T, U6> where
    T: Scalar, 

pub fn set_xyz(&mut self, right: &Point<T, U3>)

pub fn set_xzy(&mut self, right: &Point<T, U3>)

pub fn set_yxz(&mut self, right: &Point<T, U3>)

pub fn set_yzx(&mut self, right: &Point<T, U3>)

pub fn set_zxy(&mut self, right: &Point<T, U3>)

pub fn set_zyx(&mut self, right: &Point<T, U3>)

pub fn set_yz(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_xz(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_zy(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_zx(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles3Mut<T> for Point<T, U5> where
    T: Scalar, 

pub fn set_xyz(&mut self, right: &Point<T, U3>)

pub fn set_xzy(&mut self, right: &Point<T, U3>)

pub fn set_yxz(&mut self, right: &Point<T, U3>)

pub fn set_yzx(&mut self, right: &Point<T, U3>)

pub fn set_zxy(&mut self, right: &Point<T, U3>)

pub fn set_zyx(&mut self, right: &Point<T, U3>)

pub fn set_yz(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_xz(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_zy(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_zx(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles3Mut<T> for Point<T, U3> where
    T: Scalar, 

pub fn set_xyz(&mut self, right: &Point<T, U3>)

pub fn set_xzy(&mut self, right: &Point<T, U3>)

pub fn set_yxz(&mut self, right: &Point<T, U3>)

pub fn set_yzx(&mut self, right: &Point<T, U3>)

pub fn set_zxy(&mut self, right: &Point<T, U3>)

pub fn set_zyx(&mut self, right: &Point<T, U3>)

pub fn set_yz(&mut self, right: &<Point<T, U3> as Swizzles2<T>>::Swizzle2)

pub fn set_xz(&mut self, right: &<Point<T, U3> as Swizzles2<T>>::Swizzle2)

pub fn set_zy(&mut self, right: &<Point<T, U3> as Swizzles2<T>>::Swizzle2)

pub fn set_zx(&mut self, right: &<Point<T, U3> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles3Mut<T> for Point<T, U4> where
    T: Scalar, 

pub fn set_xyz(&mut self, right: &Point<T, U3>)

pub fn set_xzy(&mut self, right: &Point<T, U3>)

pub fn set_yxz(&mut self, right: &Point<T, U3>)

pub fn set_yzx(&mut self, right: &Point<T, U3>)

pub fn set_zxy(&mut self, right: &Point<T, U3>)

pub fn set_zyx(&mut self, right: &Point<T, U3>)

pub fn set_yz(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_xz(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_zy(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_zx(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles4<T> for Point<T, U4> where
    T: Scalar, 

type Swizzle4 = Point<T, U4>

pub fn xyzw(&self) -> <Point<T, U4> as Swizzles4<T>>::Swizzle4

pub fn xyw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn yxw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wxy(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wyx(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn yzw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn zyw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wyz(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wzy(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn xzw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn zxw(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wxz(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn wzx(&self) -> <Point<T, U4> as Swizzles3<T>>::Swizzle3

pub fn xw(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn yw(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn zw(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn wx(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn wy(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

pub fn wz(&self) -> <Point<T, U4> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles4<T> for Point<T, U5> where
    T: Scalar, 

type Swizzle4 = Point<T, U4>

pub fn xyzw(&self) -> <Point<T, U5> as Swizzles4<T>>::Swizzle4

pub fn xyw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn yxw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wxy(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wyx(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn yzw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn zyw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wyz(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wzy(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn xzw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn zxw(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wxz(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn wzx(&self) -> <Point<T, U5> as Swizzles3<T>>::Swizzle3

pub fn xw(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn yw(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn zw(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn wx(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn wy(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

pub fn wz(&self) -> <Point<T, U5> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles4<T> for Point<T, U6> where
    T: Scalar, 

type Swizzle4 = Point<T, U4>

pub fn xyzw(&self) -> <Point<T, U6> as Swizzles4<T>>::Swizzle4

pub fn xyw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn yxw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wxy(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wyx(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn yzw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn zyw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wyz(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wzy(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn xzw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn zxw(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wxz(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn wzx(&self) -> <Point<T, U6> as Swizzles3<T>>::Swizzle3

pub fn xw(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn yw(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn zw(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn wx(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn wy(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

pub fn wz(&self) -> <Point<T, U6> as Swizzles2<T>>::Swizzle2

impl<T> Swizzles4Mut<T> for Point<T, U4> where
    T: Scalar, 

pub fn set_xyzw(&mut self, right: &<Point<T, U4> as Swizzles4<T>>::Swizzle4)

pub fn set_xyw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_yxw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wxy(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wyx(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_yzw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_zyw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wyz(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wzy(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_xzw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_zxw(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wxz(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_wzx(&mut self, right: &<Point<T, U4> as Swizzles3<T>>::Swizzle3)

pub fn set_xw(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_yw(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_zw(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_wx(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_wy(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

pub fn set_wz(&mut self, right: &<Point<T, U4> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles4Mut<T> for Point<T, U6> where
    T: Scalar, 

pub fn set_xyzw(&mut self, right: &<Point<T, U6> as Swizzles4<T>>::Swizzle4)

pub fn set_xyw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_yxw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wxy(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wyx(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_yzw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_zyw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wyz(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wzy(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_xzw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_zxw(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wxz(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_wzx(&mut self, right: &<Point<T, U6> as Swizzles3<T>>::Swizzle3)

pub fn set_xw(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_yw(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_zw(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_wx(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_wy(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

pub fn set_wz(&mut self, right: &<Point<T, U6> as Swizzles2<T>>::Swizzle2)

impl<T> Swizzles4Mut<T> for Point<T, U5> where
    T: Scalar, 

pub fn set_xyzw(&mut self, right: &<Point<T, U5> as Swizzles4<T>>::Swizzle4)

pub fn set_xyw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_yxw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wxy(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wyx(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_yzw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_zyw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wyz(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wzy(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_xzw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_zxw(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wxz(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_wzx(&mut self, right: &<Point<T, U5> as Swizzles3<T>>::Swizzle3)

pub fn set_xw(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_yw(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_zw(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_wx(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_wy(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

pub fn set_wz(&mut self, right: &<Point<T, U5> as Swizzles2<T>>::Swizzle2)

impl<T> ToPnt<Point<T, U1>> for Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U1>

impl<T> ToPnt<Point<T, U2>> for Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U2>

impl<T> ToPnt<Point<T, U3>> for Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U3>

impl<T> ToPnt<Point<T, U4>> for Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U4>

impl<T> ToPnt<Point<T, U5>> for Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U5>

impl<T> ToPnt<Point<T, U6>> for Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer> where
    T: Scalar, 

pub fn to_pnt(self) -> Point<T, U6>

impl<T> ToVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point<T, U1> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>

impl<T> ToVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point<T, U2> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>

impl<T> ToVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point<T, U3> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>

impl<T> ToVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point<T, U4> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>

impl<T> ToVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point<T, U5> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>

impl<T> ToVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point<T, U6> where
    T: Scalar, 

pub fn to_vec(
    self
) -> Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>

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

pub fn default_max_ulps() -> u32

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

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

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

The inverse of UlpsEq::ulps_eq.

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

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