Init grid object

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
-name = "nvector"
+name = "grid"
 version = "0.1.0"
 authors = ["Armin Becher <armin.becher@methodpark.de>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[dependencies]
+[dev-dependencies]
 criterion = "0.3.1"
 
 [[bench]]
-name = "two_dim_array"
+name = "benches"
 harness = false

benches/benches.rs

@@ -0,0 +1,48 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use grid::Grid;
+
+fn init_vec_vec(size: usize) -> Vec<Vec<u32>> {
+    vec![vec![0; size]; size]
+}
+
+fn init_vec_flat(size: usize) -> Vec<u32> {
+    vec![0; size * size]
+}
+
+fn init_grid(size: usize) -> Grid<u32> {
+    Grid::new(size, size, 0)
+}
+
+fn get_vec_vec(x: usize, y: usize) -> u32 {
+    let mat = init_vec_vec(10);
+    mat[x][y]
+}
+
+fn get_vec_flat(x: usize, y: usize) -> u32 {
+    let mat = init_vec_flat(10);
+    mat[x / 10 + y % 10]
+}
+
+fn get_grid(x: usize, y: usize) -> u32 {
+    let mat = init_grid(10);
+    mat[x][y]
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("Init vec vec 10x10", |b| b.iter(|| init_vec_vec(black_box(10))));
+    c.bench_function("Init vec flat 10x10", |b| b.iter(|| init_vec_flat(black_box(10))));
+    c.bench_function("Init grid 10x10", |b| b.iter(|| init_grid(black_box(10))));
+
+    c.bench_function("Get vec vec 10x10", |b| {
+        b.iter(|| get_vec_vec(black_box(2), black_box(3)))
+    });
+    c.bench_function("Get vec flat 10x10", |b| {
+        b.iter(|| get_vec_flat(black_box(2), black_box(3)))
+    });
+    c.bench_function("Get grid 10x10", |b| {
+        b.iter(|| get_grid(black_box(2), black_box(3)))
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

benches/two_dim_array.rs

@@ -1,20 +0,0 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-fn init(x: usize, y: usize) -> Vec<Vec<u32>> {
-    vec![vec![42; x]; y]
-}
-
-fn init_flat(x: usize, y: usize) -> Vec<u32> {
-    vec![42; x * y]
-}
-
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("Init  20x20", |b| b.iter(|| init(black_box(20), black_box(20))));
-    c.bench_function("Init flat  20x20", |b| b.iter(|| init_flat(black_box(20), black_box(20))));
-    c.bench_function("Init  2000x2000", |b| b.iter(|| init(black_box(2000), black_box(2000))));
-    c.bench_function("Init flat  2000x2000", |b| b.iter(|| init_flat(black_box(2000), black_box(2000))));
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

src/lib.rs

@@ -0,0 +1,51 @@
+use std::ops::Index;
+
+pub struct Grid<T> {
+    data: Vec<T>,
+    row_len: usize,
+}
+
+impl<T: Clone> Grid<T> {
+    pub fn new(rows: usize, columns: usize, data: T) -> Grid<T> {
+        Grid {
+            data: vec![data; rows * columns],
+            row_len: rows,
+        }
+    }
+
+    pub fn get(&self, row: usize, column: usize) -> Option<&T> {
+        self.data.get(row / self.row_len + column % self.row_len)
+    }
+}
+
+impl<T: Clone> Index<usize> for Grid<T> {
+    type Output = [T];
+
+    fn index(&self, idx: usize) -> &Self::Output {
+        &self.data[(idx / &self.row_len)..]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn ctr() {
+        Grid::new(1, 2, 3);
+        Grid::new(1, 2, 1.2);
+        Grid::new(1, 2, 'a');
+    }
+
+    #[test]
+    fn get() {
+        let grid = Grid::new(1, 2, 3);
+        assert_eq!(grid.get(0, 0), Some(&3));
+    }
+
+    #[test]
+    fn idx() {
+        let grid = Grid::new(1, 2, 3);
+        assert_eq!(grid[0][0], 3);
+    }
+}