# [−][src]Struct na::geometry::Point

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

A point in a n-dimensional euclidean space.

## Fields

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

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

## Methods

### `impl<N, D> Point<N, D> where    D: DimName,    N: Scalar,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `pub fn to_homogeneous(    &self) -> Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> where    D: DimNameAdd<U1>,    N: One,    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, `[src]

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

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

# Example

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

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

#### `pub fn from_coordinates(    coords: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>) -> Point<N, D>`[src]

Deprecated:

Creates a new point with the given coordinates.

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

The dimension of this point.

# Example

```let p = Point2::new(1.0, 2.0);
assert_eq!(p.len(), 2);

// This works in any dimension.
let p = Point3::new(10.0, 20.0, 30.0);
assert_eq!(p.len(), 3);```

#### `pub fn stride(&self) -> usize`[src]

Deprecated:

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

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

#### ⓘImportant traits for MatrixIter<'a, N, R, C, S>### Important traits for MatrixIter<'a, N, R, C, S> `impl<'a, N, R, C, S> Iterator for MatrixIter<'a, N, R, C, S> where    C: Dim,    N: Scalar,    R: Dim,    S: 'a + Storage<N, R, C>,  type Item = &'a N;``pub fn iter(    &self) -> MatrixIter<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Iterates through this point coordinates.

# Example

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

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

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

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

#### ⓘImportant traits for MatrixIterMut<'a, N, R, C, S>### Important traits for MatrixIterMut<'a, N, R, C, S> `impl<'a, N, R, C, S> Iterator for MatrixIterMut<'a, N, R, C, S> where    C: Dim,    N: Scalar,    R: Dim,    S: 'a + StorageMut<N, R, C>,  type Item = &'a mut N;``pub fn iter_mut(    &mut self) -> MatrixIterMut<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Mutably iterates through this point coordinates.

# Example

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

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

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

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

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

#### `pub unsafe fn swap_unchecked(&mut self, i1: usize, i2: usize)`[src]

Swaps two entries without bound-checking.

### `impl<N, D> Point<N, D> where    D: DimName,    N: Scalar,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `pub unsafe fn new_uninitialized() -> Point<N, D>`[src]

Creates a new point with uninitialized coordinates.

#### `pub fn origin() -> Point<N, D> where    N: Zero, `[src]

Creates a new point with all coordinates equal to zero.

# Example

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

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

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

Creates a new point from a slice.

# Example

