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

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

A point in a n-dimensional euclidean space.

## Fields

`coords: VectorN<N, D>`

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

## Methods

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

#### `pub fn to_homogeneous(&self) -> VectorN<N, DimNameSum<D, U1>> where    N: One,    D: DimNameAdd<U1>,    DefaultAllocator: Allocator<N, DimNameSum<D, 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: VectorN<N, D>) -> Self`[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: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for MatrixIter<'a, N, R, C, S> type Item = &'a N;``pub fn iter(    &self) -> MatrixIter<N, D, U1, <DefaultAllocator as Allocator<N, D>>::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: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator for MatrixIterMut<'a, N, R, C, S> type Item = &'a mut N;``pub fn iter_mut(    &mut self) -> MatrixIterMut<N, D, U1, <DefaultAllocator as Allocator<N, D>>::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: Scalar, D: DimName> Point<N, D> where    DefaultAllocator: Allocator<N, D>, `[src]

#### `pub unsafe fn new_uninitialized() -> Self`[src]

Creates a new point with uninitialized coordinates.

#### `pub fn origin() -> Self 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]) -> Self`[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: VectorN<N, DimNameSum<D, U1>>) -> Option<Self> where    N: Scalar + Zero + One + ClosedDiv,    D: DimNameAdd<U1>,    DefaultAllocator: Allocator<N, DimNameSum<D, 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: Scalar> Point<N, U1> where    DefaultAllocator: Allocator<N, U1>, `[src]

#### `pub fn new(x: N) -> Self`[src]

Initializes this point from its components.

# Example

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

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

#### `pub fn new(x: N, y: N) -> Self`[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: Scalar> Point<N, U3> where    DefaultAllocator: Allocator<N, U3>, `[src]

#### `pub fn new(x: N, y: N, z: N) -> Self`[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: Scalar> Point<N, U4> where    DefaultAllocator: Allocator<N, U4>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N) -> Self`[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: Scalar> Point<N, U5> where    DefaultAllocator: Allocator<N, U5>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N, a: N) -> Self`[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: Scalar> Point<N, U6> where    DefaultAllocator: Allocator<N, U6>, `[src]

#### `pub fn new(x: N, y: N, z: N, w: N, a: N, b: N) -> Self`[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: Scalar, D: DimName> Point<N, D> where    DefaultAllocator: Allocator<N, D>,    D::Value: Cmp<U0, Output = Greater>, `[src]

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

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

Builds a new point from components of `self`.

## Trait Implementations

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

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

This method tests for `!=`.

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

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

Performs copy-assignment from `source`. Read more

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

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

The resulting type after dereferencing.

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

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

The resulting type after dereferencing.

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

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

The resulting type after dereferencing.

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

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

The resulting type after dereferencing.

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

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

The resulting type after dereferencing.

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

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

The resulting type after dereferencing.

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

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

The resulting type after applying the `+` operator.

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

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

The resulting type after applying the `+` operator.

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

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

The resulting type after applying the `+` operator.

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

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

