Struct building_blocks::prelude::PointN

pub struct PointN<N>(pub N);

An N-dimensional point (where N=2 or N=3), which is usually just a primitive array like [i32; 2] or [i32; 3]. It is most convenient to construct points of any dimension as:

use building_blocks_core::PointN;

let p2 = PointN([1, 2]); // 2D
let p3 = PointN([1, 2, 3]); // 3D

Points support basic linear algebraic operations such as addition, subtraction, scalar multiplication, and scalar division.

let p1 = PointN([1, 2]);
let p2 = PointN([3, 4]);

assert_eq!(p1 + p2, PointN([4, 6]));
assert_eq!(p1 - p2, PointN([-2, -2]));

assert_eq!(p1 * 2, PointN([2, 4]));
assert_eq!(p1 / 2, PointN([0, 1]));

// Also some component-wise operations.
assert_eq!(p1 * p2, PointN([3, 8]));
assert_eq!(p1 / p2, PointN([0, 0]));
assert_eq!(p2 / p1, PointN([3, 2]));

There is also a partial order defined on points which says that a point A is greater than a point B if and only if all of the components of point A are greater than point B. This is useful for easily checking is a point is inside of the extent between two other points:

let min = PointN([0, 0, 0]);
let least_upper_bound = PointN([3, 3, 3]);

let p = PointN([0, 1, 2]);
assert!(min <= p && p < least_upper_bound);

Implementations

impl<T> PointN<[T; 2]>

pub fn x_mut(&mut self) -> &mut T

pub fn y_mut(&mut self) -> &mut T

impl<T> PointN<[T; 2]> where
    T: Copy, 

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn yx(&self) -> PointN<[T; 2]>

impl<T> PointN<[T; 2]> where
    T: Copy + Integer, 

pub fn vector_div_floor(&self, rhs: &PointN<[T; 2]>) -> PointN<[T; 2]>

pub fn scalar_div_floor(&self, rhs: T) -> PointN<[T; 2]>

impl PointN<[f32; 2]>

pub fn round(&self) -> PointN<[f32; 2]>

pub fn floor(&self) -> PointN<[f32; 2]>

impl PointN<[f32; 2]>

pub fn as_2i(&self) -> PointN<[i32; 2]>

pub fn in_pixel(&self) -> PointN<[i32; 2]>

impl<T> PointN<[T; 3]>

pub fn x_mut(&mut self) -> &mut T

pub fn y_mut(&mut self) -> &mut T

pub fn z_mut(&mut self) -> &mut T

impl<T> PointN<[T; 3]> where
    T: Copy, 

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

pub fn xy(&self) -> PointN<[T; 2]>

pub fn yx(&self) -> PointN<[T; 2]>

pub fn yz(&self) -> PointN<[T; 2]>

pub fn zy(&self) -> PointN<[T; 2]>

pub fn zx(&self) -> PointN<[T; 2]>

pub fn xz(&self) -> PointN<[T; 2]>

pub fn yzx(&self) -> PointN<[T; 3]>

pub fn zxy(&self) -> PointN<[T; 3]>

pub fn zyx(&self) -> PointN<[T; 3]>

impl<T> PointN<[T; 3]> where
    T: Mul<T, Output = T> + Sub<T, Output = T> + Copy, 

pub fn cross(&self, other: &PointN<[T; 3]>) -> PointN<[T; 3]>

impl<T> PointN<[T; 3]> where
    T: Copy + Integer, 

pub fn vector_div_floor(&self, rhs: &PointN<[T; 3]>) -> PointN<[T; 3]>

pub fn scalar_div_floor(&self, rhs: T) -> PointN<[T; 3]>

impl PointN<[f32; 3]>

pub fn round(&self) -> PointN<[f32; 3]>

pub fn floor(&self) -> PointN<[f32; 3]>

impl PointN<[f32; 3]>

pub fn as_3i(&self) -> PointN<[i32; 3]>

pub fn in_voxel(&self) -> PointN<[i32; 3]>

Trait Implementations

