tpl_ca_rule.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef TPL_CA_RULE_H
#define TPL_CA_RULE_H
 
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <random>
#include <type_traits>
#include <tuple>
#include <utility>
 
#include <ah-errors.H>
#include <ca-rng.H>
#include <ca-traits.H>
 
namespace Aleph {
namespace CA {
 
// -----------------------------------------------------------------------
// Outer_Totalistic_Rule
// -----------------------------------------------------------------------
 
template <typename F>
class Outer_Totalistic_Rule
{
  F f_;
 
public:
  constexpr explicit Outer_Totalistic_Rule(F func) : f_(std::move(func)) {}
 
  template <typename State>
  [[nodiscard]] constexpr State operator()(const State &current, Neighbor_View<State> neighbours) const
  {
    std::size_t alive = 0;
    for (const auto &v : neighbours)
      if (v != State{})
        ++alive;
    return f_(current, alive);
  }
};
 
// -----------------------------------------------------------------------
// Totalistic_Rule
// -----------------------------------------------------------------------
 
template <typename F>
class Totalistic_Rule
{
  F f_;
 
public:
  constexpr explicit Totalistic_Rule(F func) : f_(std::move(func)) {}
 
  template <typename State>
  [[nodiscard]] constexpr State operator()(const State &current, Neighbor_View<State> neighbours) const
  {
    using sum_type = std::common_type_t<State, std::intmax_t>;
    sum_type sum = static_cast<sum_type>(current);
    for (const auto &v : neighbours)
      sum += static_cast<sum_type>(v);
    return static_cast<State>(f_(sum));
  }
};
 
// -----------------------------------------------------------------------
// Lookup_Rule
// -----------------------------------------------------------------------
 
namespace ca_rule_detail {
constexpr std::size_t static_pow_rule(std::size_t base, std::size_t exp) noexcept
{
  std::size_t r = 1;
  for (std::size_t i = 0; i < exp; ++i)
    r *= base;
  return r;
}
}  // namespace ca_rule_detail
 
template <std::size_t NumStates, std::size_t NumNeighbors>
class Lookup_Rule
{
public:
  static constexpr std::size_t num_states_v = NumStates;
 
  static constexpr std::size_t num_neighbours_v = NumNeighbors;
 
  static constexpr std::size_t table_size_v
    = ca_rule_detail::static_pow_rule(NumStates, NumNeighbors + 1);
 
  using table_type = std::array<std::size_t, table_size_v>;
 
private:
  table_type table_{};
 
public:
  constexpr Lookup_Rule() = default;
 
  constexpr explicit Lookup_Rule(table_type t) : table_(t) {}
 
  [[nodiscard]] constexpr const table_type &raw_table() const noexcept
  {
    return table_;
  }
 
  template <typename State>
  [[nodiscard]] State operator()(const State &current, Neighbor_View<State> neighbours) const
  {
    ah_length_error_if(neighbours.size() != NumNeighbors)
      << "Lookup_Rule::operator(): expected " << NumNeighbors << " neighbours, got "
      << neighbours.size();
 
    auto validate_state = [](const State &value, const char *label)
    {
      if constexpr (std::is_signed_v<State>)
        ah_domain_error_if(value < State{})
          << "Lookup_Rule::operator(): " << label << " state is negative";
 
      const std::size_t idx = static_cast<std::size_t>(value);
      ah_domain_error_if(idx >= NumStates) << "Lookup_Rule::operator(): " << label << " state "
                                           << idx << " outside [0, " << NumStates << ")";
      return idx;
    };
 
    std::size_t idx = validate_state(current, "current");
    for (const auto &v : neighbours)
      idx = idx * NumStates + validate_state(v, "neighbour");
    return static_cast<State>(table_[idx]);
  }
};
 
[[nodiscard]] inline constexpr Lookup_Rule<2, 2> make_wolfram_elementary_rule(std::uint8_t rule_no) noexcept
{
  Lookup_Rule<2, 2>::table_type t{};
  for (std::size_t pattern = 0; pattern < 8; ++pattern)
    {
      const std::size_t left = (pattern >> 2) & 1;
      const std::size_t self = (pattern >> 1) & 1;
      const std::size_t right = (pattern >> 0) & 1;
      const std::size_t lookup_idx = (self << 2) | (left << 1) | right;
      t[lookup_idx] = static_cast<std::uint8_t>((rule_no >> pattern) & 1);
    }
  return Lookup_Rule<2, 2>(t);
}
 
// -----------------------------------------------------------------------
// Probabilistic_Rule
// -----------------------------------------------------------------------
 
template <typename F, typename Engine = std::mt19937_64>
class Probabilistic_Rule
{
  mutable F f_;
  std::uint64_t master_seed_ = 0;
 
public:
  using engine_type = Engine;
 
  constexpr explicit Probabilistic_Rule(F func) : f_(std::move(func)) {}
 
  constexpr Probabilistic_Rule(F func, std::uint64_t master_seed)
    : f_(std::move(func)), master_seed_(master_seed)
  {}
 
  [[nodiscard]] constexpr std::uint64_t master_seed() const noexcept
  {
    return master_seed_;
  }
 
  void set_master_seed(std::uint64_t s) noexcept { master_seed_ = s; }
 
  template <typename State>
  [[nodiscard]] State operator()(const State &current,
                                 Neighbor_View<State> neighbours) const
    requires std::invocable<F &, const State &, Neighbor_View<State>>
  {
    return f_(current, neighbours);
  }
 
  template <typename State, std::size_t Rank>
  [[nodiscard]] State operator()(const State &current,
                                 Neighbor_View<State> neighbours,
                                 const Cell_Context<Rank> &ctx) const
  {
    if constexpr (std::is_invocable_r_v<State, F &, const State &,
                                        Neighbor_View<State>, Engine &>)
      {
        Engine eng{static_cast<typename Engine::result_type>(
          cell_seed<Rank>(master_seed_, ctx))};
        return f_(current, neighbours, eng);
      }
    else
      {
        return f_(current, neighbours);
      }
  }
};
 
// -----------------------------------------------------------------------
// Composite_Rule
// -----------------------------------------------------------------------
 
template <typename... Rules>
class Composite_Rule
{
  std::tuple<Rules...> rules_;
 
public:
  constexpr explicit Composite_Rule(Rules... rs) : rules_(std::move(rs)...) {}
 
  template <typename State>
  [[nodiscard]] constexpr State operator()(const State &current, Neighbor_View<State> neighbours) const
  {
    State acc = current;
    std::apply(
      [&](const auto &...r)
    {
      ((acc = r(acc, neighbours)), ...);
    },
      rules_);
    return acc;
  }
};
 
// -----------------------------------------------------------------------
// Game of Life: B3/S23 — convenience instance
// -----------------------------------------------------------------------
 
struct Game_Of_Life_Functor
{
  template <typename State>
  [[nodiscard]] constexpr State operator()(const State &current, const std::size_t alive) const noexcept
  {
    const bool alive_now = current != State{};
    const bool alive_next
      = (alive_now and (alive == 2 or alive == 3)) or (not alive_now and alive == 3);
    return alive_next ? static_cast<State>(1) : static_cast<State>(0);
  }
};
 
using Game_Of_Life_Rule = Outer_Totalistic_Rule<Game_Of_Life_Functor>;
 
[[nodiscard]] inline constexpr Game_Of_Life_Rule make_game_of_life_rule() noexcept
{
  return Game_Of_Life_Rule(Game_Of_Life_Functor{});
}
 
}  // namespace CA
}  // namespace Aleph
 
#endif  // TPL_CA_RULE_H