block-grid gives you a fixed size, two-dimensional array, with a blocked memory representation. This has the sweet benefit of being much more cache-friendly if you're often accessing nearby coordinates.
- Can store any type
- Generic compile-time block sizes
- Indexing with
(row, col): (usize, usize) - Block level access with
BlockandBlockMut - Constructors from row-major and column-major order arrays
- Iterators for in-memory and row-major order, and by block
no_stdandserdesupport- Also supports no blocks (i.e. classic row-major)
use block_grid::{BlockGrid, CoordsIterator, U2};
fn main() {
let data: Vec<_> = (0..(4 * 6)).collect();
// Construct from row-major ordered data
let grid = BlockGrid::<usize, U2>::from_row_major(4, 6, &data).unwrap();
// The 2D grid looks like:
// +-----------------------+
// | 0 1 | 2 3 | 4 5 |
// | 6 7 | 8 9 | 10 11 |
// |-------+-------+-------|
// | 12 13 | 14 15 | 16 17 |
// | 18 19 | 20 21 | 22 23 |
// +-----------------------+
// Indexing
assert_eq!(grid[(1, 3)], 9);
// Access raw array
let first_five = &grid.raw()[..5];
assert_eq!(first_five, &[0, 1, 6, 7, 2]);
// Iterate over blocks, and access the last
let block = grid.block_iter().last().unwrap();
assert_eq!(block[(0, 1)], 17);
// Iterate in row-major order
for (i, &x) in grid.row_major_iter().enumerate() {
assert_eq!(x, i);
}
// Iterate in memory order, with coordinates
for ((row, col), &x) in grid.each_iter().coords() {
assert_eq!(row * 6 + col, x);
}
}TODO: Stuff about caches
- Non-resizable, and grid dimensions have to be a multiple of the block size.
- Currently, only square blocks, and power-of-two block sizes are supported.
- Computing the modified index takes just a bit more time.
- There are still cache misses when you cross tile boundaries.
- No support for strides or general subsets.
See CHANGELOG.md.
block-grid is licensed under the MIT license.
If your access patterns suit a typical row-major memory representation, you can still use block-grid! If you truly desire alternatives, however, check out array2d, imgref, grid, or toodee. The last two support dynamic resizing. For matrices and linear algebra, there's also nalgebra.