ff_automaton.hpp

Go to the documentation of this file.

 
#ifndef PARALLEL_CELLULAR_AUTOMATA_FASTFLOW_AUTOMATON_HPP
#define PARALLEL_CELLULAR_AUTOMATA_FASTFLOW_AUTOMATON_HPP
#include <ff/ff.hpp>
#include <ff/parallel_for.hpp>
#include <iostream>
#include <thread>
using namespace std;
 
namespace ca
{
namespace ffl
{
template <typename T>
class CellularAutomaton
{
  public:
    CellularAutomaton(ca::Grid<T> &grid, std::function<T(T, T, T, T, T, T, T, T, T)> update_function,
                      unsigned workers = 0)
        : grid(grid), generation(0), update_function(update_function),
          pf((workers) ? workers : std::thread::hardware_concurrency())
    {
 
        this->nw = (workers) ? workers : std::thread::hardware_concurrency();
    };
    CellularAutomaton(CellularAutomaton &&other)
    {
        // move what's movable and copying numeric types.
        grid = std::move(other.grid);
        generation = other.generation;
        update_function = other.update_function;
        nw = other.nw;
        pf = std::move(other.pf);
        // set the old object in a valid state
        other.generation = 0;
    }
 
    CellularAutomaton(const CellularAutomaton &other) = delete;
 
    virtual void simulate(unsigned steps = 1)
    {
        if (steps == 0)
            return;
        Grid<T> new_grid = Grid<T>::newWithSameSize(grid);
 
        while (steps > 0)
        {
            pf.parallel_for(
                0, grid.rows(),
                [&](const long i) {
                    for (size_t j = 0; j < grid.columns(); ++j)
                    {
                        auto cell = std::make_tuple(grid(i, j));
                        new_grid(i, j) = std::apply(update_function, std::tuple_cat(cell, get_neighborhood(i, j)));
                    }
                },
                nw);
            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);
    };
    unsigned nw;
    ff::ParallelFor pf;
};
} // namespace ffl
} // namespace ca
 
#endif