impl<T> Add<PointN<[T; 2]>> for PointN<[T; 2]> where
    T: Copy + AddAssign<T>, 

type Output = PointN<[T; 2]>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: PointN<[T; 2]>
) -> <PointN<[T; 2]> as Add<PointN<[T; 2]>>>::Output

Performs the + operation.

impl<T> Add<PointN<[T; 3]>> for PointN<[T; 3]> where
    T: AddAssign<T> + Copy, 

type Output = PointN<[T; 3]>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: PointN<[T; 3]>
) -> <PointN<[T; 3]> as Add<PointN<[T; 3]>>>::Output

Performs the + operation.

impl<T> Add<PointN<T>> for ExtentN<T> where
    PointN<T>: Add<PointN<T>>,
    <PointN<T> as Add<PointN<T>>>::Output == PointN<T>, 

type Output = ExtentN<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: PointN<T>) -> <ExtentN<T> as Add<PointN<T>>>::Output

Performs the + operation.

impl<N> AddAssign<PointN<N>> for PointN<N> where
    N: Copy,
    PointN<N>: Add<PointN<N>>,
    <PointN<N> as Add<PointN<N>>>::Output == PointN<N>, 

pub fn add_assign(&mut self, rhs: PointN<N>)

Performs the += operation.

impl<T> AddAssign<PointN<T>> for ExtentN<T> where
    ExtentN<T>: Copy,
    ExtentN<T>: Add<PointN<T>>,
    <ExtentN<T> as Add<PointN<T>>>::Output == ExtentN<T>, 

pub fn add_assign(&mut self, rhs: PointN<T>)

Performs the += operation.

impl<T> Bounded for PointN<[T; 2]> where
    T: Bounded, 

pub const MAX: PointN<[T; 2]>

pub const MIN: PointN<[T; 2]>

impl<T> Bounded for PointN<[T; 3]> where
    T: Bounded, 

pub const MAX: PointN<[T; 3]>

pub const MIN: PointN<[T; 3]>

impl ChunkShape<[i32; 2]> for PointN<[i32; 2]>

pub fn mask(&self) -> PointN<[i32; 2]>

Makes the mask required to convert points to chunk keys.

pub fn chunk_key_containing_point(
    mask: &PointN<[i32; 2]>,
    p: &PointN<[i32; 2]>
) -> PointN<[i32; 2]>

A chunk key is just the leading m bits of each component of a point, where m depends on the size of the chunk. It can also be interpreted as the minimum point of a chunk extent.

impl ChunkShape<[i32; 3]> for PointN<[i32; 3]>

pub fn mask(&self) -> PointN<[i32; 3]>

Makes the mask required to convert points to chunk keys.

pub fn chunk_key_containing_point(
    mask: &PointN<[i32; 3]>,
    p: &PointN<[i32; 3]>
) -> PointN<[i32; 3]>

A chunk key is just the leading m bits of each component of a point, where m depends on the size of the chunk. It can also be interpreted as the minimum point of a chunk extent.

impl<N> Clone for PointN<N> where
    N: Clone, 

pub fn clone(&self) -> PointN<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> Copy for PointN<N> where
    N: Copy, 

impl<N> Debug for PointN<N> where
    N: Debug, 

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

Formats the value using the given formatter.

impl<N> Default for PointN<N> where
    N: Default, 

pub fn default() -> PointN<N>

Returns the "default value" for a type.

impl<'de, N> Deserialize<'de> for PointN<N> where
    N: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<PointN<N>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Distance for PointN<[T; 3]> where
    T: Add<T, Output = T> + Pow<u16, Output = T> + Copy + Signed,
    PointN<[T; 3]>: Point,
    <PointN<[T; 3]> as Point>::Scalar == T, 

pub fn l1_distance(
    &self,
    other: &PointN<[T; 3]>
) -> <PointN<[T; 3]> as Point>::Scalar

The L1 distance between points.

pub fn l2_distance_squared(
    &self,
    other: &PointN<[T; 3]>
) -> <PointN<[T; 3]> as Point>::Scalar

