use burn::{
Tensor,
config::Config,
module::Module,
prelude::{
Bool,
Int,
SliceArg,
},
tensor::{
Device,
Slice,
SliceOps,
},
};
use crate::{
sims::conway::{
ops::{
fuzz_state_2d,
next_state_wrapped_2d,
project_wrapped_toroidal_boarders,
},
util::{
ConwaySim,
slices::read_2d_slice,
},
},
support::geometry::GridShape2D,
};
#[derive(Config, Debug)]
pub struct ConwayLife2DConfig {
pub shape: GridShape2D,
}
impl ConwayLife2DConfig {
pub fn init(
self,
device: &Device,
) -> ConwayLife2DState {
ConwayLife2DState {
shape: self.shape,
state: Tensor::<2, Int>::zeros(self.shape.as_height_width(), device).bool(),
}
}
}
#[derive(Module, Debug)]
pub struct ConwayLife2DState {
#[module(skip)]
pub shape: GridShape2D,
pub state: Tensor<2, Bool>,
}
impl ConwaySim for ConwayLife2DState {
fn device(&self) -> Device {
self.state.device()
}
fn fuzz(
&mut self,
density: f64,
) {
if density == 0.0 {
return;
}
self.state
.inplace(|s| project_wrapped_toroidal_boarders(fuzz_state_2d(s, density)))
}
fn step(&mut self) {
self.state.inplace(next_state_wrapped_2d);
}
}
impl ConwayLife2DState {
pub fn read_slice<R>(
&self,
ranges: R,
) -> Vec<Vec<bool>>
where
R: SliceArg,
{
read_2d_slice(self.state.clone(), ranges)
}
pub fn write_slice<R>(
&mut self,
ranges: R,
data: Vec<Vec<bool>>,
) where
R: SliceArg,
{
let slices: [Slice; 2] = ranges.into_slices(&self.state.shape()).try_into().unwrap();
let [h, w] = self.state.shape().slice(&slices).unwrap().dims();
assert_eq!(data.len(), h);
for row in data.iter() {
assert_eq!(row.len(), w);
}
let mut block = Vec::with_capacity(h * w);
for row in data.iter() {
for &cell in row.iter() {
block.push(cell as u32);
}
}
let data = Tensor::<1, Int>::from_ints(block.as_slice(), &self.device())
.bool()
.reshape([h, w]);
self.state
.inplace(|s| project_wrapped_toroidal_boarders(s.slice_assign(slices, data)));
}
}
#[cfg(test)]
mod tests {
use burn::{
prelude::s,
tensor::TensorData,
};
use serial_test::serial;
use super::*;
use crate::{
sims::conway::{
ops::next_interior_2d,
util::ConwaySim,
},
support::testing::{
DeviceMemoryGuard,
performance_device,
},
};
fn torus_step_2d(torus: &[Vec<bool>]) -> Vec<Vec<bool>> {
let h = torus.len();
let w = torus[0].len();
(0..h)
.map(|i| {
(0..w)
.map(|j| {
let mut n = 0;
for di in [h - 1, 0, 1] {
for dj in [w - 1, 0, 1] {
if (di, dj) != (0, 0) && torus[(i + di) % h][(j + dj) % w] {
n += 1;
}
}
}
n == 3 || (n == 2 && torus[i][j])
})
.collect()
})
.collect()
}
#[test]
#[serial]
fn test_step_after_write_slice_wraps() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let mut life: ConwayLife2DState =
ConwayLife2DConfig::new(GridShape2D::square(7)).init(&device);
life.write_slice(s![1, 1..4], vec![vec![true, true, true]]);
let seed = life.read_slice(s![1..6, 1..6]);
life.step();
assert_eq!(life.read_slice(s![1..6, 1..6]), torus_step_2d(&seed));
assert_eq!(
life.read_slice(s![1..6, 2]),
vec![vec![true], vec![true], vec![false], vec![false], vec![true]]
);
}
#[test]
#[serial]
fn test_step_after_fuzz_wraps() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let mut life: ConwayLife2DState = ConwayLife2DConfig::new(GridShape2D {
width: 12,
height: 9,
})
.init(&device);
life.fuzz(0.5);
let seed = life.read_slice(s![1..8, 1..11]);
life.step();
assert_eq!(life.read_slice(s![1..8, 1..11]), torus_step_2d(&seed));
}
#[test]
#[serial]
fn test_fuzz_flips_each_hit_cell() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let mut life: ConwayLife2DState =
ConwayLife2DConfig::new(GridShape2D::square(7)).init(&device);
life.write_slice(
s![1..3, 1..4],
vec![vec![true, false, true], vec![false, true, true]],
);
let seed = life.read_slice(s![.., ..]);
let inverted: Vec<Vec<bool>> = seed
.iter()
.map(|row| row.iter().map(|cell| !cell).collect())
.collect();
life.fuzz(1.0);
assert_eq!(life.read_slice(s![.., ..]), inverted);
life.fuzz(1.0);
assert_eq!(life.read_slice(s![.., ..]), seed);
}
#[test]
#[serial]
fn test_module_reaches_the_board() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let life: ConwayLife2DState = ConwayLife2DConfig::new(GridShape2D::square(5)).init(&device);
assert_eq!(life.devices(), vec![device]);
}
#[test]
#[serial]
fn test_smoke() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let steps = 100;
let grid_size = 20;
let config = ConwayLife2DConfig {
shape: GridShape2D::square(grid_size),
};
let mut game: ConwayLife2DState = config.init(&device);
game.fuzz(0.05);
for _ in 0..steps {
game.step();
}
}
#[test]
#[serial]
fn test_logic() {
let device = performance_device();
let _memory = DeviceMemoryGuard::new(&device);
let config = ConwayLife2DConfig {
shape: GridShape2D::square(5),
};
let mut conway: ConwayLife2DState = config.init(&device);
assert_eq!(
conway.read_slice(s![1..3, 1..3]),
vec![vec![false, false], vec![false, false]]
);
conway.write_slice(s![1..3, 1..3], vec![vec![true, true], vec![true, false]]);
assert_eq!(
conway.read_slice(s![1..3, 1..3]),
vec![vec![true, true], vec![true, false]]
);
conway.write_slice(s![-2.., -2..], vec![vec![false, true], vec![true, true]]);
assert_eq!(
conway.read_slice(s![1..3, 1..3]),
vec![vec![true, true], vec![true, false]]
);
assert_eq!(
conway.read_slice(s![-2.., -2..]),
vec![vec![false, false], vec![false, true]]
);
next_interior_2d(conway.state.clone())
.to_data()
.assert_eq(&TensorData::from([[true; 3]; 3]), false)
}
}