tickcounter.h

// -*-c++-*-
#ifndef STORMM_TICKCOUNTER_H
#define STORMM_TICKCOUNTER_H
 
#include <string>
#include <vector>
#include "copyright.h"
#include "DataTypes/stormm_vector_types.h"
#include "Reporting/error_format.h"
#include "Structure/local_arrangement.h"
#include "Structure/structure_enumerators.h"
#include "multiplication.h"
#include "summation.h"
 
namespace stormm {
namespace stmath {
 
using structure::imageValue;
using structure::ImagingMethod;

template <typename T> class TickCounter {
public:

  explicit TickCounter(const std::vector<int> &state_limits_in,
                       const std::vector<int> &settings_in = std::vector<int>());
 
  explicit TickCounter(const std::vector<std::vector<T>> &state_values_in,
                       const std::vector<int> &settings_in = std::vector<int>());

  TickCounter(const TickCounter &original) = default;
  TickCounter(TickCounter &&original) = default;
  TickCounter& operator=(const TickCounter &original) = default;
  TickCounter& operator=(TickCounter &&original) = default;

  int getVariableCount() const;

  double getLogPermutations() const;
  
  const std::vector<int>& getSettings() const;

  int getStateLimits(int var_index) const;
  const std::vector<int>& getStateLimits() const;

  T getState(int var_index) const;
  std::vector<T> getState() const;

  std::vector<T> getPossibleStates(int var_index) const;

  llint getExactPermutationCount() const;

  double getApproximatePermutationCount() const;

  double getLogPermutationCount() const;
  
  void advance(int steps = 1);

  void reverse(int steps = 1);
  
  template <typename Trng> void randomize(Trng *xrs);
  template <typename Trng> void randomize(Trng *xrs, const std::vector<bool> &apply_rng);
  template <typename Trng> void randomize(Trng *xrs, const std::vector<int> &apply_rng);

  void set(const std::vector<int> &new_state);
 
  void set(int new_state, int var_index);
  
  void reset();

  void loadStateValues(const std::vector<T> &state_values_in, int var_index);
  void loadStateValues(const std::vector<std::vector<T>> &state_values_in);
 
private:
  int variable_count;             
  double log_permutations;        
  std::vector<int> settings;      
  std::vector<int> state_limits;  
  std::vector<T> state_values;    

  std::vector<int> state_value_bounds;

  void variableBoundsCheck(const int var_index) const;
  
  void validateSettings() const;
};

template <typename T, typename T2>
void loadScalarStateValues(TickCounter<T> *tc, const std::vector<T2> &ranges,
                           const std::vector<T> &periodic_boundaries);
 
template <typename T, typename T2>
void loadScalarStateValues(TickCounter<T> *tc, const std::vector<T2> &ranges);
 
} // namespace stmath
} // namespace stormm
 
#include "tickcounter.tpp"
 
#endif