building_blocks_storage 0.7.1

Efficient storage for maps on sparse or dense, 2D and 3D integer lattices.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use crate::{ArrayIndexer, ArrayStrideIter, Local, Stride};

use building_blocks_core::prelude::*;

/// All information required to do strided iteration over an extent of a single array.
#[derive(Clone)]
pub struct ArrayForEach<N> {
    pub(crate) iter_extent: ExtentN<N>,
    pub(crate) iter: ArrayStrideIter,
}

/// A 2D `ArrayForEach`.
pub type Array2ForEach = ArrayForEach<[i32; 2]>;
/// A 3D `ArrayForEach`.
pub type Array3ForEach = ArrayForEach<[i32; 3]>;

impl<N> ArrayForEach<N>
where
    N: ArrayIndexer<N>,
    PointN<N>: IntegerPoint<N>,
{
    #[inline]
    pub fn new_local_unchecked(
        array_shape: PointN<N>,
        origin: Local<N>,
        iter_extent: ExtentN<N>,
    ) -> Self {
        Self {
            iter_extent,
            iter: N::make_stride_iter(array_shape, origin, PointN::ONES),
        }
    }

    #[inline]
    pub fn new_local(array_shape: PointN<N>, iter_extent: ExtentN<N>) -> Self {
        // Make sure we don't index out of array bounds.
        let iter_extent =
            iter_extent.intersection(&ExtentN::from_min_and_shape(PointN::ZERO, array_shape));

        Self::new_local_unchecked(array_shape, Local(iter_extent.minimum), iter_extent)
    }

    #[inline]
    pub fn new_global_unchecked(array_extent: ExtentN<N>, iter_extent: ExtentN<N>) -> Self {
        // Translate to local coordinates.
        let origin = Local(iter_extent.minimum - array_extent.minimum);

        Self {
            iter_extent,
            iter: N::make_stride_iter(array_extent.shape, origin, PointN::ONES),
        }
    }

    #[inline]
    pub fn new_global(array_extent: ExtentN<N>, iter_extent: ExtentN<N>) -> Self {
        // Make sure we don't index out of array bounds.
        let iter_extent = iter_extent.intersection(&array_extent);

        Self::new_global_unchecked(array_extent, iter_extent)
    }
}

impl<N> ArrayForEach<N>
where
    N: ArrayIndexer<N>,
{
    pub fn for_each(self, f: impl FnMut(PointN<N>, Stride)) {
        N::for_each(self, f)
    }
}