Counter.hh

Go to the documentation of this file.

#ifndef COUNTER_HH
#define COUNTER_HH
 
#include <iostream>
 
#include "casm/container/BaseCounter.hh"
#include "casm/global/eigen.hh"
#include "casm/misc/CASM_math.hh"
 
namespace CASM {
 
template <typename _Container, typename _value_type, typename _size_type,
          typename _Access, typename _Compare>
class Counter;
 
template <typename _Container, typename _value_type, typename _size_type,
          typename _Access, typename _Compare>
struct traits<
    Counter<_Container, _value_type, _size_type, _Access, _Compare> > {
  typedef BaseCounter<
      Counter<_Container, _value_type, _size_type, _Access, _Compare> >
      Base;
  typedef _Container Container;
  typedef _value_type value_type;
  typedef _size_type size_type;
  typedef _Access Access;
  typedef _Compare Compare;
};
 
template <typename _Container,
          typename _value_type = typename _Container::value_type,
          typename _size_type = typename _Container::size_type,
          typename _Access =
              CASM_TMP::BracketAccess<_Container, _value_type, _size_type>,
          typename _Compare = CASM_TMP::MuchLessThan<_value_type> >
class Counter
    : public BaseCounter<
          Counter<_Container, _value_type, _size_type, _Access, _Compare> > {
  typedef typename traits<Counter>::Base Base;
  using Base::_current;
  using Base::_final;
  using Base::_increment;
  using Base::_initial;
  using Base::_lower;
  using Base::_upper;
  using Base::_valid;
 
 public:
  typedef _Container Container;
  typedef _value_type value_type;
  typedef _size_type size_type;
  typedef _Access Access;
  typedef _Compare Compare;
 
  using Base::compare;
  using Base::current;
  using Base::initial;
  using Base::size;
  using Base::valid;
  using Base::operator();
  using Base::operator[];
  using Base::operator bool;
 
  Counter() {}
 
  Counter(const Container &_initial, const Container &_final,
          const Container &_increment, Access _access = Access(),
          Compare _compare = Compare())
      : Base(_initial, _final, _increment, _access, _compare) {
    _init();
  }
 
  Counter &operator++() {
    if (!valid()) return *this;
    size_type i = 0;
    while (compare(_upper(i), _current(i) + _increment(i)) ||
           compare(_current(i) + _increment(i), _lower(i))) {
      _current(i) = _initial(i);
      i++;
      if (i == this->size()) {
        _valid() = false;
        return *this;
      }
    }
    _current(i) += _increment(i);
    return *this;
  }
 
  void operator++(int) { ++(*this); }
 
  void set_current(const Container &new_current) {
    if (current().size() != new_current.size()) {
      std::cerr << "CRITICAL ERROR: In IsoCounter::set_current(), new state is "
                   "incompatible with this counter.\n"
                << "                Exiting...\n";
      exit(1);
    }
    _current() = new_current;
    _compute_validity();
  }
 
  void reset() {
    _current() = initial();
    _valid() = size() != 0;
  };
 
 private:
  void _init() {
    for (size_type i = 0; i < initial().size(); i++) {
      if (compare(_initial(i), _final(i))) {
        _lower(i) = _initial(i);
        _upper(i) = _final(i);
      } else {
        _lower(i) = _final(i);
        _upper(i) = _initial(i);
      }
    }
  }
 
  bool _compute_validity() {
    _valid() = true;
    for (size_type i = 0; i < size() && valid(); i++) {
      _valid() = valid() && compare(_current(i), _upper(i)) &&
                 compare(_lower(i), _current(i));
    }
    return valid();
  }
};
 
template <typename EigenType>
using EigenCounter =
    Counter<EigenType, typename EigenType::Scalar, typename EigenType::Index,
            CASM_TMP::ParenthesesAccess<EigenType, typename EigenType::Scalar,
                                        typename EigenType::Index> >;
 
typedef EigenCounter<Eigen::VectorXd> EigenVectorXdCounter;
typedef EigenCounter<Eigen::MatrixXd> EigenMatrixXdCounter;
typedef EigenCounter<Eigen::Matrix3d> EigenMatrix3dCounter;
typedef EigenCounter<Eigen::Vector3d> EigenVector3dCounter;
typedef EigenCounter<Eigen::Vector3i> EigenVector3iCounter;
typedef EigenCounter<Eigen::VectorXi> EigenVectorXiCounter;
typedef EigenCounter<Eigen::MatrixXi> EigenMatrixXiCounter;
typedef EigenCounter<Eigen::Matrix3i> EigenMatrix3iCounter;
}  // namespace CASM
 
#endif