Struct point_nd::PointND

source · [−]

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

Expand description

The whole point of the crate (get it?)

This is basically just a small wrapper around an array with convenience methods for accessing values if it’s dimensions are within 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 2D point from values of a given vector or array
let vec: Vec<i32> = vec![0, 1];
let p: PointND<_, 2> = PointND::from(&vec);

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

// ERROR: Can't create a point with zero dimensions
// let p: PointND<_, 0> = PointND::fill(9);

// If you don't like writing PointND twice, use this syntax instead
//  Note: The second generic must still be specified
let p = PointND::<_, 2>::from(&vec);

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

assert_eq!(*y, arr[1]);

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

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

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
//  Note that unlike other accessing methods, this will return a copy of the value
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;

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

Implementations

source

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

source

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

source

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

source

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

source

pub fn dims(&self) -> usize

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

source

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

source

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

source

pub fn apply<F>(self, modifier: F) -> Self where
F: Fn(T) -> T,

Returns a new PointND from the values contained by self after applying the modifier function to them

Examples

use point_nd::PointND;

// Multiplies each item by 10
let p = PointND::<i32, 3>::from(&[0, 1, 2]);
let p = p.apply(|item| item * 10);

assert_eq!(p.as_arr(), [0, 10, 20]);

source

pub fn apply_dims<F>(self, dims: &[usize ], modifier: F) -> Self where
F: Fn(T) -> T,

Returns a new PointND from the values at the specified dimensions after applying the modifier function to them

Any values at dimensions that were not specified are passed as is

If any dimensions specified are out of bounds, this method will ignore it

Examples

use point_nd::PointND;

// Multiplies items at indexes 1 and 2 by 2
let p = PointND::<i32, 4>::from(&[0, 1, 2, 3]);
let p = p.apply_dims(&[1, 2], |item| item * 2);

assert_eq!(p.as_arr(), [0, 2, 4, 3]);

source

pub fn apply_with<F>(self, values: [T; N], modifier: F) -> Self where
F: Fn(T, T) -> T,

Returns a new PointND from the values specified and those contained by self after applying the modifier to both

Examples

use point_nd::PointND;

// Adds each item in the PointND with their respective items in the array
let p = PointND::<i32, 3>::from(&[0, 1, 2]);
let p = p.apply_with([1, 2, 3], |a, b| a + b);

assert_eq!(p.as_arr(), [1, 3, 5]);