Synchronous update over rotating sub-blocks. More...

#include <tpl_ca_update_scheme.H>

Public Member Functions
template<typename Engine , typename Rule >
void	apply (Engine &e, Rule &r) const
	Execute one block-synchronous step.

Static Public Attributes
static constexpr bool	requires_double_buffer = true

static constexpr bool	requires_block_rule = false

static constexpr std::size_t	block_size = BlockSize

Detailed Description

template<std::size_t BlockSize = 4, typename Order = RowMajor>
struct Aleph::CA::Block_Synchronous_Update< BlockSize, Order >

Synchronous update over rotating sub-blocks.

The lattice is split into non-overlapping blocks of side BlockSize. Each step() updates all cells inside the active block index using the canonical synchronous rule (read from cur, write to nxt, swap), then advances the active block index. Cells outside the active block carry over unchanged.

After (n_blocks) steps every cell has been updated exactly once.

Template Parameters

BlockSize	side of the square (or cubic) block in cells.
Order	intra-block iteration order.

Definition at line 459 of file tpl_ca_update_scheme.H.

Member Function Documentation

◆ apply()

template<std::size_t BlockSize = 4, typename Order = RowMajor>

template<typename Engine , typename Rule >

void Aleph::CA::Block_Synchronous_Update< BlockSize, Order >::apply	(	Engine &	e,
		Rule &	r
	)		const

inline

Execute one block-synchronous step.

Template Parameters

Engine	engine type providing `current_buffer()`, `next_buffer()`, `swap_buffers()`, `neighborhood()` and `step_count()`.
Rule	cell rule satisfying `RuleLike<Rule, Lattice>`.