Struct bevy_rapier2d::prelude::nalgebra::Point[−][src]

#[repr(C)]
pub struct Point<T, const D: usize> {
    pub coords: Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>,
}

Expand description

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<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

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

Implementations

impl<T, const D: usize> Point<T, D> where
    T: Scalar,

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

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(T) -> T,

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<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
    T: One,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,

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<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> Point<T, D>

👎 Deprecated:

Use Point::from(vector) instead.

Creates a new point with the given coordinates.

pub fn len(&self) -> usize[src]

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[src]

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[src]

👎 Deprecated:

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

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

pub fn iter(
    &self
) -> MatrixIter<'_, T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>ⓘNotable traits for MatrixIter<'a, T, R, C, S>
impl<'a, T, R, C, S> Iterator for MatrixIter<'a, T, R, C, S> where
    C: Dim,
    T: Scalar,
    S: 'a + Storage<T, R, C>,
    R: Dim,     type Item = &'a T;

Iterates through this point coordinates.

Example

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

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

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

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

pub fn iter_mut(
    &mut self
) -> MatrixIterMut<'_, T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>ⓘNotable traits for MatrixIterMut<'a, T, R, C, S>
impl<'a, T, R, C, S> Iterator for MatrixIterMut<'a, T, R, C, S> where
    C: Dim,
    T: Scalar,
    S: 'a + StorageMut<T, R, C>,
    R: Dim,     type Item = &'a mut T;

Mutably iterates through this point coordinates.

Example

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

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

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

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

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)[src]

Swaps two entries without bound-checking.

impl<T, const D: usize> Point<T, D> where
    T: Scalar + SimdPartialOrd,

pub fn inf(&self, other: &Point<T, D>) -> Point<T, D>[src]

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

pub fn sup(&self, other: &Point<T, D>) -> Point<T, D>[src]

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

pub fn inf_sup(&self, other: &Point<T, D>) -> (Point<T, D>, Point<T, D>)[src]

Computes the (infimum, supremum) of two points.

impl<T, const D: usize> Point<T, D> where
    T: Scalar,

Other construction methods

pub unsafe fn new_uninitialized() -> Point<T, D>[src]

Creates a new point with uninitialized coordinates.

pub fn origin() -> Point<T, D> where
    T: Zero,

Creates a new point with all coordinates equal to zero.

Example

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

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

pub fn from_slice(components: &[T]) -> Point<T, D>[src]

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<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> Option<Point<T, D>> where
    T: Scalar + Zero + One + ClosedDiv<T>,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,

Creates a new point from its homogeneous vector representation.

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

Example


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

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

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

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

pub fn cast<To>(self) -> Point<To, D> where
    To: Scalar,
    Point<To, D>: SupersetOf<Point<T, D>>,

Cast the components of self to another type.

Example

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

impl<T> Point<T, 1_usize>[src]

Construction from individual components

pub const fn new(x: T) -> Point<T, 1_usize>[src]

Initializes this point from its components.

Example

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

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

Swizzling

