Struct OPoint

#[repr(C)]
pub struct OPoint<T, D>
where
    T: Scalar,
    D: DimName,
    DefaultAllocator: Allocator<T, D>,
{
    pub coords: Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::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<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>

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

Implementations

impl<T, D> OPoint<T, D>

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

pub fn map<T2, F>(&self, f: F) -> OPoint<T2, D>

where T2: Scalar, F: FnMut(T) -> T2, DefaultAllocator: Allocator<T2, D>,

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

Example

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

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

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

where F: FnMut(&mut 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 = *e * 10.0);
assert_eq!(p, Point2::new(10.0, 20.0));

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

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

where T: One, D: DimNameAdd<Const<1>>, DefaultAllocator: Allocator<T, <D as DimNameAdd<Const<1>>>::Output>,

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 lerp(&self, rhs: &OPoint<T, D>, t: T) -> OPoint<T, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul,

Linear interpolation between two points.

Returns self * (1.0 - t) + rhs.coords * t, i.e., the linear blend of the points self and rhs using the scalar value t.

The value for a is not restricted to the range [0, 1].

Examples:

let a = Point3::new(1.0, 2.0, 3.0);
let b = Point3::new(10.0, 20.0, 30.0);
assert_eq!(a.lerp(&b, 0.1), Point3::new(1.9, 3.8, 5.7));

pub fn from_coordinates( coords: Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>, ) -> OPoint<T, 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<'_, T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>

Iterates through this point coordinates.

Example

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

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

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

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

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

Mutably iterates through this point coordinates.

Example

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

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

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

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

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

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

Swaps two entries without bound-checking.

impl<T, D> OPoint<T, D>

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

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

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

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

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

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

Computes the (infimum, supremum) of two points.

impl<T, D> OPoint<T, D>

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

Other construction methods

pub fn origin() -> OPoint<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]) -> OPoint<T, 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<T, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1>>>::Output>>::Buffer>, ) -> Option<OPoint<T, D>>

where T: Scalar + Zero + One + ClosedDiv, D: DimNameAdd<Const<1>>, DefaultAllocator: Allocator<T, <D as DimNameAdd<Const<1>>>::Output>,

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) -> OPoint<To, D>

where To: Scalar, OPoint<To, D>: SupersetOf<OPoint<T, D>>, DefaultAllocator: Allocator<To, D>,

Cast the components of self to another type.

Example

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

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

where T: Scalar,

Construction from individual components

pub const fn new(x: T) -> OPoint<T, Const<1>>

Initializes this point from its components.

Example

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

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

where T: Scalar,

pub const fn new(x: T, y: T) -> OPoint<T, Const<2>>

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> OPoint<T, Const<3>>

where T: Scalar,

pub const fn new(x: T, y: T, z: T) -> OPoint<T, Const<3>>

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> OPoint<T, Const<4>>

where T: Scalar,

pub const fn new(x: T, y: T, z: T, w: T) -> OPoint<T, Const<4>>

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> OPoint<T, Const<5>>

where T: Scalar,

pub const fn new(x: T, y: T, z: T, w: T, a: T) -> OPoint<T, Const<5>>

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> OPoint<T, Const<6>>

where T: Scalar,

pub const fn new(x: T, y: T, z: T, w: T, a: T, b: T) -> OPoint<T, Const<6>>

Initializes this point from its components.

Example

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

impl<T, const D: usize> OPoint<T, Const<D>>

where T: Scalar, Const<D>: ToTypenum,

Swizzling

