Struct ArrayNd 

pub struct ArrayNd<const N: usize, T> {
    pub data: Vec<T>,
    pub dims: [usize; N],
    pub dim_strides: [usize; N],
}

Fields

data: Vec<T>

dims: [usize; N]

dim_strides: [usize; N]

Implementations

impl<'a, const C: usize, T: Copy> ArrayNd<C, T>

pub fn iter(&'a self) -> Iter<'a, T>

impl<'a, const C: usize, T: Copy> ArrayNd<C, T>

pub fn iter_mut(&'a mut self) -> IterMut<'a, T>

impl<const C: usize, T: Copy> ArrayNd<C, T>

pub fn new<U: Copy + TryInto<usize>>(dims: [U; C], default: T) -> Self

pub fn from_slice<U: Copy + TryInto<usize>>(dims: [U; C], slice: &[T]) -> Self

pub fn resized( &self, new_dims: [usize; C], default: T, offset: Vector<C, i32>, ) -> Self

pub fn padded(&self, padding: i32, default: T) -> Self

impl<const N: usize, T: Copy + PartialEq> ArrayNd<N, T>

pub fn replace_all(&mut self, from: &T, to: &T)

impl<const N: usize, T> ArrayNd<N, T>

pub fn get_linear(&self, index: usize) -> &T

pub fn get_mut_linear(&mut self, index: usize) -> &mut T

pub fn set_linear(&mut self, index: usize, v: T)

pub fn get<I>(&self, p: I) -> Option<&T>

where Self: LinearIndex<I>,

pub fn get_mut<I>(&mut self, p: I) -> Option<&mut T>

where Self: LinearIndex<I>,

pub fn set<I>(&mut self, p: I, v: T) -> bool

where Self: LinearIndex<I>,

impl<const N: usize, T> ArrayNd<N, T>

pub fn find_item(&self, item: &T) -> Option<Vector<N, i32>>

where T: PartialEq,

pub fn find_last_item(&self, item: &T) -> Option<Vector<N, i32>>

where T: PartialEq,

pub fn find_all<F, I>(&self, predicate: F) -> Vec<I>

where F: Fn(&T) -> bool, T: PartialEq, Self: LinearIndex<I>,

pub fn find_all_items<I>(&self, item: &T) -> Vec<I>

where T: PartialEq, Self: LinearIndex<I>,

impl<const N: usize, T> ArrayNd<N, T>

pub fn map<F, U>(&self, f: F) -> ArrayNd<N, U>

where F: Fn(&T) -> U,

impl<const N: usize, T> ArrayNd<N, T>

pub fn line_iter<const B: bool>( &self, p0: Vector<N, i32>, p1: Vector<N, i32>, ) -> LineIterator<B, N>

impl<const N: usize, T> ArrayNd<N, T>

pub fn iter_values_in_line<const B: bool>( &self, p0: Vector<N, i32>, p1: Vector<N, i32>, ) -> impl Iterator<Item = &T>

impl<const N: usize, T: Copy> ArrayNd<N, T>

pub fn draw_line<const B: bool>(&mut self, line: Line<Vector<N, i32>>, v: T)

impl<const N: usize, T: Copy> ArrayNd<N, T>

pub fn draw_block(&mut self, matching: [Option<usize>; N], v: T)

impl<T> ArrayNd<2, T>

pub fn width(&self) -> usize

pub fn height(&self) -> usize

impl<T> ArrayNd<3, T>

pub fn width(&self) -> usize

pub fn height(&self) -> usize

pub fn depth(&self) -> usize

impl ArrayNd<2, char>

pub fn from_buffer<R: Read>( reader: BufReader<R>, ) -> Result<Self, CharArrayParseError>

pub fn from_read<R: Read>(reader: R) -> Result<Self, CharArrayParseError>

impl<T: Copy> ArrayNd<2, T>

pub fn with_dimensions(width: usize, height: usize, default: T) -> Self

pub fn shift_n_rows_down(&mut self, n: usize, default: T)

impl<T: Copy> ArrayNd<3, T>

pub fn with_dimensions( width: usize, height: usize, depth: usize, default: T, ) -> Self

Trait Implementations

impl<const N: usize, T: Clone> Clone for ArrayNd<N, T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize, T: Debug> Debug for ArrayNd<N, T>

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

Formats the value using the given formatter.

impl<'de, const N: usize, T> Deserialize<'de> for ArrayNd<N, T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const C: usize, T: Display> Display for ArrayNd<C, T>

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

Formats the value using the given formatter.

impl<const N: usize, T: Hash> Hash for ArrayNd<N, T>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const C: usize, T: Copy> Index<Vector<C, i32>> for ArrayNd<C, T>

type Output = T

The returned type after indexing.

fn index(&self, index: Vector<C, i32>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const C: usize, T: Copy> Index<usize> for ArrayNd<C, T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<const C: usize, T: Copy> IndexMut<usize> for ArrayNd<C, T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, const C: usize, T: Copy> IntoIterator for &'a ArrayNd<C, T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, const C: usize, T: Copy> IntoIterator for &'a mut ArrayNd<C, T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const C: usize, T: Copy> IntoIterator for ArrayNd<C, T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T> LinearIndex<Vector<N, i32>> for ArrayNd<N, T>

fn index_unchecked(&self, i: Vector<N, i32>) -> Option<usize>

fn unindex(&self, i: usize) -> Option<Vector<N, i32>>

unsafe fn cardinality(&self) -> Option<usize>

👎Deprecated

This is unsafe and should not be called as overflows are not checked. Uses Iterator::product

fn is_in_bounds(&self, i: &Vector<N, i32>) -> bool

fn index(&self, i: I) -> Option<usize>

impl<const N: usize, T> LinearIndex<Vector<N, usize>> for ArrayNd<N, T>

fn index_unchecked(&self, i: Vector<N, usize>) -> Option<usize>

fn unindex(&self, i: usize) -> Option<Vector<N, usize>>

unsafe fn cardinality(&self) -> Option<usize>

👎Deprecated

This is unsafe and should not be called as overflows are not checked. Uses Iterator::product

fn is_in_bounds(&self, i: &Vector<N, usize>) -> bool

fn index(&self, i: I) -> Option<usize>

impl<const N: usize, T> LinearIndex<usize> for ArrayNd<N, T>

fn index_unchecked(&self, i: usize) -> Option<usize>

fn unindex(&self, i: usize) -> Option<usize>

unsafe fn cardinality(&self) -> Option<usize>

👎Deprecated

This is unsafe and should not be called as overflows are not checked. Uses Iterator::product

fn is_in_bounds(&self, i: &usize) -> bool

fn index(&self, i: I) -> Option<usize>

impl<const N: usize, T: PartialEq> PartialEq for ArrayNd<N, T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, T> Serialize for ArrayNd<N, T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize, T: Eq> Eq for ArrayNd<N, T>

impl<const C: usize, T> IterateNeighboursContext for ArrayNd<C, T>

impl<const N: usize, T> StructuralPartialEq for ArrayNd<N, T>