The square of the L2 (Euclidean) distance between points.

impl<T> Distance for PointN<[T; 2]> where
    T: Add<T, Output = T> + Pow<u16, Output = T> + Copy + Signed,
    PointN<[T; 2]>: Point,
    <PointN<[T; 2]> as Point>::Scalar == T, 

pub fn l1_distance(
    &self,
    other: &PointN<[T; 2]>
) -> <PointN<[T; 2]> as Point>::Scalar

The L1 distance between points.

pub fn l2_distance_squared(
    &self,
    other: &PointN<[T; 2]>
) -> <PointN<[T; 2]> as Point>::Scalar

The square of the L2 (Euclidean) distance between points.

impl Div<PointN<[f32; 2]>> for PointN<[f32; 2]>

type Output = PointN<[f32; 2]>

The resulting type after applying the / operator.

pub fn div(self, rhs: PointN<[f32; 2]>) -> PointN<[f32; 2]>

Performs the / operation.

impl Div<PointN<[f32; 3]>> for PointN<[f32; 3]>

type Output = PointN<[f32; 3]>

The resulting type after applying the / operator.

pub fn div(self, rhs: PointN<[f32; 3]>) -> PointN<[f32; 3]>

Performs the / operation.

impl Div<PointN<[i32; 2]>> for PointN<[i32; 2]>

type Output = PointN<[i32; 2]>

The resulting type after applying the / operator.

pub fn div(self, rhs: PointN<[i32; 2]>) -> PointN<[i32; 2]>

Performs the / operation.

impl Div<PointN<[i32; 3]>> for PointN<[i32; 3]>

type Output = PointN<[i32; 3]>

The resulting type after applying the / operator.

pub fn div(self, rhs: PointN<[i32; 3]>) -> PointN<[i32; 3]>

Performs the / operation.

impl Div<f32> for PointN<[f32; 2]>

type Output = PointN<[f32; 2]>

The resulting type after applying the / operator.

pub fn div(self, rhs: f32) -> PointN<[f32; 2]>

Performs the / operation.

impl Div<f32> for PointN<[f32; 3]>

type Output = PointN<[f32; 3]>

The resulting type after applying the / operator.

pub fn div(self, rhs: f32) -> PointN<[f32; 3]>

Performs the / operation.

impl Div<i32> for PointN<[i32; 2]>

type Output = PointN<[i32; 2]>

The resulting type after applying the / operator.

pub fn div(self, rhs: i32) -> PointN<[i32; 2]>

Performs the / operation.

impl Div<i32> for PointN<[i32; 3]>

type Output = PointN<[i32; 3]>

The resulting type after applying the / operator.

pub fn div(self, rhs: i32) -> PointN<[i32; 3]>

Performs the / operation.

impl<T> DotProduct for PointN<[T; 2]> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Copy, 

type Scalar = T

pub fn dot(
    &self,
    other: &PointN<[T; 2]>
) -> <PointN<[T; 2]> as DotProduct>::Scalar

The vector dot product.

impl<T> DotProduct for PointN<[T; 3]> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Copy, 

type Scalar = T

pub fn dot(
    &self,
    other: &PointN<[T; 3]>
) -> <PointN<[T; 3]> as DotProduct>::Scalar

The vector dot product.

impl<N> Eq for PointN<N> where
    N: Eq, 

impl<N, T> ForEach<N, PointN<N>> for AmbientExtent<N, T> where
    T: Clone,
    ExtentN<N>: IntegerExtent<N>, 

type Data = T

pub fn for_each(
    &self,
    extent: &ExtentN<N>,
    f: impl FnMut(PointN<N>, <AmbientExtent<N, T> as ForEach<N, PointN<N>>>::Data)
)

impl<'a, F, N, T> ForEach<N, PointN<N>> for F where
    F: Fn(&PointN<N>) -> T,
    PointN<N>: Copy,
    ExtentN<N>: IntegerExtent<N>, 

type Data = T