pub fn xx(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UTerm, Output = Greater>,

Builds a new point from components of self.

pub fn xxx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UTerm, Output = Greater>,

Builds a new point from components of self.

pub fn xy(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yx(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yy(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn xxy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn xyx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn xyy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yxx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yxy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yyx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn yyy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UTerm, B1>, Output = Greater>,

Builds a new point from components of self.

pub fn xz(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yz(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zx(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zy(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zz(&self) -> OPoint<T, Const<2>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn xxz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn xyz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn xzx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn xzy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn xzz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yxz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yyz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yzx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yzy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn yzz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zxx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zxy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zxz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zyx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zyy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zyz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zzx(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zzy(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

pub fn zzz(&self) -> OPoint<T, Const<3>>

where <Const<D> as ToTypenum>::Typenum: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,

Builds a new point from components of self.

Trait Implementations

impl<T, D> AbsDiffEq for OPoint<T, D>

where T: Scalar + AbsDiffEq, D: DimName, <T as AbsDiffEq>::Epsilon: Clone, DefaultAllocator: Allocator<T, D>,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <OPoint<T, D> as AbsDiffEq>::Epsilon

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

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

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

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

The inverse of AbsDiffEq::abs_diff_eq.

impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b, T, D1, D2, SB> AddAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

where D1: DimName, D2: Dim, T: Scalar + ClosedAdd, SB: Storage<T, D2>, ShapeConstraint: SameNumberOfRows<D1, D2>, DefaultAllocator: Allocator<T, D1>,

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

Performs the += operation.

impl<T, D1, D2, SB> AddAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

where D1: DimName, D2: Dim, T: Scalar + ClosedAdd, SB: Storage<T, D2>, ShapeConstraint: SameNumberOfRows<D1, D2>, DefaultAllocator: Allocator<T, D1>,

fn add_assign(&mut self, right: Matrix<T, D2, Const<1>, SB>)

Performs the += operation.

impl<T: Scalar> AsPnt<OPoint<T, Const<1>>> for Vector1<T>

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

impl<T: Scalar> AsPnt<OPoint<T, Const<2>>> for Vector2<T>

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

impl<T: Scalar> AsPnt<OPoint<T, Const<3>>> for Vector3<T>

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

impl<T: Scalar> AsPnt<OPoint<T, Const<4>>> for Vector4<T>

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

impl<T: Scalar> AsPnt<OPoint<T, Const<5>>> for Vector5<T>

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

impl<T: Scalar> AsPnt<OPoint<T, Const<6>>> for Vector6<T>

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

impl<T, D> Bounded for OPoint<T, D>

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

fn max_value() -> OPoint<T, D>

Returns the largest finite number this type can represent

fn min_value() -> OPoint<T, D>

Returns the smallest finite number this type can represent

impl<T, D> Clone for OPoint<T, D>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, D> Debug for OPoint<T, D>

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

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

Formats the value using the given formatter.

impl<T, D> Default for OPoint<T, D>

where T: Scalar + Zero, D: DimName, DefaultAllocator: Allocator<T, D>,

fn default() -> OPoint<T, D>

Returns the “default value” for a type.

impl<T> Deref for OPoint<T, Const<1>>

where T: Scalar,

type Target = X<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<1>> as Deref>::Target

Dereferences the value.

impl<T> Deref for OPoint<T, Const<2>>

where T: Scalar,

type Target = XY<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<2>> as Deref>::Target

Dereferences the value.

impl<T> Deref for OPoint<T, Const<3>>

where T: Scalar,

type Target = XYZ<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<3>> as Deref>::Target

Dereferences the value.

impl<T> Deref for OPoint<T, Const<4>>

where T: Scalar,

type Target = XYZW<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<4>> as Deref>::Target

Dereferences the value.

impl<T> Deref for OPoint<T, Const<5>>

where T: Scalar,

type Target = XYZWA<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<5>> as Deref>::Target

Dereferences the value.

impl<T> Deref for OPoint<T, Const<6>>

where T: Scalar,

type Target = XYZWAB<T>

The resulting type after dereferencing.

fn deref(&self) -> &<OPoint<T, Const<6>> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for OPoint<T, Const<1>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<1>> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for OPoint<T, Const<2>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<2>> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for OPoint<T, Const<3>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<3>> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for OPoint<T, Const<4>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<4>> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for OPoint<T, Const<5>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<5>> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for OPoint<T, Const<6>>

where T: Scalar,

fn deref_mut(&mut self) -> &mut <OPoint<T, Const<6>> as Deref>::Target

Mutably dereferences the value.

impl<T, D> Display for OPoint<T, D>

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

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

Formats the value using the given formatter.

impl<'a, T, D> Div<T> for &'a OPoint<T, D>

where T: Scalar + ClosedDiv, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, D> Div<T> for OPoint<T, D>

where T: Scalar + ClosedDiv, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the / operator.

fn div(self, right: T) -> <OPoint<T, D> as Div<T>>::Output

Performs the / operation.

impl<T, D> DivAssign<T> for OPoint<T, D>

where T: Scalar + ClosedDiv, D: DimName, DefaultAllocator: Allocator<T, D>,

fn div_assign(&mut self, right: T)

Performs the /= operation.

impl<T, const D: usize> From<[OPoint<<T as SimdValue>::Element, Const<D>>; 16]> for OPoint<T, Const<D>>

where T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 16]>, <T as SimdValue>::Element: Scalar + Copy, <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>>>::Buffer: Copy,

fn from( arr: [OPoint<<T as SimdValue>::Element, Const<D>>; 16], ) -> OPoint<T, Const<D>>

Converts to this type from the input type.

impl<T, const D: usize> From<[OPoint<<T as SimdValue>::Element, Const<D>>; 2]> for OPoint<T, Const<D>>

where T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 2]>, <T as SimdValue>::Element: Scalar + Copy, <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>>>::Buffer: Copy,

fn from( arr: [OPoint<<T as SimdValue>::Element, Const<D>>; 2], ) -> OPoint<T, Const<D>>

Converts to this type from the input type.

impl<T, const D: usize> From<[OPoint<<T as SimdValue>::Element, Const<D>>; 4]> for OPoint<T, Const<D>>

where T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 4]>, <T as SimdValue>::Element: Scalar + Copy, <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>>>::Buffer: Copy,

fn from( arr: [OPoint<<T as SimdValue>::Element, Const<D>>; 4], ) -> OPoint<T, Const<D>>

Converts to this type from the input type.

impl<T, const D: usize> From<[OPoint<<T as SimdValue>::Element, Const<D>>; 8]> for OPoint<T, Const<D>>

where T: Scalar + Copy + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 8]>, <T as SimdValue>::Element: Scalar + Copy, <DefaultAllocator as Allocator<<T as SimdValue>::Element, Const<D>>>::Buffer: Copy,

fn from( arr: [OPoint<<T as SimdValue>::Element, Const<D>>; 8], ) -> OPoint<T, Const<D>>

Converts to this type from the input type.

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

where T: Scalar,

fn from(coords: [T; D]) -> OPoint<T, Const<D>>

Converts to this type from the input type.

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

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

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

Converts to this type from the input type.

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

where T: SimdRealField, R: AbstractRotation<T, D>,

fn from(coords: OPoint<T, Const<D>>) -> Isometry<T, R, D>

Converts to this type from the input type.

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

where T: Scalar,

fn from(pt: OPoint<T, Const<D>>) -> Scale<T, D>

Converts to this type from the input type.

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

where T: Scalar,

fn from(pt: OPoint<T, Const<D>>) -> Translation<T, D>

Converts to this type from the input type.

impl<T, D> From<OPoint<T, D>> for Matrix<T, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1>>>::Output>>::Buffer>

where T: Scalar + Zero + One, D: DimName + DimNameAdd<Const<1>>, DefaultAllocator: Allocator<T, <D as DimNameAdd<Const<1>>>::Output> + Allocator<T, D>,

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

Converts to this type from the input type.

impl<T, D> Hash for OPoint<T, D>

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

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

where H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, D> Index<usize> for OPoint<T, D>

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

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, D> IndexMut<usize> for OPoint<T, D>

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

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

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

impl<'a, T: Scalar> IntoPnt<OPoint<T, Const<2>>> for &'a [T]

fn into_pnt(self) -> Point2<T>

impl<T: Scalar> IntoPnt<OPoint<T, Const<2>>> for [T; 2]

fn into_pnt(self) -> Point2<T>

impl<'a, T: Scalar> IntoPnt<OPoint<T, Const<3>>> for &'a [T]

fn into_pnt(self) -> Point3<T>

impl<T: Scalar> IntoPnt<OPoint<T, Const<3>>> for [T; 3]

fn into_pnt(self) -> Point3<T>

impl<'a, T: Scalar> IntoPnt<OPoint<T, Const<4>>> for &'a [T]

fn into_pnt(self) -> Point4<T>

impl<T: Scalar> IntoPnt<OPoint<T, Const<4>>> for [T; 4]

fn into_pnt(self) -> Point4<T>

impl<T: Scalar> JoinPnt<T, OPoint<T, Const<2>>> for Point2<T>

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

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

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<2>>> for &'a Unit<Complex<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T> Mul<&'b OPoint<T, Const<2>>> for Unit<Complex<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<3>>> for &'a Unit<DualQuaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'b OPoint<T, Const<3>>> for &'a Unit<Quaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T> Mul<&'b OPoint<T, Const<3>>> for Unit<DualQuaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T> Mul<&'b OPoint<T, Const<3>>> for Unit<Quaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Rotation<T, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Scale<T, D>

where T: Scalar + ClosedMul, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

fn mul( self, right: &'b OPoint<T, Const<D>>, ) -> <&'a Scale<T, D> as Mul<&'b OPoint<T, Const<D>>>>::Output

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Transform<T, C, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for &'a Translation<T, D>

where T: Scalar + ClosedAdd, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Rotation<T, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Scale<T, D>

where T: Scalar + ClosedMul, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

fn mul( self, right: &'b OPoint<T, Const<D>>, ) -> <Scale<T, D> as Mul<&'b OPoint<T, Const<D>>>>::Output

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T, C, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Transform<T, C, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T, const D: usize> Mul<&'b OPoint<T, Const<D>>> for Translation<T, D>

where T: Scalar + ClosedAdd, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<OPoint<T, Const<2>>> for &'a Unit<Complex<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<OPoint<T, Const<2>>> for Unit<Complex<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

fn mul( self, rhs: OPoint<T, Const<2>>, ) -> <Unit<Complex<T>> as Mul<OPoint<T, Const<2>>>>::Output

Performs the * operation.

impl<'a, T> Mul<OPoint<T, Const<3>>> for &'a Unit<DualQuaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<OPoint<T, Const<3>>> for &'a Unit<Quaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<OPoint<T, Const<3>>> for Unit<DualQuaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

fn mul( self, rhs: OPoint<T, Const<3>>, ) -> <Unit<DualQuaternion<T>> as Mul<OPoint<T, Const<3>>>>::Output

Performs the * operation.

impl<T> Mul<OPoint<T, Const<3>>> for Unit<Quaternion<T>>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,

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

The resulting type after applying the * operator.

fn mul( self, rhs: OPoint<T, Const<3>>, ) -> <Unit<Quaternion<T>> as Mul<OPoint<T, Const<3>>>>::Output

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Rotation<T, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Scale<T, D>

where T: Scalar + ClosedMul, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

fn mul( self, right: OPoint<T, Const<D>>, ) -> <&'a Scale<T, D> as Mul<OPoint<T, Const<D>>>>::Output

Performs the * operation.

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

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, C, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Transform<T, C, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, const D: usize> Mul<OPoint<T, Const<D>>> for &'a Translation<T, D>

where T: Scalar + ClosedAdd, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, R, const D: usize> Mul<OPoint<T, Const<D>>> for Isometry<T, R, D>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, ShapeConstraint: AreMultipliable<Const<D>, Const<D>, Const<D>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Scalar + ClosedMul, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

fn mul( self, right: OPoint<T, Const<D>>, ) -> <Scale<T, D> as Mul<OPoint<T, Const<D>>>>::Output

Performs the * operation.

impl<T, R, const D: usize> Mul<OPoint<T, Const<D>>> for Similarity<T, R, D>

where T: SimdRealField, <T as SimdValue>::Element: SimdRealField, R: AbstractRotation<T, D>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, C, const D: usize> Mul<OPoint<T, Const<D>>> for Transform<T, C, D>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<Const<1>>, C: TCategory, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Scalar + ClosedAdd, ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA>

where T: Scalar + Zero + One + ClosedAdd + ClosedMul, SA: Storage<T, Const<R1>, Const<C1>>, ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1>>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, D> Mul<T> for &'a OPoint<T, D>

where T: Scalar + ClosedMul, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, D> Mul<T> for OPoint<T, D>

where T: Scalar + ClosedMul, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, D> MulAssign<T> for OPoint<T, D>

where T: Scalar + ClosedMul, D: DimName, DefaultAllocator: Allocator<T, D>,

fn mul_assign(&mut self, right: T)

Performs the *= operation.

impl<'a, T, D> Neg for &'a OPoint<T, D>

where T: Scalar + ClosedNeg, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the - operator.

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

Performs the unary - operation.

impl<T, D> Neg for OPoint<T, D>

where T: Scalar + ClosedNeg, D: DimName, DefaultAllocator: Allocator<T, D>,

type Output = OPoint<T, D>

The resulting type after applying the - operator.

fn neg(self) -> <OPoint<T, D> as Neg>::Output

Performs the unary - operation.

impl<T, D> PartialEq for OPoint<T, D>

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

fn eq(&self, right: &OPoint<T, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, D> PartialOrd for OPoint<T, D>

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

fn partial_cmp(&self, other: &OPoint<T, D>) -> Option<Ordering>

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

fn lt(&self, right: &OPoint<T, D>) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, right: &OPoint<T, D>) -> bool

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

fn gt(&self, right: &OPoint<T, D>) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, right: &OPoint<T, D>) -> bool

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

impl<T, D> RelativeEq for OPoint<T, D>

where T: Scalar + RelativeEq, D: DimName, <T as AbsDiffEq>::Epsilon: Clone, DefaultAllocator: Allocator<T, D>,

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

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

fn relative_eq( &self, other: &OPoint<T, D>, epsilon: <OPoint<T, D> as AbsDiffEq>::Epsilon, max_relative: <OPoint<T, D> as AbsDiffEq>::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 OPoint<T, Const<D>>

where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,

type Element = OPoint<<T as SimdValue>::Element, Const<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.

fn lanes() -> usize

The number of lanes of this SIMD value.

fn splat( val: <OPoint<T, Const<D>> as SimdValue>::Element, ) -> OPoint<T, Const<D>>

Initializes an SIMD value with each lanes set to val.

fn extract(&self, i: usize) -> <OPoint<T, Const<D>> as SimdValue>::Element

Extracts the i-th lane of self.

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

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

fn replace( &mut self, i: usize, val: <OPoint<T, Const<D>> as SimdValue>::Element, )

Replaces the i-th lane of self by val.

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

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

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

Merges self and other depending on the lanes of cond.

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

where Self: Clone,

Applies a function to each lane of self.

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<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T, D> Sub<&'b OPoint<T, D>> for &'a OPoint<T, D>

where T: Scalar + ClosedSub, ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>, D: DimName, DefaultAllocator: Allocator<T, D>,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b, T, D> Sub<&'b OPoint<T, D>> for OPoint<T, D>

where T: Scalar + ClosedSub, ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>, D: DimName, DefaultAllocator: Allocator<T, D>,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

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

type Output = OPoint<T, D1>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, D> Sub<OPoint<T, D>> for &'a OPoint<T, D>

where T: Scalar + ClosedSub, ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>, D: DimName, DefaultAllocator: Allocator<T, D>,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, D> Sub for OPoint<T, D>

where T: Scalar + ClosedSub, ShapeConstraint: SameNumberOfRows<D, D, Representative = D> + SameNumberOfColumns<Const<1>, Const<1>, Representative = Const<1>>, D: DimName, DefaultAllocator: Allocator<T, D>,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b, T, D1, D2, SB> SubAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

where D1: DimName, D2: Dim, T: Scalar + ClosedSub, SB: Storage<T, D2>, ShapeConstraint: SameNumberOfRows<D1, D2>, DefaultAllocator: Allocator<T, D1>,

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

Performs the -= operation.

impl<T, D1, D2, SB> SubAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>

where D1: DimName, D2: Dim, T: Scalar + ClosedSub, SB: Storage<T, D2>, ShapeConstraint: SameNumberOfRows<D1, D2>, DefaultAllocator: Allocator<T, D1>,

fn sub_assign(&mut self, right: Matrix<T, D2, Const<1>, SB>)

Performs the -= operation.

impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1>>>::Output>>::Buffer>> for OPoint<T1, D>

where D: DimNameAdd<Const<1>>, T1: Scalar, T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>, DefaultAllocator: Allocator<T1, D> + Allocator<T2, D> + Allocator<T1, <D as DimNameAdd<Const<1>>>::Output> + Allocator<T2, <D as DimNameAdd<Const<1>>>::Output>,

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

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

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

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

fn from_superset_unchecked( v: &Matrix<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1>>>::Output>>::Buffer>, ) -> OPoint<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.

impl<T1, T2, D> SubsetOf<OPoint<T2, D>> for OPoint<T1, D>

where D: DimName, T1: Scalar, T2: Scalar + SupersetOf<T1>, DefaultAllocator: Allocator<T1, D> + Allocator<T2, D>,

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

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

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

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

fn from_superset_unchecked(m: &OPoint<T2, D>) -> OPoint<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.

impl<T: Scalar> ToPnt<OPoint<T, Const<1>>> for Vector1<T>

fn to_pnt(self) -> Point1<T>

impl<T: Scalar> ToPnt<OPoint<T, Const<2>>> for Vector2<T>

fn to_pnt(self) -> Point2<T>

impl<T: Scalar> ToPnt<OPoint<T, Const<3>>> for Vector3<T>

fn to_pnt(self) -> Point3<T>

impl<T: Scalar> ToPnt<OPoint<T, Const<4>>> for Vector4<T>

fn to_pnt(self) -> Point4<T>

impl<T: Scalar> ToPnt<OPoint<T, Const<5>>> for Vector5<T>

fn to_pnt(self) -> Point5<T>

impl<T: Scalar> ToPnt<OPoint<T, Const<6>>> for Vector6<T>

fn to_pnt(self) -> Point6<T>

impl<T, D> UlpsEq for OPoint<T, D>

where T: Scalar + UlpsEq, D: DimName, <T as AbsDiffEq>::Epsilon: Clone, DefaultAllocator: Allocator<T, D>,

fn default_max_ulps() -> u32

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

fn ulps_eq( &self, other: &OPoint<T, D>, epsilon: <OPoint<T, D> as AbsDiffEq>::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, D> Copy for OPoint<T, D>

where T: Scalar + Copy, D: DimName, DefaultAllocator: Allocator<T, D>, Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer>: Copy,

impl<T, D> Eq for OPoint<T, D>

where T: Scalar + Eq, D: DimName, DefaultAllocator: Allocator<T, D>,