sequential_automaton.hpp

Go to the documentation of this file.

 
#ifndef PARALLEL_CELLULAR_AUTOMATA_SEQUENTIAL_AUTOMATON_HPP
#define PARALLEL_CELLULAR_AUTOMATA_SEQUENTIAL_AUTOMATON_HPP
#include <functional>
#include <iostream>
#include <tuple>
 
#ifndef PARALLEL_CELLULAR_AUTOMATA_CELLULAR_AUTOMATA_HPP
#include "cellular_automata.hpp"
#endif
#include "grid.hpp"
 
namespace ca
{
namespace seq
{
template <typename T>
class CellularAutomaton
{
  public:
    CellularAutomaton(Grid<T> &grid, std::function<T(T, T, T, T, T, T, T, T, T)> update_function)
        : grid{grid}, generation(0), update_function(update_function){};
 
    CellularAutomaton(CellularAutomaton &&other)
    {
        // move what's movable and copying numeric types.
        grid = std::move(other.grid);
        update_function = std::move(other.update_function);
    }
 
    CellularAutomaton(const CellularAutomaton &other) = delete;
 
    virtual void simulate(unsigned steps = 1)
    {
        if (steps == 0)
            return;
        // allocate new grid
        auto new_grid = ca::Grid<int>::newWithSameSize(grid);
 
        // compute state and put values on the new grid.
        while (steps > 0)
        {
            for (size_t r{0}; r < grid.rows(); ++r)
            {
                for (size_t c{0}; c < grid.columns(); ++c)
                {
                    auto cell = std::make_tuple(grid(r, c));
                    new_grid(r, c) = std::apply(update_function, std::tuple_cat(cell, get_neighborhood(r, c)));
                }
            }
            // swap grids so grid contains the final value.
            grid.swap(new_grid);
 
            ++generation;
            --steps;
        }
    }
 
    virtual size_t get_generation() const
    {
        return generation;
    }
    friend std::ostream &operator<<(std::ostream &os, const CellularAutomaton &ca)
    {
 
        return os << ca.grid;
    }
 
  protected:
    Grid<T> &grid;
 
    size_t generation;
    std::function<T(T, T, T, T, T, T, T, T, T)> update_function;
    virtual std::tuple<T, T, T, T, T, T, T, T> get_neighborhood(int row, int col) const
 
    {
        unsigned rows = grid.rows();
        unsigned columns = grid.columns();
        T top_left, top, top_right, left, right, bottom_left, bottom, bottom_right;
        top_left = grid((row - 1 + rows) % rows, (col - 1 + columns) % columns);
        top = grid((row - 1 + rows) % rows, col);
        top_right = grid((row - 1 + rows) % rows, (col + 1) % columns);
        left = grid(row, (col - 1 + columns) % columns);
        right = grid(row, (col + 1) % columns);
        bottom_left = grid((row + 1) % rows, (col - 1 + columns) % columns);
        bottom = grid((row + 1) % rows, col);
        bottom_right = grid((row + 1) % rows, (col + 1) % columns);
        return std::make_tuple(top_left, top, top_right, left, right, bottom_left, bottom, bottom_right);
    };
};
} // namespace seq
} // namespace ca
 
#endif