slab.h

Go to the documentation of this file.

#ifndef TPCC_SLAB_H
#define TPCC_SLAB_H
 
#include <algorithm>
#include <cassert>
#include <tpcc/lexicographic.h>
 
namespace TPCC
{
template <int n, int k, typename Bint = unsigned int, typename Sint = unsigned short,
          typename Tint = unsigned char>
class Slab
{
  typedef Lexicographic<n, k, Bint, Sint, Tint> super_class;
  const Lexicographic<n, k, Bint, Sint, Tint>& superset;
  const std::array<Tint, n - 1> directions;
  const std::array<bool, n - 1> reverse;
  const Tint normal_direction;
  const Sint normal_coordinate;
  const Lexicographic<n - 1, ((k > 0) ? k - 1 : 0), Bint, Sint, Tint> aux;
 
  static constexpr std::array<Sint, n - 1> aux_dimensions(
    const Lexicographic<n, k, Bint, Sint, Tint>& from, const std::array<Tint, n - 1>& directions)
  {
    std::array<Sint, n - 1> result{};
    for (Tint i = 0; i < n - 1; ++i)
      result[i] = from.fiber_dimension(directions[i]);
    return result;
  }
 
  std::array<Bint, binomial(n, k)> block_sizes;
 
public:
  constexpr Slab(const Lexicographic<n, k, Bint, Sint, Tint>& from,
                 const std::array<Tint, n - 1> directions, const std::array<bool, n - 1>& reverse,
                 Tint normal_direction, Sint normal_coordinate)
    : superset(from)
    , directions(directions)
    , reverse(reverse)
    , normal_direction(normal_direction)
    , normal_coordinate(normal_coordinate)
    , aux(aux_dimensions(from, directions))
  {
    static_assert(k >= 1, "Element dimension of slab must be at least 1");
    // Assert that normal_direction is not in the array of directions
    assert(std::find(directions.begin(), directions.end(), normal_direction) == directions.end());
  }
 
  constexpr Bint size() const { return aux.size(); }
 
  constexpr Bint block_size(Tint block) const { return aux.block_size(block); }
 
  constexpr Element<n, k, Sint, Tint> operator[](Bint index) const
  {
    auto local = aux[index];
    // `local` contains a cut through the elements of the slab. Thus, copy the along directions.
    std::array<Sint, n> coordinates{};
    for (Tint i = 0; i < k - 1; ++i)
    {
      const Sint c = local.along_coordinate(i);
      const Tint d = directions[local.along_direction(i)];
      coordinates[d] = reverse[i] ? (superset.fiber_dimension(d) - c - 1) : (c);
    }
    // By definition of a slab, the normal_direction is an along_direction of its elements
    coordinates[normal_direction] = normal_coordinate;
    // The remaining coordinates are just copied
    for (Tint i = 0; i < n - k; ++i)
    {
      const Sint c = local.across_coordinate(i);
      const Tint d = directions[local.across_direction(i)];
      coordinates[d] = reverse[i] ? (superset.fiber_dimension(d) - c) : (c);
    }
    Tint new_direction = (normal_direction < k) ? k : normal_direction;
    return Element<n, k, Sint, Tint>{ local.orientation.add_and_expand(new_direction),
                                      coordinates };
  }
};
} // namespace TPCC
 
#endif // TPCC_SLAB_H