Struct CellularAutomaton 

pub struct CellularAutomaton {
    pub x: usize,
    pub y: usize,
    pub cells: Vec<Vec<i32>>,
    pub cell_processor: fn(&Self, usize, usize) -> i32,
    /* private fields */
}

Fields

x: usize

y: usize

cells: Vec<Vec<i32>>

Field of simulation with self.x and self.y dimensions.

cell_processor: fn(&Self, usize, usize) -> i32

Implementations

impl CellularAutomaton

Construction

pub fn new(x: usize, y: usize) -> CellularAutomaton

Constructor with the given dimensions and default (Conway’s game of life) processor.

pub fn new_with_processor( x: usize, y: usize, processor: fn(c: &CellularAutomaton, x: usize, y: usize) -> i32, ) -> CellularAutomaton

Constructor with the given dimensions and proccesing lambda.

pub fn set_processor( &mut self, processor: fn(c: &CellularAutomaton, x: usize, y: usize) -> i32, ) -> &mut Self

Sets the cell processor lambda for the automaton.

processor: fn(C:&CellularAutomaton, X:usize, Y:usize) -> NextState:i32

---

Allows to use multiple strategies for one field, by swapping cell_processor instead of cloning or moving matrices between automatons.

impl CellularAutomaton

Core processing

pub fn next(&self, x: usize, y: usize) -> i32

Processes the next state of one cell by coordinates via lambda processor self.cell_processor.

pub fn step(&mut self) -> &mut Self

Processes field with rayon borrowing unmutable self to self.cell_processor.

pub fn steps(&mut self, steps: u64) -> &mut Self

Method to process multiple steps of the automaton as one call.

Will be more useful in FFI. But still solves convenience of using.

impl CellularAutomaton

Field fillings

pub fn randomize(&mut self) -> &mut Self

TODO: Add randomize strat

pub fn randomize_prob(&mut self, alive_probability: f64) -> &mut Self

pub fn set_xy(&mut self, x: usize, y: usize, init_state: i32) -> &mut Self

Sets the size of the automaton and initializes all cells with the given state.