pub fn for_each(
    &self,
    extent: &ExtentN<N>,
    f: impl FnMut(PointN<N>, <F as ForEach<N, PointN<N>>>::Data)
)

impl<N, T> ForEach<N, PointN<N>> for ArrayN<N, T> where
    ArrayN<N, T>: Sized,
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: Get<Stride>,
    ArrayN<N, T>: GetUnchecked<Stride>,
    <ArrayN<N, T> as Get<Stride>>::Data == T,
    <ArrayN<N, T> as GetUnchecked<Stride>>::Data == T, 

type Data = T

pub fn for_each(&self, extent: &ExtentN<N>, f: impl FnMut(PointN<N>, T))

impl<'a, N, T, M> ForEach<N, PointN<N>> for ChunkMapReader<'a, N, T, M> where
    M: Clone,
    T: Copy,
    PointN<N>: IntegerPoint,
    PointN<N>: ChunkShape<N>,
    PointN<N>: Eq,
    PointN<N>: Hash,
    ExtentN<N>: IntegerExtent<N>,
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: ForEach<N, PointN<N>>,
    <ArrayN<N, T> as ForEach<N, PointN<N>>>::Data == T, 

type Data = T

pub fn for_each(
    &self,
    extent: &ExtentN<N>,
    f: impl FnMut(PointN<N>, <ChunkMapReader<'a, N, T, M> as ForEach<N, PointN<N>>>::Data)
)

impl<N, T> ForEachMut<N, PointN<N>> for ArrayN<N, T> where
    ArrayN<N, T>: Sized,
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: GetMut<Stride>,
    ArrayN<N, T>: GetUncheckedMut<Stride>,
    ExtentN<N>: Copy,
    <ArrayN<N, T> as GetMut<Stride>>::Data == T,
    <ArrayN<N, T> as GetUncheckedMut<Stride>>::Data == T, 

type Data = T

pub fn for_each_mut(
    &mut self,
    extent: &ExtentN<N>,
    f: impl FnMut(PointN<N>, &mut T)
)

impl<'a, N, T, M> ForEachMut<N, PointN<N>> for ChunkMap<N, T, M> where
    M: Clone,
    T: Copy,
    PointN<N>: Point,
    PointN<N>: ChunkShape<N>,
    PointN<N>: Eq,
    PointN<N>: Hash,
    ExtentN<N>: IntegerExtent<N>,
    ArrayN<N, T>: ForEachMut<N, PointN<N>>,
    <ArrayN<N, T> as ForEachMut<N, PointN<N>>>::Data == T, 

type Data = T

pub fn for_each_mut(
    &mut self,
    extent: &ExtentN<N>,
    f: impl FnMut(PointN<N>, &mut <ChunkMap<N, T, M> as ForEachMut<N, PointN<N>>>::Data)
)

impl From<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>> for PointN<[f32; 2]>

pub fn from(
    p: Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>
) -> PointN<[f32; 2]>

Performs the conversion.

impl From<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> for PointN<[f32; 3]>

pub fn from(
    p: Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>
) -> PointN<[f32; 3]>

Performs the conversion.

impl From<Matrix<i32, U2, U1, <DefaultAllocator as Allocator<i32, U2, U1>>::Buffer>> for PointN<[i32; 2]>

pub fn from(
    p: Matrix<i32, U2, U1, <DefaultAllocator as Allocator<i32, U2, U1>>::Buffer>
) -> PointN<[i32; 2]>

Performs the conversion.

impl From<Matrix<i32, U3, U1, <DefaultAllocator as Allocator<i32, U3, U1>>::Buffer>> for PointN<[i32; 3]>

pub fn from(
    p: Matrix<i32, U3, U1, <DefaultAllocator as Allocator<i32, U3, U1>>::Buffer>
) -> PointN<[i32; 3]>

Performs the conversion.

impl From<Point<f32, U2>> for PointN<[f32; 2]>

pub fn from(p: Point<f32, U2>) -> PointN<[f32; 2]>

Performs the conversion.

impl From<Point<f32, U3>> for PointN<[f32; 3]>

pub fn from(p: Point<f32, U3>) -> PointN<[f32; 3]>

Performs the conversion.

impl From<Point<i32, U2>> for PointN<[i32; 2]>

pub fn from(p: Point<i32, U2>) -> PointN<[i32; 2]>

Performs the conversion.

impl From<Point<i32, U3>> for PointN<[i32; 3]>

pub fn from(p: Point<i32, U3>) -> PointN<[i32; 3]>

Performs the conversion.

impl<T> From<Point2<T>> for PointN<[T; 2]>

pub fn from(p: Point2<T>) -> PointN<[T; 2]>

Performs the conversion.

impl<T> From<Point3<T>> for PointN<[T; 3]>

pub fn from(p: Point3<T>) -> PointN<[T; 3]>

Performs the conversion.

impl From<PointN<[i32; 2]>> for PointN<[f32; 2]>

pub fn from(p: PointN<[i32; 2]>) -> PointN<[f32; 2]>

Performs the conversion.

impl From<PointN<[i32; 3]>> for PointN<[f32; 3]>

pub fn from(p: PointN<[i32; 3]>) -> PointN<[f32; 3]>

Performs the conversion.

impl<T> From<Vector2<T>> for PointN<[T; 2]>

pub fn from(p: Vector2<T>) -> PointN<[T; 2]>

Performs the conversion.

impl<T> From<Vector3<T>> for PointN<[T; 3]>

pub fn from(p: Vector3<T>) -> PointN<[T; 3]>

Performs the conversion.

impl<'_, N, T> Get<&'_ PointN<N>> for ArrayN<N, T> where
    T: Clone,
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: for<'r> Get<&'r Local<N>>,
    PointN<N>: Point,
    <ArrayN<N, T> as Get<&'r Local<N>>>::Data == T, 

type Data = T

pub fn get(&self, p: &PointN<N>) -> <ArrayN<N, T> as Get<&'_ PointN<N>>>::Data

Get an owned value at location.

impl<'a, '_, N, T, M> Get<&'_ PointN<N>> for ChunkMapReader<'a, N, T, M> where
    M: Clone,
    T: Copy,
    PointN<N>: IntegerPoint,
    PointN<N>: ChunkShape<N>,
    PointN<N>: Eq,
    PointN<N>: Hash,
    ExtentN<N>: IntegerExtent<N>,
    ArrayN<N, T>: Array<N>, 

type Data = T

pub fn get(
    &self,
    p: &PointN<N>
) -> <ChunkMapReader<'a, N, T, M> as Get<&'_ PointN<N>>>::Data

Get an owned value at location.

impl<'_, N, T> GetMut<&'_ PointN<N>> for ArrayN<N, T> where
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: for<'r> GetMut<&'r Local<N>>,
    PointN<N>: Point,
    <ArrayN<N, T> as GetMut<&'r Local<N>>>::Data == T, 

type Data = T

pub fn get_mut(
    &mut self,
    p: &PointN<N>
) -> &mut <ArrayN<N, T> as GetMut<&'_ PointN<N>>>::Data

Get a mutable reference to the value at location.

impl<'_, N, T, M> GetMut<&'_ PointN<N>> for ChunkMap<N, T, M> where
    M: Clone,
    T: Copy,
    PointN<N>: IntegerPoint,
    PointN<N>: ChunkShape<N>,
    PointN<N>: Eq,
    PointN<N>: Hash,
    ExtentN<N>: IntegerExtent<N>,
    ArrayN<N, T>: Array<N>, 

type Data = T

pub fn get_mut(&mut self, p: &PointN<N>) -> &mut T

Get a mutable reference to the value at location.

impl<'_, N, T> GetUnchecked<&'_ PointN<N>> for ArrayN<N, T> where
    T: Clone,
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: for<'r> GetUnchecked<&'r Local<N>>,
    PointN<N>: Point,
    <ArrayN<N, T> as GetUnchecked<&'r Local<N>>>::Data == T, 

type Data = T

pub unsafe fn get_unchecked(
    &self,
    p: &PointN<N>
) -> <ArrayN<N, T> as GetUnchecked<&'_ PointN<N>>>::Data

Get the value at location without doing bounds checking.

impl<'_, N, T> GetUncheckedMut<&'_ PointN<N>> for ArrayN<N, T> where
    ArrayN<N, T>: Array<N>,
    ArrayN<N, T>: for<'r> GetUncheckedMut<&'r Local<N>>,
    PointN<N>: Point,
    <ArrayN<N, T> as GetUncheckedMut<&'r Local<N>>>::Data == T, 

type Data = T

pub unsafe fn get_unchecked_mut(
    &mut self,
    p: &PointN<N>
) -> &mut <ArrayN<N, T> as GetUncheckedMut<&'_ PointN<N>>>::Data

Get a mutable reference to the value at location without doing bounds checking.

impl<N> Hash for PointN<N> where
    N: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl IntegerPoint for PointN<[i32; 3]>

pub const MIN: PointN<[i32; 3]>

The least point.

pub const MAX: PointN<[i32; 3]>

The greatest point.

pub fn join(&self, other: &PointN<[i32; 3]>) -> PointN<[i32; 3]>

Component-wise maximum.

pub fn meet(&self, other: &PointN<[i32; 3]>) -> PointN<[i32; 3]>

Component-wise minimum.

pub fn left_shift(&self, shift_by: i32) -> PointN<[i32; 3]>

Left bitshifts all dimensions.

pub fn right_shift(&self, shift_by: i32) -> PointN<[i32; 3]>

Right bitshifts all dimensions.

pub fn corner_offsets() -> Vec<PointN<[i32; 3]>>

All corners of an N-dimensional unit cube.

pub fn von_neumann_offsets() -> Vec<PointN<[i32; 3]>>

Von Neumann Neighborhood

pub fn moore_offsets() -> Vec<PointN<[i32; 3]>>

Moore Neighborhood

pub fn dimensions_are_powers_of_2(&self) -> bool

Returns true iff all dimensions are powers of 2.

pub fn is_cube(&self) -> bool

Returns true iff all dimensions are equal.

impl IntegerPoint for PointN<[i32; 2]>

pub const MIN: PointN<[i32; 2]>

The least point.

pub const MAX: PointN<[i32; 2]>

The greatest point.

pub fn join(&self, other: &PointN<[i32; 2]>) -> PointN<[i32; 2]>

Component-wise maximum.

pub fn meet(&self, other: &PointN<[i32; 2]>) -> PointN<[i32; 2]>

Component-wise minimum.

pub fn left_shift(&self, shift_by: i32) -> PointN<[i32; 2]>

Left bitshifts all dimensions.

pub fn right_shift(&self, shift_by: i32) -> PointN<[i32; 2]>

Right bitshifts all dimensions.

pub fn corner_offsets() -> Vec<PointN<[i32; 2]>>

All corners of an N-dimensional unit cube.

pub fn von_neumann_offsets() -> Vec<PointN<[i32; 2]>>

Von Neumann Neighborhood

pub fn moore_offsets() -> Vec<PointN<[i32; 2]>>

Moore Neighborhood

pub fn dimensions_are_powers_of_2(&self) -> bool

Returns true iff all dimensions are powers of 2.

pub fn is_cube(&self) -> bool

Returns true iff all dimensions are equal.

impl<T> Mul<PointN<[T; 2]>> for PointN<[T; 2]> where
    T: Copy + Mul<T, Output = T>, 

type Output = PointN<[T; 2]>

The resulting type after applying the * operator.

pub fn mul(self, other: PointN<[T; 2]>) -> PointN<[T; 2]>

Performs the * operation.

impl<T> Mul<PointN<[T; 3]>> for PointN<[T; 3]> where
    T: Copy + Mul<T, Output = T>, 

type Output = PointN<[T; 3]>

The resulting type after applying the * operator.

pub fn mul(self, other: PointN<[T; 3]>) -> PointN<[T; 3]>

Performs the * operation.

impl<T> Mul<T> for PointN<[T; 2]> where
    T: Copy + Mul<T, Output = T>, 

type Output = PointN<[T; 2]>

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> PointN<[T; 2]>

Performs the * operation.

impl<T> Mul<T> for PointN<[T; 3]> where
    T: Copy + Mul<T, Output = T>, 

type Output = PointN<[T; 3]>

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> PointN<[T; 3]>

Performs the * operation.

impl<N> Neg for PointN<N> where
    N: Copy,
    PointN<N>: Sub<PointN<N>>,
    PointN<N>: Zero,
    <PointN<N> as Sub<PointN<N>>>::Output == PointN<N>, 

type Output = PointN<N>

The resulting type after applying the - operator.

pub fn neg(self) -> <PointN<N> as Neg>::Output

Performs the unary - operation.

impl NormSquared for PointN<[f32; 2]>

pub fn norm_squared(&self) -> f32

impl NormSquared for PointN<[i32; 3]>

pub fn norm_squared(&self) -> f32

impl NormSquared for PointN<[i32; 2]>

pub fn norm_squared(&self) -> f32

impl NormSquared for PointN<[f32; 3]>

pub fn norm_squared(&self) -> f32

impl<T> Ones for PointN<[T; 3]> where
    T: SmallOne, 

pub const ONES: PointN<[T; 3]>

A point of all ones.

impl<T> Ones for PointN<[T; 2]> where
    T: SmallOne, 

pub const ONES: PointN<[T; 2]>

A point of all ones.

impl<N> PartialEq<PointN<N>> for PointN<N> where
    N: PartialEq<N>, 

pub fn eq(&self, other: &PointN<N>) -> bool

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

pub fn ne(&self, other: &PointN<N>) -> bool

This method tests for !=.

impl<T> PartialOrd<PointN<[T; 2]>> for PointN<[T; 2]> where
    T: Copy + PartialOrd<T>, 

pub fn partial_cmp(&self, other: &PointN<[T; 2]>) -> Option<Ordering>

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

pub fn lt(&self, other: &PointN<[T; 2]>) -> bool

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

pub fn gt(&self, other: &PointN<[T; 2]>) -> bool

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

pub fn le(&self, other: &PointN<[T; 2]>) -> bool

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

pub fn ge(&self, other: &PointN<[T; 2]>) -> bool

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

impl<T> PartialOrd<PointN<[T; 3]>> for PointN<[T; 3]> where
    T: Copy + PartialOrd<T>, 

pub fn partial_cmp(&self, other: &PointN<[T; 3]>) -> Option<Ordering>

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

pub fn lt(&self, other: &PointN<[T; 3]>) -> bool

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

pub fn gt(&self, other: &PointN<[T; 3]>) -> bool

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

pub fn le(&self, other: &PointN<[T; 3]>) -> bool

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

pub fn ge(&self, other: &PointN<[T; 3]>) -> bool

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

impl Point for PointN<[i32; 3]>

type Scalar = i32

pub fn basis() -> Vec<PointN<[i32; 3]>>

pub fn abs(&self) -> PointN<[i32; 3]>

Returns a point where each component is the absolute value of the input component.

pub fn at(&self, component_index: usize) -> <PointN<[i32; 3]> as Point>::Scalar

Returns the component specified by index. I.e. X = 0, Y = 1, Z = 2.

pub fn map_components(
    &self,
    f: impl Fn(<PointN<[i32; 3]> as Point>::Scalar) -> <PointN<[i32; 3]> as Point>::Scalar
) -> PointN<[i32; 3]>

Returns the point after applying f component-wise.

impl Point for PointN<[f32; 3]>

type Scalar = f32

pub fn basis() -> Vec<PointN<[f32; 3]>>

pub fn abs(&self) -> PointN<[f32; 3]>

Returns a point where each component is the absolute value of the input component.

pub fn at(&self, component_index: usize) -> <PointN<[f32; 3]> as Point>::Scalar

Returns the component specified by index. I.e. X = 0, Y = 1, Z = 2.

pub fn map_components(
    &self,
    f: impl Fn(<PointN<[f32; 3]> as Point>::Scalar) -> <PointN<[f32; 3]> as Point>::Scalar
) -> PointN<[f32; 3]>

Returns the point after applying f component-wise.

impl Point for PointN<[f32; 2]>

type Scalar = f32

pub fn basis() -> Vec<PointN<[f32; 2]>>

pub fn abs(&self) -> PointN<[f32; 2]>

Returns a point where each component is the absolute value of the input component.

pub fn at(&self, component_index: usize) -> <PointN<[f32; 2]> as Point>::Scalar

Returns the component specified by index. I.e. X = 0, Y = 1, Z = 2.

pub fn map_components(
    &self,
    f: impl Fn(<PointN<[f32; 2]> as Point>::Scalar) -> <PointN<[f32; 2]> as Point>::Scalar
) -> PointN<[f32; 2]>

Returns the point after applying f component-wise.

impl Point for PointN<[i32; 2]>

type Scalar = i32

pub fn basis() -> Vec<PointN<[i32; 2]>>

pub fn abs(&self) -> PointN<[i32; 2]>

Returns a point where each component is the absolute value of the input component.

pub fn at(&self, component_index: usize) -> <PointN<[i32; 2]> as Point>::Scalar

Returns the component specified by index. I.e. X = 0, Y = 1, Z = 2.

pub fn map_components(
    &self,
    f: impl Fn(<PointN<[i32; 2]> as Point>::Scalar) -> <PointN<[i32; 2]> as Point>::Scalar
) -> PointN<[i32; 2]>

Returns the point after applying f component-wise.

impl<N> Serialize for PointN<N> where
    N: Serialize, 

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> SmallZero for PointN<[T; 2]> where
    T: SmallZero, 

pub const ZERO: PointN<[T; 2]>

impl<T> SmallZero for PointN<[T; 3]> where
    T: SmallZero, 

pub const ZERO: PointN<[T; 3]>

impl<N> StructuralEq for PointN<N>

impl<N> StructuralPartialEq for PointN<N>

impl<T> Sub<PointN<[T; 2]>> for PointN<[T; 2]> where
    T: Copy + SubAssign<T>, 

type Output = PointN<[T; 2]>

The resulting type after applying the - operator.

pub fn sub(
    self,
    rhs: PointN<[T; 2]>
) -> <PointN<[T; 2]> as Sub<PointN<[T; 2]>>>::Output

Performs the - operation.

impl<T> Sub<PointN<[T; 3]>> for PointN<[T; 3]> where
    T: SubAssign<T> + Copy, 

type Output = PointN<[T; 3]>

The resulting type after applying the - operator.

pub fn sub(
    self,
    rhs: PointN<[T; 3]>
) -> <PointN<[T; 3]> as Sub<PointN<[T; 3]>>>::Output

Performs the - operation.

impl<T> Sub<PointN<T>> for ExtentN<T> where
    PointN<T>: Sub<PointN<T>>,
    <PointN<T> as Sub<PointN<T>>>::Output == PointN<T>, 

type Output = ExtentN<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: PointN<T>) -> <ExtentN<T> as Sub<PointN<T>>>::Output

Performs the - operation.

impl<N> SubAssign<PointN<N>> for PointN<N> where
    N: Copy,
    PointN<N>: Sub<PointN<N>>,
    <PointN<N> as Sub<PointN<N>>>::Output == PointN<N>, 

pub fn sub_assign(&mut self, rhs: PointN<N>)

Performs the -= operation.

impl<T> SubAssign<PointN<T>> for ExtentN<T> where
    ExtentN<T>: Copy,
    ExtentN<T>: Sub<PointN<T>>,
    <ExtentN<T> as Sub<PointN<T>>>::Output == ExtentN<T>, 

pub fn sub_assign(&mut self, rhs: PointN<T>)

Performs the -= operation.

impl<N> Zero for PointN<N> where
    PointN<N>: Point,
    PointN<N>: SmallZero, 

pub fn zero() -> PointN<N>

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.