pub fn xx(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UTerm>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UTerm>>::Output == Greater,

Builds a new point from components of self.

pub fn xxx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UTerm>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UTerm>>::Output == Greater,

Builds a new point from components of self.

pub fn xy(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yx(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yy(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn xxy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn xyx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn xyy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yxx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yxy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yyx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn yyy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UTerm, B1>>>::Output == Greater,

Builds a new point from components of self.

pub fn xz(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yz(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zx(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zy(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zz(&self) -> Point<T, 2_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn xxz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn xyz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn xzx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn xzy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn xzz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yxz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yyz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yzx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yzy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn yzz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zxx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zxy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zxz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zyx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zyy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zyz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zzx(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zzy(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

pub fn zzz(&self) -> Point<T, 3_usize> where
    <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>>,
    <<Const<D> as ToTypenum>::Typenum as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,

Builds a new point from components of self.

impl<T> Point<T, 2_usize>[src]

pub const fn new(x: T, y: T) -> Point<T, 2_usize>[src]

Initializes this point from its components.

Example

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

impl<T> Point<T, 3_usize>[src]

pub const fn new(x: T, y: T, z: T) -> Point<T, 3_usize>[src]

Initializes this point from its components.

Example

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

impl<T> Point<T, 4_usize>[src]

pub const fn new(x: T, y: T, z: T, w: T) -> Point<T, 4_usize>[src]

Initializes this point from its components.

Example

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

impl<T> Point<T, 5_usize>[src]

pub const fn new(x: T, y: T, z: T, w: T, a: T) -> Point<T, 5_usize>[src]

Initializes this point from its components.

Example

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

impl<T> Point<T, 6_usize>[src]

pub const fn new(x: T, y: T, z: T, w: T, a: T, b: T) -> Point<T, 6_usize>[src]

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<T, const D: usize> AbsDiffEq<Point<T, D>> for Point<T, D> where
    T: Scalar + AbsDiffEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy,

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

Used for specifying relative comparisons.

pub fn default_epsilon() -> <Point<T, D> as AbsDiffEq<Point<T, D>>>::Epsilon[src]

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

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

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

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

The inverse of [AbsDiffEq::abs_diff_eq].

impl<'a, 'b, T, D2, SB, const D1: usize> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the + operator.

pub fn add(
    self, 
    right: &'b Matrix<T, D2, Const<1_usize>, SB>
) -> <&'a Point<T, D1> as Add<&'b Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the + operation. Read more

impl<'b, T, D2, SB, const D1: usize> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the + operator.

pub fn add(
    self, 
    right: &'b Matrix<T, D2, Const<1_usize>, SB>
) -> <Point<T, D1> as Add<&'b Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the + operation. Read more

impl<T, D2, SB, const D1: usize> Add<Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the + operator.

pub fn add(
    self, 
    right: Matrix<T, D2, Const<1_usize>, SB>
) -> <Point<T, D1> as Add<Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the + operation. Read more

impl<'a, T, D2, SB, const D1: usize> Add<Matrix<T, D2, Const<1_usize>, SB>> for &'a Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the + operator.

pub fn add(
    self, 
    right: Matrix<T, D2, Const<1_usize>, SB>
) -> <&'a Point<T, D1> as Add<Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the + operation. Read more

impl<'b, T, D2, SB, const D1: usize> AddAssign<&'b Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,

pub fn add_assign(&mut self, right: &'b Matrix<T, D2, Const<1_usize>, SB>)[src]

Performs the += operation. Read more

impl<T, D2, SB, const D1: usize> AddAssign<Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedAdd<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,

pub fn add_assign(&mut self, right: Matrix<T, D2, Const<1_usize>, SB>)[src]

Performs the += operation. Read more

impl<N> AsBytes for Point<N, 2_usize> where
    N: RealField,

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

Converts self to a slice of bytes.

impl<N> AsBytes for Point<N, 3_usize> where
    N: RealField,

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

Converts self to a slice of bytes.

impl<T, const D: usize> Bounded for Point<T, D> where
    T: Scalar + Bounded,

pub fn max_value() -> Point<T, D>[src]

returns the largest finite number this type can represent

pub fn min_value() -> Point<T, D>[src]

returns the smallest finite number this type can represent

impl<T, const D: usize> Clone for Point<T, D> where
    T: Clone,

pub fn clone(&self) -> Point<T, D>[src]

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0 [src]

Performs copy-assignment from source. Read more

impl<T, const D: usize> Debug for Point<T, D> where
    T: Debug,

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

Formats the value using the given formatter. Read more

impl<T> Deref for Point<T, 1_usize> where
    T: Scalar,

type Target = X<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 1_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> Deref for Point<T, 2_usize> where
    T: Scalar,

type Target = XY<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 2_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> Deref for Point<T, 5_usize> where
    T: Scalar,

type Target = XYZWA<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 5_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> Deref for Point<T, 3_usize> where
    T: Scalar,

type Target = XYZ<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 3_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> Deref for Point<T, 4_usize> where
    T: Scalar,

type Target = XYZW<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 4_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> Deref for Point<T, 6_usize> where
    T: Scalar,

type Target = XYZWAB<T>

The resulting type after dereferencing.

pub fn deref(&self) -> &<Point<T, 6_usize> as Deref>::Target[src]

Dereferences the value.

impl<T> DerefMut for Point<T, 6_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 6_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T> DerefMut for Point<T, 1_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 1_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T> DerefMut for Point<T, 3_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 3_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T> DerefMut for Point<T, 5_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 5_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T> DerefMut for Point<T, 2_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 2_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T> DerefMut for Point<T, 4_usize> where
    T: Scalar,

pub fn deref_mut(&mut self) -> &mut <Point<T, 4_usize> as Deref>::Target[src]

Mutably dereferences the value.

impl<T, const D: usize> Display for Point<T, D> where
    T: Scalar + Display,

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

Formats the value using the given formatter. Read more

impl<'a, T, const D: usize> Div<T> for &'a Point<T, D> where
    T: Scalar + ClosedDiv<T>,

type Output = Point<T, D>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T, const D: usize> Div<T> for Point<T, D> where
    T: Scalar + ClosedDiv<T>,

type Output = Point<T, D>

The resulting type after applying the / operator.

pub fn div(self, right: T) -> <Point<T, D> as Div<T>>::Output[src]

Performs the / operation. Read more

impl<T, const D: usize> DivAssign<T> for Point<T, D> where
    T: Scalar + ClosedDiv<T>,

pub fn div_assign(&mut self, right: T)[src]

Performs the /= operation. Read more

impl<T, const D: usize> From<[Point<<T as SimdValue>::Element, D>; 16]> for Point<T, D> where
    T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 16]>,
    <T as SimdValue>::Element: Scalar,
    <T as SimdValue>::Element: Copy,
    <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>, Const<1_usize>>>::Buffer: Copy,

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

Performs the conversion.

impl<T, const D: usize> From<[Point<<T as SimdValue>::Element, D>; 2]> for Point<T, D> where
    T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 2]>,
    <T as SimdValue>::Element: Scalar,
    <T as SimdValue>::Element: Copy,
    <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>, Const<1_usize>>>::Buffer: Copy,

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

Performs the conversion.

impl<T, const D: usize> From<[Point<<T as SimdValue>::Element, D>; 4]> for Point<T, D> where
    T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 4]>,
    <T as SimdValue>::Element: Scalar,
    <T as SimdValue>::Element: Copy,
    <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>, Const<1_usize>>>::Buffer: Copy,

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

Performs the conversion.

impl<T, const D: usize> From<[Point<<T as SimdValue>::Element, D>; 8]> for Point<T, D> where
    T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 8]>,
    <T as SimdValue>::Element: Scalar,
    <T as SimdValue>::Element: Copy,
    <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>, Const<1_usize>>>::Buffer: Copy,

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

Performs the conversion.

impl<T, const D: usize> From<[T; D]> for Point<T, D> where
    T: Scalar,

pub fn from(coords: [T; D]) -> Point<T, D>[src]

Performs the conversion.

impl From<BVec2> for Point<bool, 2_usize>[src]

pub fn from(e: BVec2) -> Point<bool, 2_usize>[src]

Performs the conversion.

impl From<BVec3> for Point<bool, 3_usize>[src]

pub fn from(e: BVec3) -> Point<bool, 3_usize>[src]

Performs the conversion.

impl From<BVec4> for Point<bool, 4_usize>[src]

pub fn from(e: BVec4) -> Point<bool, 4_usize>[src]

Performs the conversion.

impl From<DVec2> for Point<f64, 2_usize>[src]

pub fn from(e: DVec2) -> Point<f64, 2_usize>[src]

Performs the conversion.

impl From<DVec3> for Point<f64, 3_usize>[src]

pub fn from(e: DVec3) -> Point<f64, 3_usize>[src]

Performs the conversion.

impl From<DVec4> for Point<f64, 4_usize>[src]

pub fn from(e: DVec4) -> Point<f64, 4_usize>[src]

Performs the conversion.

impl From<IVec2> for Point<i32, 2_usize>[src]

pub fn from(e: IVec2) -> Point<i32, 2_usize>[src]

Performs the conversion.

impl From<IVec3> for Point<i32, 3_usize>[src]

pub fn from(e: IVec3) -> Point<i32, 3_usize>[src]

Performs the conversion.

impl From<IVec4> for Point<i32, 4_usize>[src]

pub fn from(e: IVec4) -> Point<i32, 4_usize>[src]

Performs the conversion.

impl<T, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>> for Point<T, D> where
    T: Scalar,

pub fn from(
    coords: Matrix<T, Const<D>, Const<1_usize>, <DefaultAllocator as Allocator<T, Const<D>, Const<1_usize>>>::Buffer>
) -> Point<T, D>

Performs the conversion.

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

pub fn from(coords: Point<T, D>) -> Isometry<T, R, D>[src]

Performs the conversion.

impl<T, const D: usize> From<Point<T, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
    T: Scalar + Zero + One,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,

pub fn from(
    t: Point<T, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>

Performs the conversion.

impl<T, const D: usize> From<Point<T, D>> for Translation<T, D> where
    T: Scalar,

pub fn from(pt: Point<T, D>) -> Translation<T, D>[src]

Performs the conversion.

impl From<UVec2> for Point<u32, 2_usize>[src]

pub fn from(e: UVec2) -> Point<u32, 2_usize>[src]

Performs the conversion.

impl From<UVec3> for Point<u32, 3_usize>[src]

pub fn from(e: UVec3) -> Point<u32, 3_usize>[src]

Performs the conversion.

impl From<UVec4> for Point<u32, 4_usize>[src]

pub fn from(e: UVec4) -> Point<u32, 4_usize>[src]

Performs the conversion.

impl From<Vec2> for Point<f32, 2_usize>[src]

pub fn from(e: Vec2) -> Point<f32, 2_usize>[src]

Performs the conversion.

impl From<Vec3> for Point<f32, 3_usize>[src]

pub fn from(e: Vec3) -> Point<f32, 3_usize>[src]

Performs the conversion.

impl From<Vec3A> for Point<f32, 3_usize>[src]

pub fn from(e: Vec3A) -> Point<f32, 3_usize>[src]

Performs the conversion.

impl From<Vec4> for Point<f32, 4_usize>[src]

pub fn from(e: Vec4) -> Point<f32, 4_usize>[src]

Performs the conversion.

impl<T, const D: usize> Hash for Point<T, D> where
    T: Scalar + Hash,

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

Feeds this value into the given Hasher. Read more

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

1.3.0 [src]

Feeds a slice of this type into the given Hasher. Read more

impl<T, const D: usize> Index<usize> for Point<T, D> where
    T: Scalar,

type Output = T

The returned type after indexing.

pub fn index(&self, i: usize) -> &<Point<T, D> as Index<usize>>::Output[src]

Performs the indexing (container[index]) operation. Read more

impl<T, const D: usize> IndexMut<usize> for Point<T, D> where
    T: Scalar,

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

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

impl<T, const D: usize> Into<[T; D]> for Point<T, D> where
    T: Scalar,

pub fn into(self) -> [T; D][src]

Performs the conversion.

impl<'b, T> Mul<&'b Point<T, 2_usize>> for Unit<Complex<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 2_usize>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, 'b, T> Mul<&'b Point<T, 2_usize>> for &'a Unit<Complex<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 2_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: &'b Point<T, 2_usize>
) -> <&'a Unit<Complex<T>> as Mul<&'b Point<T, 2_usize>>>::Output

Performs the * operation. Read more

impl<'b, T> Mul<&'b Point<T, 3_usize>> for Unit<Quaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, 'b, T> Mul<&'b Point<T, 3_usize>> for &'a Unit<DualQuaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: &'b Point<T, 3_usize>
) -> <&'a Unit<DualQuaternion<T>> as Mul<&'b Point<T, 3_usize>>>::Output

Performs the * operation. Read more

impl<'b, T> Mul<&'b Point<T, 3_usize>> for Unit<DualQuaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: &'b Point<T, 3_usize>
) -> <Unit<DualQuaternion<T>> as Mul<&'b Point<T, 3_usize>>>::Output

Performs the * operation. Read more

impl<'a, 'b, T> Mul<&'b Point<T, 3_usize>> for &'a Unit<Quaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'b, T, C, const D: usize> Mul<&'b Point<T, D>> for Transform<T, C, D> where
    C: TCategory,
    T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, 'b, T, C, const D: usize> Mul<&'b Point<T, D>> for &'a Transform<T, C, D> where
    C: TCategory,
    T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, R1>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, R1>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<Point<T, 2_usize>> for Unit<Complex<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 2_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: Point<T, 2_usize>
) -> <Unit<Complex<T>> as Mul<Point<T, 2_usize>>>::Output

Performs the * operation. Read more

impl<'a, T> Mul<Point<T, 2_usize>> for &'a Unit<Complex<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 2_usize>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, T> Mul<Point<T, 3_usize>> for &'a Unit<Quaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<Point<T, 3_usize>> for Unit<Quaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: Point<T, 3_usize>
) -> <Unit<Quaternion<T>> as Mul<Point<T, 3_usize>>>::Output

Performs the * operation. Read more

impl<T> Mul<Point<T, 3_usize>> for Unit<DualQuaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: Point<T, 3_usize>
) -> <Unit<DualQuaternion<T>> as Mul<Point<T, 3_usize>>>::Output

Performs the * operation. Read more

impl<'a, T> Mul<Point<T, 3_usize>> for &'a Unit<DualQuaternion<T>> where
    T: SimdRealField,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, 3_usize>

The resulting type after applying the * operator.

pub fn mul(
    self, 
    rhs: Point<T, 3_usize>
) -> <&'a Unit<DualQuaternion<T>> as Mul<Point<T, 3_usize>>>::Output

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T, const D: usize> Mul<Point<T, D>> for Translation<T, D> where
    T: ClosedAdd<T> + Scalar,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D>, Const<D>>>::Representative == Const<D>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T, R, const D: usize> Mul<Point<T, D>> for Similarity<T, R, D> where
    T: SimdRealField,
    R: AbstractRotation<T, D>,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, T, C, const D: usize> Mul<Point<T, D>> for &'a Transform<T, C, D> where
    C: TCategory,
    T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T, C, const D: usize> Mul<Point<T, D>> for Transform<T, C, D> where
    C: TCategory,
    T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T, R, const D: usize> Mul<Point<T, D>> for Isometry<T, R, D> where
    T: SimdRealField,
    R: AbstractRotation<T, D>,
    <T as SimdValue>::Element: SimdRealField,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, R1>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Point<T, R1>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<'a, T, const D: usize> Mul<T> for &'a Point<T, D> where
    T: Scalar + ClosedMul<T>,

type Output = Point<T, D>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T, const D: usize> Mul<T> for Point<T, D> where
    T: Scalar + ClosedMul<T>,

type Output = Point<T, D>

The resulting type after applying the * operator.

pub fn mul(self, right: T) -> <Point<T, D> as Mul<T>>::Output[src]

Performs the * operation. Read more

impl<T, const D: usize> MulAssign<T> for Point<T, D> where
    T: Scalar + ClosedMul<T>,

pub fn mul_assign(&mut self, right: T)[src]

Performs the *= operation. Read more

impl<T, const D: usize> Neg for Point<T, D> where
    T: Scalar + ClosedNeg,

type Output = Point<T, D>

The resulting type after applying the - operator.

pub fn neg(self) -> <Point<T, D> as Neg>::Output[src]

Performs the unary - operation. Read more

impl<'a, T, const D: usize> Neg for &'a Point<T, D> where
    T: Scalar + ClosedNeg,

type Output = Point<T, D>

The resulting type after applying the - operator.

pub fn neg(self) -> <&'a Point<T, D> as Neg>::Output[src]

Performs the unary - operation. Read more

impl<T, const D: usize> PartialEq<Point<T, D>> for Point<T, D> where
    T: Scalar,

pub fn eq(&self, right: &Point<T, D>) -> bool[src]

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

#[must_use]
fn ne(&self, other: &Rhs) -> bool

1.0.0 [src]

This method tests for !=.

impl<T, const D: usize> PartialOrd<Point<T, D>> for Point<T, D> where
    T: Scalar + PartialOrd<T>,

pub fn partial_cmp(&self, other: &Point<T, D>) -> Option<Ordering>[src]

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

pub fn lt(&self, right: &Point<T, D>) -> bool[src]

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

pub fn le(&self, right: &Point<T, D>) -> bool[src]

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

pub fn gt(&self, right: &Point<T, D>) -> bool[src]

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

pub fn ge(&self, right: &Point<T, D>) -> bool[src]

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

impl<T, const D: usize> RelativeEq<Point<T, D>> for Point<T, D> where
    T: Scalar + RelativeEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy,

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

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

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

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

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

The inverse of [RelativeEq::relative_eq].

impl<T, const D: usize> SimdValue for Point<T, D> where
    T: Scalar + SimdValue,
    <T as SimdValue>::Element: Scalar,

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

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

type SimdBool = <T as SimdValue>::SimdBool

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

pub fn lanes() -> usize[src]

The number of lanes of this SIMD value.

pub fn splat(val: <Point<T, D> as SimdValue>::Element) -> Point<T, D>[src]

Initializes an SIMD value with each lanes set to val.

pub fn extract(&self, i: usize) -> <Point<T, D> as SimdValue>::Element[src]

Extracts the i-th lane of self. Read more

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

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

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

Replaces the i-th lane of self by val. Read more

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

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

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

Merges self and other depending on the lanes of cond. Read more

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

Applies a function to each lane of self. Read more

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

impl<'a, 'b, T, D2, SB, const D1: usize> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the - operator.

pub fn sub(
    self, 
    right: &'b Matrix<T, D2, Const<1_usize>, SB>
) -> <&'a Point<T, D1> as Sub<&'b Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the - operation. Read more

impl<'b, T, D2, SB, const D1: usize> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the - operator.

pub fn sub(
    self, 
    right: &'b Matrix<T, D2, Const<1_usize>, SB>
) -> <Point<T, D1> as Sub<&'b Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the - operation. Read more

impl<'a, 'b, T, const D: usize> Sub<&'b Point<T, D>> for &'a Point<T, D> where
    T: ClosedSub<T> + Scalar,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D>, Const<D>>>::Representative == Const<D>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl<'b, T, const D: usize> Sub<&'b Point<T, D>> for Point<T, D> where
    T: ClosedSub<T> + Scalar,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D>, Const<D>>>::Representative == Const<D>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl<T, D2, SB, const D1: usize> Sub<Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the - operator.

pub fn sub(
    self, 
    right: Matrix<T, D2, Const<1_usize>, SB>
) -> <Point<T, D1> as Sub<Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the - operation. Read more

impl<'a, T, D2, SB, const D1: usize> Sub<Matrix<T, D2, Const<1_usize>, SB>> for &'a Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D1>, D2>>::Representative == Const<D1>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Point<T, D1>

The resulting type after applying the - operator.

pub fn sub(
    self, 
    right: Matrix<T, D2, Const<1_usize>, SB>
) -> <&'a Point<T, D1> as Sub<Matrix<T, D2, Const<1_usize>, SB>>>::Output

Performs the - operation. Read more

impl<T, const D: usize> Sub<Point<T, D>> for Point<T, D> where
    T: ClosedSub<T> + Scalar,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D>, Const<D>>>::Representative == Const<D>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl<'a, T, const D: usize> Sub<Point<T, D>> for &'a Point<T, D> where
    T: ClosedSub<T> + Scalar,
    ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>>,
    ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
    <ShapeConstraint as SameNumberOfRows<Const<D>, Const<D>>>::Representative == Const<D>,
    <ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,

type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl<'b, T, D2, SB, const D1: usize> SubAssign<&'b Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,

pub fn sub_assign(&mut self, right: &'b Matrix<T, D2, Const<1_usize>, SB>)[src]

Performs the -= operation. Read more

impl<T, D2, SB, const D1: usize> SubAssign<Matrix<T, D2, Const<1_usize>, SB>> for Point<T, D1> where
    T: Scalar + ClosedSub<T>,
    D2: Dim,
    SB: Storage<T, D2, Const<1_usize>>,
    ShapeConstraint: SameNumberOfRows<Const<D1>, D2>,

pub fn sub_assign(&mut self, right: Matrix<T, D2, Const<1_usize>, SB>)[src]

Performs the -= operation. Read more

impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>> for Point<T1, D> where
    T1: Scalar,
    T2: Scalar + Zero + One + ClosedDiv<T2> + SupersetOf<T1>,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
    DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,

pub fn to_superset(
    &self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>

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

pub fn is_in_subset(
    v: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::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<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> Point<T1, D>

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

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

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

impl<T1, T2, const D: usize> SubsetOf<Point<T2, D>> for Point<T1, D> where
    T1: Scalar,
    T2: Scalar + SupersetOf<T1>,

pub fn to_superset(&self) -> Point<T2, D>[src]

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

pub fn is_in_subset(m: &Point<T2, D>) -> bool[src]

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

pub fn from_superset_unchecked(m: &Point<T2, D>) -> Point<T1, D>[src]

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

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

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

impl<T, const D: usize> UlpsEq<Point<T, D>> for Point<T, D> where
    T: Scalar + UlpsEq<T>,
    <T as AbsDiffEq<T>>::Epsilon: Copy,

pub fn default_max_ulps() -> u32[src]

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

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

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

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

The inverse of [UlpsEq::ulps_eq].

impl<T, const D: usize> Copy for Point<T, D> where
    T: Scalar + Copy,

impl<T, const D: usize> Eq for Point<T, D> where
    T: Scalar + Eq,

Auto Trait Implementations

impl<T, const D: usize> RefUnwindSafe for Point<T, D> where
    T: RefUnwindSafe,

impl<T, const D: usize> Send for Point<T, D> where
    T: Send,

impl<T, const D: usize> Sync for Point<T, D> where
    T: Sync,

impl<T, const D: usize> Unpin for Point<T, D> where
    T: Unpin,

impl<T, const D: usize> UnwindSafe for Point<T, D> where
    T: UnwindSafe,

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized,

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> CallHasher for T where
    T: Hash + ?Sized,

pub default fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64 where
    H: Hash + ?Sized,
    B: BuildHasher,

impl<T> Downcast for T where
    T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

pub fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

impl<T> DowncastSync for T where
    T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + 'static + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait. Read more

impl<T> DynEq for T where
    T: Any + Eq,

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn dyn_eq(&self, other: &(dyn DynEq + 'static)) -> bool

impl<T> DynHash for T where
    T: DynEq + Hash,

pub fn as_dyn_eq(&self) -> &(dyn DynEq + 'static)

pub fn dyn_hash(&self, state: &mut dyn Hasher)

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>[src]

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T where
    U: From<T>,

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> Pointable for T

pub const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

pub unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

pub unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

pub unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> Scalar for T where
    T: Copy + PartialEq<T> + Debug + Any,

pub fn inlined_clone(&self) -> T[src]

Performance hack: Clone doesn’t get inlined for Copy types in debug mode, so make it inline anyway.

fn is<T>() -> bool where
    T: Scalar,

Tests if Self the same as the type T Read more

impl<T> SimdPartialOrd for T where
    T: SimdValue<Element = T, SimdBool = bool> + PartialOrd<T>,

pub fn simd_gt(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise greater than > comparison.

pub fn simd_lt(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise less than < comparison.

pub fn simd_ge(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise greater or equal >= comparison.

pub fn simd_le(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise less or equal <= comparison.

pub fn simd_eq(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise equal == comparison.

pub fn simd_ne(self, other: T) -> <T as SimdValue>::SimdBool

Lanewise not equal != comparison.

pub fn simd_max(self, other: T) -> T

Lanewise max value.

pub fn simd_min(self, other: T) -> T

Lanewise min value.

pub fn simd_clamp(self, min: T, max: T) -> T

Clamps each lane of self between the corresponding lane of min and max.

pub fn simd_horizontal_min(self) -> <T as SimdValue>::Element

The min value among all lanes of self.

pub fn simd_horizontal_max(self) -> <T as SimdValue>::Element

The max value among all lanes of self.

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>,

pub fn to_subset(&self) -> Option<SS>

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

pub fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

pub fn to_subset_unchecked(&self) -> SS

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

pub fn from_subset(element: &SS) -> SP

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

impl<T> ToOwned for T where
    T: Clone,

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
    T: Display + ?Sized,

pub default fn to_string(&self) -> String[src]

Converts the given value to a String. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.

impl<T> TypeData for T where
    T: 'static + Send + Sync + Clone,

pub fn clone_type_data(&self) -> Box<dyn TypeData + 'static, Global>

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,

pub fn vzip(self) -> V

impl<T, Right> ClosedAdd<Right> for T where
    T: Add<Right, Output = T> + AddAssign<Right>,

impl<T, Right> ClosedDiv<Right> for T where
    T: Div<Right, Output = T> + DivAssign<Right>,

impl<T, Right> ClosedMul<Right> for T where
    T: Mul<Right, Output = T> + MulAssign<Right>,

impl<T> ClosedNeg for T where
    T: Neg<Output = T>,

impl<T, Right> ClosedSub<Right> for T where
    T: Sub<Right, Output = T> + SubAssign<Right>,

impl<T> Component for T where
    T: 'static + Send + Sync,