355154fa9b
Thanks @jijinbei.
145 lines
5.3 KiB
Rust
145 lines
5.3 KiB
Rust
//! A rectangular net of values: a surface's control points, a sample grid. Rectangular by
|
|
//! construction, so code that walks it never meets a missing cell: a grid is made from a
|
|
//! function of `(i, j)`, from one row, or from rows checked once ([`Grid::from_u_rows`]).
|
|
|
|
/// `count[0]` values along u by `count[1]` along v; value `(i, j)` (i along u) is stored at
|
|
/// `j·count[0] + i`, u fastest.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Grid<T> {
|
|
count: [usize; 2],
|
|
cells: Vec<T>,
|
|
}
|
|
|
|
impl<T> Grid<T> {
|
|
/// A grid of `f(i, j)` for every cell; `None` when `count[0]·count[1]` overflows.
|
|
pub fn from_fn(count: [usize; 2], mut f: impl FnMut(usize, usize) -> T) -> Option<Grid<T>> {
|
|
let total = count[0].checked_mul(count[1])?;
|
|
let cu = count[0].max(1);
|
|
Some(Grid { count, cells: (0..total).map(|k| f(k % cu, k / cu)).collect() })
|
|
}
|
|
|
|
/// One row of values along u: `count` is `[cells.len(), 1]` (a curve's control points seen
|
|
/// as a net).
|
|
pub fn row(cells: Vec<T>) -> Grid<T> {
|
|
Grid { count: [cells.len(), 1], cells }
|
|
}
|
|
|
|
/// A grid whose caller already holds `count[0]·count[1]` cells (a checked surface's net).
|
|
pub(crate) fn checked(count: [usize; 2], cells: Vec<T>) -> Grid<T> {
|
|
Grid { count, cells }
|
|
}
|
|
|
|
/// Values along u and along v.
|
|
pub fn count(&self) -> [usize; 2] {
|
|
self.count
|
|
}
|
|
|
|
pub fn is_empty(&self) -> bool {
|
|
self.cells.is_empty()
|
|
}
|
|
|
|
/// Value `(i, j)`, i along u.
|
|
pub fn get(&self, i: usize, j: usize) -> Option<&T> {
|
|
if i < self.count[0] { self.cells.get(j * self.count[0] + i) } else { None }
|
|
}
|
|
|
|
/// The values, u fastest.
|
|
pub fn cells(&self) -> &[T] {
|
|
&self.cells
|
|
}
|
|
|
|
/// The runs along u, one per v index: run `j` holds values `(0, j)`, `(1, j)`, ….
|
|
pub fn lines(&self) -> std::slice::Chunks<'_, T> {
|
|
self.cells.chunks(self.count[0].max(1))
|
|
}
|
|
|
|
/// The grid with u and v swapped: value `(i, j)` becomes value `(j, i)`.
|
|
pub fn transposed(&self) -> Grid<T>
|
|
where
|
|
T: Clone,
|
|
{
|
|
let [cu, cv] = self.count;
|
|
let cells = (0..self.cells.len()).filter_map(|k| self.get(k / cv.max(1), k % cv.max(1)).cloned()).collect();
|
|
Grid { count: [cv, cu], cells }
|
|
}
|
|
|
|
/// The values to change in place; the grid keeps its shape.
|
|
pub fn cells_mut(&mut self) -> &mut [T] {
|
|
&mut self.cells
|
|
}
|
|
|
|
pub fn into_cells(self) -> Vec<T> {
|
|
self.cells
|
|
}
|
|
|
|
pub fn map<U>(self, f: impl FnMut(T) -> U) -> Grid<U> {
|
|
Grid { count: self.count, cells: self.cells.into_iter().map(f).collect() }
|
|
}
|
|
|
|
/// [`Grid::map`] with a step that can fail: the first failure.
|
|
pub fn try_map<U, E>(self, f: impl FnMut(T) -> Result<U, E>) -> Result<Grid<U>, E> {
|
|
Ok(Grid { count: self.count, cells: self.cells.into_iter().map(f).collect::<Result<_, _>>()? })
|
|
}
|
|
|
|
/// The grid as rows, one per u index: `rows[i][j]` is value `(i, j)` (truck's layout).
|
|
pub fn into_u_rows(self) -> Vec<Vec<T>> {
|
|
let cu = self.count[0];
|
|
let mut rows: Vec<Vec<T>> = (0..cu).map(|_| Vec::with_capacity(self.count[1])).collect();
|
|
for (k, v) in self.cells.into_iter().enumerate() {
|
|
if let Some(row) = rows.get_mut(k % cu) {
|
|
row.push(v);
|
|
}
|
|
}
|
|
rows
|
|
}
|
|
}
|
|
|
|
impl<T: Clone> Grid<T> {
|
|
/// A grid from rows, one per u index: `rows[i][j]` is value `(i, j)` (truck's layout).
|
|
/// `None` when the rows differ in length, the one check rows from elsewhere need.
|
|
pub fn from_u_rows<R: AsRef<[T]>>(rows: &[R]) -> Option<Grid<T>> {
|
|
let cv = rows.first().map_or(0, |r| r.as_ref().len());
|
|
if rows.iter().any(|r| r.as_ref().len() != cv) {
|
|
return None;
|
|
}
|
|
let cells = (0..cv).flat_map(|j| rows.iter().filter_map(move |r| r.as_ref().get(j).cloned())).collect();
|
|
Some(Grid { count: [rows.len(), cv], cells })
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn rows_go_in_and_come_back_out() {
|
|
// rows[i][j]: two along u, three along v.
|
|
let rows = vec![vec![(0, 0), (0, 1), (0, 2)], vec![(1, 0), (1, 1), (1, 2)]];
|
|
let g = Grid::from_u_rows(&rows).unwrap();
|
|
assert_eq!(g.count(), [2, 3]);
|
|
assert_eq!(g.cells(), &[(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)]);
|
|
assert_eq!(g.get(1, 2), Some(&(1, 2)));
|
|
assert_eq!(g.get(2, 0), None);
|
|
assert_eq!(g.into_u_rows(), rows);
|
|
assert_eq!(Grid::row(vec![1, 2, 3]).count(), [3, 1]);
|
|
let g = Grid::from_fn([3, 2], |i, j| (i, j)).unwrap();
|
|
assert_eq!(g.lines().collect::<Vec<_>>(), vec![&[(0, 0), (1, 0), (2, 0)][..], &[(0, 1), (1, 1), (2, 1)][..]]);
|
|
let t = g.transposed();
|
|
assert_eq!(t.count(), [2, 3]);
|
|
assert!((0..3).all(|i| (0..2).all(|j| t.get(j, i) == g.get(i, j))));
|
|
assert!(Grid::from_fn([usize::MAX, 2], |_, _| 0).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn only_rectangles_are_grids() {
|
|
assert!(Grid::from_u_rows(&[vec![1, 2], vec![3]]).is_none());
|
|
let empty: [Vec<u8>; 0] = [];
|
|
assert!(Grid::from_u_rows(&empty).is_some_and(|g| g.is_empty()));
|
|
}
|
|
|
|
#[test]
|
|
fn try_map_stops_at_the_first_failure() {
|
|
assert_eq!(Grid::row(vec![1, -1, -2]).try_map(|x| if x > 0 { Ok(x) } else { Err(x) }), Err(-1));
|
|
}
|
|
}
|