The resulting type after applying the `+` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<u8, D>> for u8 where    DefaultAllocator: Allocator<u8, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<u8, D>> for u8 where    DefaultAllocator: Allocator<u8, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<u16, D>> for u16 where    DefaultAllocator: Allocator<u16, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<u16, D>> for u16 where    DefaultAllocator: Allocator<u16, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<u32, D>> for u32 where    DefaultAllocator: Allocator<u32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<u32, D>> for u32 where    DefaultAllocator: Allocator<u32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<u64, D>> for u64 where    DefaultAllocator: Allocator<u64, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<u64, D>> for u64 where    DefaultAllocator: Allocator<u64, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<usize, D>> for usize where    DefaultAllocator: Allocator<usize, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<usize, D>> for usize where    DefaultAllocator: Allocator<usize, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<i8, D>> for i8 where    DefaultAllocator: Allocator<i8, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<i8, D>> for i8 where    DefaultAllocator: Allocator<i8, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<i16, D>> for i16 where    DefaultAllocator: Allocator<i16, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<i16, D>> for i16 where    DefaultAllocator: Allocator<i16, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<i32, D>> for i32 where    DefaultAllocator: Allocator<i32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<i32, D>> for i32 where    DefaultAllocator: Allocator<i32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<i64, D>> for i64 where    DefaultAllocator: Allocator<i64, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<i64, D>> for i64 where    DefaultAllocator: Allocator<i64, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<isize, D>> for isize where    DefaultAllocator: Allocator<isize, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<isize, D>> for isize where    DefaultAllocator: Allocator<isize, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<f32, D>> for f32 where    DefaultAllocator: Allocator<f32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<f32, D>> for f32 where    DefaultAllocator: Allocator<f32, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<D: DimName> Mul<Point<f64, D>> for f64 where    DefaultAllocator: Allocator<f64, D>, `[src]

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

The resulting type after applying the `*` operator.

### `impl<'b, D: DimName> Mul<&'b Point<f64, D>> for f64 where    DefaultAllocator: Allocator<f64, D>, `[src]

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

#### `type Output = Point3<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point3<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point3<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point3<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point2<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point2<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point2<N>`

The resulting type after applying the `*` operator.

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

#### `type Output = Point2<N>`

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `*` operator.

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

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

The resulting type after applying the `/` operator.

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

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

The resulting type after applying the `/` operator.

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

#### `type Output = Self`

The resulting type after applying the `-` operator.

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

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

The resulting type after applying the `-` operator.

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

#### `type Output = N`

The returned type after indexing.

### `impl<N: Scalar + Hash, D: DimName + Hash> Hash for Point<N, D> where    DefaultAllocator: Allocator<N, D>,    <DefaultAllocator as Allocator<N, D>>::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<N: Scalar, D: DimName> Distribution<Point<N, D>> for Standard where    DefaultAllocator: Allocator<N, D>,    Standard: Distribution<N>, `[src]

#### `default fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where    R: Rng, `[src]

Create an iterator that generates random values of `T`, using `rng` as the source of randomness. Read more

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

#### `type Epsilon = 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: Scalar + RelativeEq, D: DimName> RelativeEq<Point<N, D>> for Point<N, D> where    DefaultAllocator: Allocator<N, D>,    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<N: Scalar + UlpsEq, D: DimName> UlpsEq<Point<N, D>> for Point<N, D> where    DefaultAllocator: Allocator<N, D>,    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<N1, N2, D> SubsetOf<Point<N2, D>> for Point<N1, D> where    D: DimName,    N1: Scalar,    N2: Scalar + SupersetOf<N1>,    DefaultAllocator: Allocator<N2, D> + Allocator<N1, D>, `[src]

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

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

### `impl<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 + SupersetOf<N1>,    DefaultAllocator: Allocator<N1, D> + Allocator<N1, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>> + Allocator<N2, D>, `[src]

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

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

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

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

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

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

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

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

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

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

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

The associated vector space.

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

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`

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

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

#### `type Coordinates = VectorN<N, D>`

The underlying finite vector space.

#### `type RealField = N`

The underlying reals.

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

The distance between two points.

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

The distance between two points.

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

#### `type Rotation = Self`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id`

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

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

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

#### `type Rotation = Self`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id`

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

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

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

#### `type Rotation = Self`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Id`

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

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

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

#### `type Rotation = Id`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

Type of the non-uniform scaling to be applied.

#### `type Translation = Self`

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

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

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

#### `type Rotation = R`

Type of the first rotation to be applied.

#### `type NonUniformScaling = Id`

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: RealField, D: DimName, R> AffineTransformation<Point<N, D>> for Similarity<N, D, R> where    R: Rotation<Point<N, D>>,    DefaultAllocator: Allocator<N, D>, `[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: RealField, D: DimName> Similarity<Point<N, D>> for Rotation<N, D> where    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, `[src]

#### `type Scaling = Id`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

#### `type Scaling = Id`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

#### `type Scaling = Id`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

#### `type Scaling = Id`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

#### `type Scaling = Id`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

#### `type Scaling = N`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`

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`

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

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

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

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

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

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