Struct point_nd::PointND

pub struct PointND<T, const N: usize> where
    T: Clone + Copy,  { /* private fields */ }

The whole point of the crate (get it?)

It really is just a small wrapper around an array with convenience methods for accessing values if it’s dimensions are 1..=4

Examples

Constructing a Point

No matter how a PointND is constructed, the second generic arg must be filled with the number of dimensions it needs to have

If a point of zero dimensions is constructed, it will panic

use point_nd::PointND;

// Creates a 3D point with all values set to 5
//  When using this function, complete type annotation is necessary
let p: PointND<i32, 3> = PointND::fill(5);

// Creates a 2D point from values of a given vector or array
let vec = vec![0, 1];
let p: PointND<_, 2> = PointND::from(&vec);

// ERROR:
// let p: PointND<_, 0> = PointND::fill(9);

Accessing Values

It is recommended to use the convenience getters if the dimensions of the point are from 1..=4

use point_nd::PointND;

// A 2D point
let arr: [i32; 2] = [0,1];
let p: PointND<_, 2> = PointND::from(&arr);

// As the point has 2 dimensions, we can access it's values with the x() and y() methods
let x: i32 = p.x();
let y = p.y();

// If the point had 3 dimensions, we could use the above and:
// let z = p.z();

// Or 4:
// ...
// let w = p.w();

assert_eq!(y, arr[1]);

Otherwise indexing or the get() method can be used

use point_nd::PointND;

let arr: [i32; 2] = [0,1];
let p: PointND<_, 2> = PointND::from(&arr);

// Safely getting
//  Returns None if index is out of bounds
let x: Option<i32> = p.get(0);
assert_eq!(x.unwrap(), arr[0]);

// Unsafely indexing
//  If the index is out of bounds, this will panic
let y: i32 = p[1];
assert_eq!(y, arr[1]);

Querying Size

The number of dimensions can be retrieved using the dims() method (short for dimensions)

use point_nd::PointND;

// A 2D point
let p: PointND<i32, 2> = PointND::fill(10);
assert_eq!(p.dims(), 2);

Implementations

impl<T, const N: usize> PointND<T, N> where
    T: Clone + Copy, 

pub fn from(slice: &[T]) -> Self

Returns a new PointND with values from the specified array or vector

Panics

If the length of the slice is zero

pub fn fill(value: T) -> Self

Returns a new PointND with all values set as specified

Panics

If the dimensions of the point being constructed is zero

pub fn dims(&self) -> usize

Returns the number of dimensions of the point (a 2D point will return 2, a 3D point 3, etc)

pub fn get(&self, dim: usize) -> Option<T>

Returns the Some(value) at the specified dimension or None if the dimension is out of bounds

The value of the first dimension is indexed at 0 for easier interoperability with standard indexing

pub fn as_arr(&self) -> [T; N]

Returns an array of all the values contained by the point

pub fn as_vec(&self) -> Vec<T>

Returns a vector of all the values contained by the point

impl<T> PointND<T, 1> where
    T: Clone + Copy, 

Function for safely returning the first value contained by a 1D PointND

pub fn x(&self) -> T

impl<T> PointND<T, 2> where
    T: Clone + Copy, 

Functions for safely returning the first and second values contained by a 2D PointND

pub fn x(&self) -> T

pub fn y(&self) -> T

impl<T> PointND<T, 3> where
    T: Clone + Copy, 

Functions for safely returning the first, second and third values contained by a 3D PointND

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

impl<T> PointND<T, 4> where
    T: Clone + Copy, 

Functions for safely returning the first, second, third and fourth values contained by a 4D PointND

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

pub fn w(&self) -> T

Trait Implementations

impl<T, const N: usize> Add<PointND<T, N>> for PointND<T, N> where
    T: Add<Output = T> + Clone + Copy, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: Clone, const N: usize> Clone for PointND<T, N> where
    T: Clone + Copy, 

fn clone(&self) -> PointND<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for PointND<T, N> where
    T: Clone + Copy, 

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

Formats the value using the given formatter.

impl<T, const N: usize> Div<PointND<T, N>> for PointND<T, N> where
    T: Div<Output = T> + Clone + Copy, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<I, T, const N: usize> Index<I> for PointND<T, N> where
    T: Clone + Copy,
    I: Sized + SliceIndex<[T], Output = T>, 

type Output = T

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const N: usize> Mul<PointND<T, N>> for PointND<T, N> where
    T: Mul<Output = T> + Clone + Copy, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: PartialEq, const N: usize> PartialEq<PointND<T, N>> for PointND<T, N> where
    T: Clone + Copy, 

fn eq(&self, other: &PointND<T, N>) -> bool

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

fn ne(&self, other: &PointND<T, N>) -> bool

This method tests for !=.

impl<T, const N: usize> Sub<PointND<T, N>> for PointND<T, N> where
    T: Sub<Output = T> + Clone + Copy, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: Copy, const N: usize> Copy for PointND<T, N> where
    T: Clone + Copy, 

impl<T: Eq, const N: usize> Eq for PointND<T, N> where
    T: Clone + Copy, 

impl<T, const N: usize> StructuralEq for PointND<T, N> where
    T: Clone + Copy, 

impl<T, const N: usize> StructuralPartialEq for PointND<T, N> where
    T: Clone + Copy,