OPoint in nalgebra::geometry - Rust
Description: A point in an euclidean space.
Keywords: rust, rustlang, rust-lang, OPoint

# Struct nalgebra::geometry::OPoint

source ·

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

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: OVector<T, D>`

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

## Implementations§

source§

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

source

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

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

##### Example

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

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

source

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

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

##### Example

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

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

source

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

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

This is the same as `.into()`.

##### Example

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

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

source

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

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

Creates a new point with the given coordinates.

source

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

source

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

source

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

source

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

source

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

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

source

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

source

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

source

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

Swaps two entries without bound-checking.

source§

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

source

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

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

source

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

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

source

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

Computes the (infimum, supremum) of two points.

source§

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

#### Other construction methods

source

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

Creates a new point with all coordinates equal to zero.

##### Example

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

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

source

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

Creates a new point from a slice.

##### Example

    let data = [ 1.0, 2.0, 3.0 ];

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

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

source

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

Creates a new point from its homogeneous vector representation.

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

##### Example

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

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

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

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

source

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

Cast the components of `self` to another type.

##### Example

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

source§

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

#### Construction from individual components

source

#### pub const fn new(x: T) -> Self

Initializes this point from its components.

##### Example

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

source§

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

source

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

Initializes this point from its components.

##### Example

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

source§

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

source

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

Initializes this point from its components.

##### Example

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

source§

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

source

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

Initializes this point from its components.

##### Example

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

source§

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

source

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

Initializes this point from its components.

##### Example

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

source§

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

source

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

Initializes this point from its components.

##### Example

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

source§

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

#### Swizzling

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

source

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

Builds a new point from components of `self`.

## Trait Implementations§

source§

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

§

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

Used for specifying relative comparisons.
source§

#### fn default_epsilon() -> Self::Epsilon

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

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

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

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

The inverse of `AbsDiffEq::abs_diff_eq`.
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

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

source§

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

Performs the `+=` operation. Read more
source§

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

source§

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

Performs the `+=` operation. Read more
source§

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

source§

#### fn max_value() -> Self

Returns the largest finite number this type can represent
source§

#### fn min_value() -> Self

Returns the smallest finite number this type can represent
source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

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

§

#### type Target = X<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

§

#### type Target = XY<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

§

#### type Target = XYZ<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

§

#### type Target = XYZW<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

§

#### type Target = XYZWA<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

§

#### type Target = XYZWAB<T>

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Mutably dereferences the value.
source§

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

source§

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

Formats the value using the given formatter. Read more
source§

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

§

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

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

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

§

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

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

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

source§

#### fn div_assign(&mut self, right: T)

Performs the `/=` operation. Read more
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

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

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

§

#### type Output = T

The returned type after indexing.
source§

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

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

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

source§

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

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

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<f32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<f64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i16, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i8, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<isize, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u16, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u8, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<usize, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<f32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<f64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i16, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<i8, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<isize, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u16, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u32, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u64, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<u8, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

#### type Output = OPoint<usize, D>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

§

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

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

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

source§

#### fn mul_assign(&mut self, right: T)

Performs the `*=` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

#### fn neg(self) -> Self::Output

Performs the unary `-` operation. Read more
source§

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

source§

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

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more
1.0.0 · source§

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

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

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

source§

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

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

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

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

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

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

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

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

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

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

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

source§

#### fn default_max_relative() -> Self::Epsilon

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

#### fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool

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

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

The inverse of `RelativeEq::relative_eq`.
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

#### type Output = OPoint<T, D1>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

§

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

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

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

source§

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

Performs the `-=` operation. Read more
source§

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

source§

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

Performs the `-=` operation. Read more
source§

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

source§

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

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

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

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

#### fn from_superset_unchecked(v: &OVector<T2, DimNameSum<D, U1>>) -> Self

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

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

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

### impl<T1, T2, D: DimName> SubsetOf<OPoint<T2, D>> for OPoint<T1, D>where
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<T1, D> + Allocator<T2, D>,

source§

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

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

#### 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).
source§

#### fn from_superset_unchecked(m: &OPoint<T2, D>) -> Self

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

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

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

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

source§

#### fn default_max_ulps() -> u32

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

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

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

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

The inverse of `UlpsEq::ulps_eq`.
source§

### impl<T: Scalar + Copy, D: DimName> Copy for OPoint<T, D>where
DefaultAllocator: Allocator<T, D>,
OVector<T, D>: Copy,

source§

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

## Auto Trait Implementations§

§

### impl<T, D> !RefUnwindSafe for OPoint<T, D>

§

### impl<T, D> !Send for OPoint<T, D>

§

### impl<T, D> !Sync for OPoint<T, D>

§

### impl<T, D> !Unpin for OPoint<T, D>

§

### impl<T, D> !UnwindSafe for OPoint<T, D>

## Blanket Implementations§

source§

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

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

const: unstable · source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> LowerBounded for Twhere
T: Bounded,

source§

#### fn min_value() -> T

Returns the smallest finite number this type can represent
source§

### impl<T> Same<T> for T

§

#### type Output = T

Should always be `Self`
source§

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

source§

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

Lanewise greater than `>` comparison.
source§

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

Lanewise less than `<` comparison.
source§

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

Lanewise greater or equal `>=` comparison.
source§

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

Lanewise less or equal `<=` comparison.
source§

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

Lanewise equal `==` comparison.
source§

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

Lanewise not equal `!=` comparison.
source§

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

Lanewise max value.
source§

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

Lanewise min value.
source§

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

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

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

The min value among all lanes of `self`.
source§

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

The max value among all lanes of `self`.
source§

### impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,

source§

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

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

#### fn is_in_subset(&self) -> bool

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

#### fn to_subset_unchecked(&self) -> SS

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

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

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

### impl<T> ToOwned for Twhere
T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

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

#### fn clone_into(&self, target: &mut T)

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

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

source§

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more
source§

### impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

### impl<T> UpperBounded for Twhere
T: Bounded,

source§

#### fn max_value() -> T

Returns the largest finite number this type can represent
source§

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

source§

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

source§

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

source§

### impl<T> ClosedNeg for Twhere
T: Neg<Output = T>,

source§

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