```let data = [ 1.0, 2.0, 3.0 ];

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

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

#### `pub fn from_homogeneous(    v: Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>) -> Option<Point<N, D>> where    D: DimNameAdd<U1>,    N: Scalar + Zero + One + ClosedDiv<N>,    DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>, `[src]

Creates a new point from its homogeneous vector representation.

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

# Example

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

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

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

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

### `impl<N> Point<N, U1> where    N: Scalar,    DefaultAllocator: Allocator<N, U1, U1>, `[src]

#### `pub fn new(x: N) -> Point<N, U1>`[src]

Initializes this point from its components.

# Example

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

### `impl<N> Point<N, U2> where    N: Scalar,    DefaultAllocator: Allocator<N, U2, U1>, `[src]

#### `pub fn new(x: N, y: N) -> Point<N, U2>`[src]

Initializes this point from its components.

# Example

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

### `impl<N> Point<N, U3> where    N: Scalar,    DefaultAllocator: Allocator<N, U3, U1>, `[src]

#### `pub fn new(x: N, y: N, z: N) -> Point<N, U3>`[src]

Initializes this point from its components.

# Example

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

### `impl<N> Point<N, U4> where    N: Scalar,    DefaultAllocator: Allocator<N, U4, U1>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N) -> Point<N, U4>`[src]

Initializes this point from its components.

# Example

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

### `impl<N> Point<N, U5> where    N: Scalar,    DefaultAllocator: Allocator<N, U5, U1>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N, a: N) -> Point<N, U5>`[src]

Initializes this point from its components.

# Example

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

### `impl<N> Point<N, U6> where    N: Scalar,    DefaultAllocator: Allocator<N, U6, U1>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Point<N, U6>`[src]

Initializes this point from its components.

# Example

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

### `impl<N, D> Point<N, D> where    D: DimName,    N: Scalar,    DefaultAllocator: Allocator<N, D, U1>,    <D as DimName>::Value: Cmp<UTerm>,    <<D as DimName>::Value as Cmp<UTerm>>::Output == Greater, `[src]

#### `pub fn xx(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn xxx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

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

#### `pub fn xy(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn yx(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn yy(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn xxy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xyx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xyy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yxx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yxy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yyx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yyy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

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

#### `pub fn xz(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn yz(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn zx(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn zy(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn zz(&self) -> Point<N, U2>`[src]

Builds a new point from components of `self`.

#### `pub fn xxz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xyz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xzx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xzy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn xzz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yxz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yyz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yzx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yzy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn yzz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zxx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zxy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zxz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zyx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zyy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zyz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zzx(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zzy(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

#### `pub fn zzz(&self) -> Point<N, U3>`[src]

Builds a new point from components of `self`.

## Trait Implementations

### `impl<N, D, R> AffineTransformation<Point<N, D>> for Isometry<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Rotation = R`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id<Multiplicative>`

Type of the non-uniform scaling to be applied.

#### `type Translation = Translation<N, D>`

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

### `impl<N> AffineTransformation<Point<N, U3>> for Unit<Quaternion<N>> where    N: RealField, `[src]

#### `type Rotation = Unit<Quaternion<N>>`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id<Multiplicative>`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id<Multiplicative>`

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

#### `default fn append_rotation_wrt_point(    &self,     r: &Self::Rotation,     p: &E) -> Option<Self>`[src]

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

### `impl<N, D, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type NonUniformScaling = N`

Type of the non-uniform scaling to be applied.

#### `type Rotation = R`

Type of the first rotation to be applied.

#### `type Translation = Translation<N, D>`

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

### `impl<N, D> AffineTransformation<Point<N, D>> for Rotation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, D>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Rotation = Rotation<N, D>`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id<Multiplicative>`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id<Multiplicative>`

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

#### `default fn append_rotation_wrt_point(    &self,     r: &Self::Rotation,     p: &E) -> Option<Self>`[src]

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

### `impl<N, D> AffineTransformation<Point<N, D>> for Translation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Rotation = Id<Multiplicative>`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id<Multiplicative>`

Type of the non-uniform scaling to be applied.

#### `type Translation = Translation<N, D>`

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

#### `default fn append_rotation_wrt_point(    &self,     r: &Self::Rotation,     p: &E) -> Option<Self>`[src]

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

### `impl<N> AffineTransformation<Point<N, U2>> for Unit<Complex<N>> where    N: RealField,    DefaultAllocator: Allocator<N, U2, U1>, `[src]

#### `type Rotation = Unit<Complex<N>>`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id<Multiplicative>`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id<Multiplicative>`

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

#### `default fn append_rotation_wrt_point(    &self,     r: &Self::Rotation,     p: &E) -> Option<Self>`[src]

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

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

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

Used for specifying relative comparisons.

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

The inverse of `ApproxEq::abs_diff_eq`.

### `impl<N, D> Clone for Point<N, D> where    D: DimName + Clone,    N: Scalar + Clone,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

Performs copy-assignment from `source`. Read more

### `impl<N, D> EuclideanSpace for Point<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

The underlying finite vector space.

#### `type RealField = N`

The underlying reals.

#### `default fn distance_squared(&self, b: &Self) -> Self::RealField`[src]

The distance between two points.

#### `default fn distance(&self, b: &Self) -> Self::RealField`[src]

The distance between two points.

### `impl<N, D> PartialEq<Point<N, D>> for Point<N, D> where    D: DimName,    N: Scalar,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

This method tests for `!=`.

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

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

The inverse of `ApproxEq::relative_eq`.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `-` operator.

### `impl<N, D> Neg for Point<N, D> where    D: DimName,    N: Scalar + ClosedNeg,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = Point<N, D>`

The resulting type after applying the `-` operator.

### `impl<N, D> Similarity<Point<N, D>> for Translation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Scaling = Id<Multiplicative>`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N, D, R> Similarity<Point<N, D>> for Isometry<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Scaling = Id<Multiplicative>`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N> Similarity<Point<N, U2>> for Unit<Complex<N>> where    N: RealField,    DefaultAllocator: Allocator<N, U2, U1>, `[src]

#### `type Scaling = Id<Multiplicative>`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N, D, R> Similarity<Point<N, D>> for Similarity<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Scaling = N`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N> Similarity<Point<N, U3>> for Unit<Quaternion<N>> where    N: RealField, `[src]

#### `type Scaling = Id<Multiplicative>`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N, D> Similarity<Point<N, D>> for Rotation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, D>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Scaling = Id<Multiplicative>`

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

#### `default fn translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_translate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_scale_point(&self, pt: &E) -> E`[src]

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

#### `default fn inverse_rotate_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

#### `default fn inverse_scale_vector(    &self,     pt: &<E as EuclideanSpace>::Coordinates) -> <E as EuclideanSpace>::Coordinates`[src]

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

### `impl<N, D, R> Mul<Point<N, D>> for Similarity<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

### `impl<N> Mul<Point<N, U3>> for Unit<Quaternion<N>> where    N: RealField,    DefaultAllocator: Allocator<N, U4, U1>,    DefaultAllocator: Allocator<N, U3, U1>, `[src]

#### `type Output = Point<N, U3>`

The resulting type after applying the `*` operator.

### `impl<N, D> Mul<N> for Point<N, D> where    D: DimName,    N: Scalar + ClosedMul<N>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U2>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U3>`

The resulting type after applying the `*` operator.

### `impl<N> Mul<Point<N, U2>> for Unit<Complex<N>> where    N: RealField,    DefaultAllocator: Allocator<N, U2, U1>, `[src]

#### `type Output = Point<N, U2>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, R1>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

### `impl<N, D, R> Mul<Point<N, D>> for Isometry<N, D, R> where    D: DimName,    N: RealField,    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, R1>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U3>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, R1>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U3>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U2>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, R1>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, U2>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `*` operator.

### `impl<N, D> Hash for Point<N, D> where    D: DimName + Hash,    N: Scalar + Hash,    DefaultAllocator: Allocator<N, D, U1>,    <DefaultAllocator as Allocator<N, D, U1>>::Buffer: Hash, `[src]

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

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

### `impl<N1, N2, D> SubsetOf<Point<N2, D>> for Point<N1, D> where    D: DimName,    N1: Scalar,    N2: Scalar + SupersetOf<N1>,    DefaultAllocator: Allocator<N2, D, U1>,    DefaultAllocator: Allocator<N1, D, U1>, `[src]

#### `default fn from_superset(element: &T) -> Option<Self>`[src]

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

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

#### `default fn from_superset(element: &T) -> Option<Self>`[src]

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

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `+` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `+` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `+` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `+` operator.

### `impl<N, D> Rotation<Point<N, D>> for Rotation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, D>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

### `impl<N, D> Translation<Point<N, D>> for Translation<N, D> where    D: DimName,    N: RealField,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

### `impl<N> Deref for Point<N, U6> where    N: Scalar,    DefaultAllocator: Allocator<N, U6, U1>, `[src]

#### `type Target = XYZWAB<N>`

The resulting type after dereferencing.

### `impl<N> Deref for Point<N, U2> where    N: Scalar,    DefaultAllocator: Allocator<N, U2, U1>, `[src]

#### `type Target = XY<N>`

The resulting type after dereferencing.

### `impl<N> Deref for Point<N, U4> where    N: Scalar,    DefaultAllocator: Allocator<N, U4, U1>, `[src]

#### `type Target = XYZW<N>`

The resulting type after dereferencing.

### `impl<N> Deref for Point<N, U3> where    N: Scalar,    DefaultAllocator: Allocator<N, U3, U1>, `[src]

#### `type Target = XYZ<N>`

The resulting type after dereferencing.

### `impl<N> Deref for Point<N, U1> where    N: Scalar,    DefaultAllocator: Allocator<N, U1, U1>, `[src]

#### `type Target = X<N>`

The resulting type after dereferencing.

### `impl<N> Deref for Point<N, U5> where    N: Scalar,    DefaultAllocator: Allocator<N, U5, U1>, `[src]

#### `type Target = XYZWA<N>`

The resulting type after dereferencing.

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

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

The inverse of `ApproxEq::ulps_eq`.

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

#### `type Output = Point<N, D>`

The resulting type after applying the `/` operator.

### `impl<N, D> Div<N> for Point<N, D> where    D: DimName,    N: Scalar + ClosedDiv<N>,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = Point<N, D>`

The resulting type after applying the `/` operator.

### `impl<N, D> Lattice for Point<N, D> where    D: DimName,    N: Scalar + Lattice,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `default fn partial_min(&'a self, other: &'a Self) -> Option<&'a Self>`[src]

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

#### `default fn partial_max(&'a self, other: &'a Self) -> Option<&'a Self>`[src]

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

#### `default fn partial_sort2(    &'a self,     other: &'a Self) -> Option<(&'a Self, &'a Self)>`[src]

Sorts two values in increasing order using a partial ordering.

#### `default fn partial_clamp(    &'a self,     min: &'a Self,     max: &'a Self) -> Option<&'a Self>`[src]

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

### `impl<N, D> Index<usize> for Point<N, D> where    D: DimName,    N: Scalar,    DefaultAllocator: Allocator<N, D, U1>, `[src]

#### `type Output = N`

The returned type after indexing.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `-` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `-` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

#### `type Output = Point<N, D1>`

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

### `impl<N, D> AffineSpace for Point<N, D> where    D: DimName,    N: Scalar + Field + Scalar + Field,    DefaultAllocator: Allocator<N, D, U1>, `[src]

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

The associated vector space.

#### `default fn translate_by(&self, t: &Self::Translation) -> Self`[src]

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

#### `default fn subtract(&self, right: &Self) -> Self::Translation`[src]

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

## Blanket Implementations

### `impl<T, U> TryFrom for T where    U: Into<T>, `[src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto for T where    U: TryFrom<T>, `[src]

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

The type returned in the event of a conversion error.

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

#### `type Output = T`

Should always be `Self`