Struct Array3d

pub struct Array3d<T> {
    pub shape: V3i,
    pub data: Vec<T>,
}

Fields

shape: V3i

data: Vec<T>

Implementations

impl<T: Clone> Array3d<T>

pub fn from_fn<F: Fn(V3i) -> T>(s: V3i, f: F) -> Array3d<T>

pub fn from_fn_doubled<F: Fn(V3i) -> (T, T)>( sz: V3i, axis: i32, f: F, ) -> Array3d<T>

production from a function with expansion, todo - make this more general e.g.‘production in blocks’ the motivation is to share state across the production of a block of adjacent cells

pub fn fill_val(size: V3i, val: T) -> Array3d<T>

pub fn len(&self) -> usize

pub fn linear_index(&self, pos: V3i) -> usize

pub fn size(&self) -> V3i

pub fn map_xyz<B: Clone, F: Fn(V3i, &T) -> B>(&self, f: F) -> Array3d<B>

produce a new array3d by applying a function to every element

pub fn map_strided_region<B: Clone, F: Fn(V3i, &T) -> B>( &self, range: Range<V3i>, stride: V3i, f: F, ) -> Array3d<B>

pub fn for_each<F: Fn(V3i, &mut T)>(&mut self, f: F)

internal iteration with inplace mutation

pub fn map_xy<F, B>(&self, a_func: F) -> Array2d<B>

where F: Fn(&Self, i32, i32) -> B, B: Clone,

pub fn map_xz<F, B>(&self, a_func: F) -> Array2d<B>

where F: Fn(&Self, i32, i32) -> B, B: Clone,

pub fn map_yz<F, B>(&self, a_func: F) -> Array2d<B>

where F: Fn(&Self, i32, i32) -> B, B: Clone,

pub fn reshape(&mut self, s: V3i)

pub fn fold_z<B, F>(&self, init_val: B, f: F) -> Array2d<B>

where B: Clone, F: Fn(V3i, B, &T) -> B,

pub fn fold_x<B: Clone, F: Fn(V3i, B, &T) -> B>( &self, input: B, f: F, ) -> Array2d<B>

produce a 2d array by folding along the X axis

pub fn fold_xyz<A, B, C, FOLDX, FOLDY, FOLDZ>( &self, (input_x, fx): (A, FOLDX), (input_y, fy): (B, FOLDY), (input_z, fz): (C, FOLDZ), ) -> A

where A: Clone, B: Clone, C: Clone, FOLDZ: Fn(V3i, C, &T) -> C, FOLDY: Fn(i32, i32, B, &C) -> B, FOLDX: Fn(i32, A, &B) -> A,

fold values along x,y,z in turn without intermediate storage

pub fn fold_zyx<A, B, C, FOLDX, FOLDY, FOLDZ>( &self, (input_x, fx): (A, FOLDX), (input_y, fy): (B, FOLDY), (input_z, fz): (C, FOLDZ), ) -> C

where A: Clone, B: Clone, C: Clone, FOLDZ: Fn(i32, C, &B) -> C, FOLDY: Fn(i32, i32, B, &A) -> B, FOLDX: Fn(V3i, A, &T) -> A,

fold values along z,y,x in turn without intermediate storage

pub fn fold<B, F>(&self, input: B, f: F) -> B

where F: Fn(V3i, B, &T) -> B, B: Clone,

fold the whole array to produce a single value

pub fn fold_tiles<B, F>(&self, tilesize: V3i, input: B, f: &F) -> Array3d<B>

where F: Fn(V3i, B, &T) -> B, B: Clone,

produce tiles by applying a function to every subtile output size is divided by tilesize must be exact multiple.

pub fn fold_region<B, F>(&self, r: Range<V3i>, input: B, f: &F) -> B

where F: Fn(V3i, B, &T) -> B, B: Clone,

subroutine for ‘fold tiles’, see context closure is borrowed for multiple invocation by caller

pub fn get_indexed(&self, pos: V3i) -> (V3i, &T)

pub fn region_all(&self) -> Range<V3i>

pub fn map_region_strided<F, B>( &self, region: Range<V3i>, stride: V3i, f: F, ) -> Array3d<B>

where F: Fn(V3i, &T) -> B, B: Clone,

pub fn map_strided<F, B>(&self, stride: V3i, f: F) -> Array3d<B>

where F: Fn(V3i, &T) -> B, B: Clone,

pub fn map_region<F, B>(&self, region: Range<V3i>, f: F) -> Array3d<B>

where F: Fn(V3i, &T) -> B, B: Clone,

pub fn convolute_neighbours<F, B>(&self, f: F) -> Array3d<B>

where F: Fn(&T, Vec3<Neighbours<&T>>) -> B, B: Clone,

X form of convolution
XOX passing each cell and it’s X immiediate neighbours on each axis

pub fn index_wrap(&self, pos: V3i) -> &T

pub fn get_wrap(&self, pos: V3i) -> &T

pub fn get_ofs_wrap(&self, pos: V3i, dx: i32, dy: i32, dz: i32) -> &T

pub fn convolute_neighbours_wrap<F, B>(&self, f: F) -> Array3d<B>

where F: Fn(&T, Vec3<Neighbours<&T>>) -> B, B: Clone,

pub fn convolute_2x2x2_wrap<F, B>(&self, f: F) -> Array3d<B>

where F: Fn(V3i, [[[&T; 2]; 2]; 2]) -> B, B: Clone,

special case of convolution for 2x2 cells, e.g. for marching cubes

pub fn fold_half<F, B>(&self, fold_fn: F) -> Array3d<B>

where F: Fn(V3i, [[[&T; 2]; 2]; 2]) -> B, B: Clone,

take 2x2x2 blocks, fold to produce new values

Trait Implementations

impl<T: Clone> Index<Vec3<i32>> for Array3d<T>

type Output = T

The returned type after indexing.

fn index(&self, pos: V3i) -> &T

Performs the indexing (container[index]) operation.

impl<T: Clone> IndexMut<Vec3<i32>> for Array3d<T>

fn index_mut(&mut self, pos: V3i) -> &mut T

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