element.h

Go to the documentation of this file.

#ifndef TPCC_ELEMENT_H
#define TPCC_ELEMENT_H
 
#include <tpcc/combinations.h>
 
namespace TPCC
{
template <int n, int k, typename Bint, typename Sint, typename Tint>
class Slab;
template <int n, int k, typename Sint = unsigned short, typename Tint = unsigned char>
class Element
{
  Combination<n, k> orientation;
  std::array<Sint, n> positions;
 
public:
  template <typename T>
  Element(const Combination<n, k>& combi, const std::array<T, n>& pos)
    : orientation(combi)
    , positions(pos)
  {
  }
 
  static constexpr unsigned int n_val = n;
  static constexpr unsigned int k_val = k;
 
  static constexpr Tint n_facets() { return 2 * k; }
 
  constexpr Tint direction_index() const { return Combinations<n, k>::index(orientation); }
 
  constexpr Sint operator[](Tint index) const { return positions[index]; }
 
  constexpr Tint along_direction(Tint index) const { return n - 1 - orientation.in(index); }
 
  constexpr Sint along_coordinate(Tint index) const { return positions[along_direction(index)]; }
 
  constexpr Tint across_direction(Tint index) const { return n - 1 - orientation.out(index); }
 
  constexpr Sint across_coordinate(Tint index) const { return positions[across_direction(index)]; }
 
  void print_debug(std::ostream& os) const
  {
    os << " (";
    for (Tint i = 0; i < k; ++i)
      os << (unsigned int)along_direction(i);
    os << ':';
    for (Tint i = 0; i < n - k; ++i)
      os << (unsigned int)across_direction(i);
    os << ' ';
    for (unsigned int i = 0; i < n - 1; ++i)
      os << positions[i] << ',';
    os << positions[n - 1] << ")";
  }
 
  constexpr Element<n, k - 1, Sint, Tint> facet(Tint index) const
  {
    Tint i2 = index / 2;           // The direction index out of k
    Tint im = index % 2;           // Lower or upper boundary in this direction?
    Tint gi = along_direction(i2); // The global direction out of n belonging to index
    Combination<n, k - 1> combi = orientation.eliminate(i2);
    std::array<Sint, n> new_positions = positions;
    if (im == 1)
      ++new_positions[gi];
 
    return Element<n, k - 1, Sint, Tint>{ combi, new_positions };
  }
 
  template <int, int, typename, typename, typename>
  friend class Slab;
};
} // namespace TPCC
 
#endif