tiles

template<std::size_t N, std::size_t O>

tiles_t<N, O> kumi::tiles {}

inlineconstexprnodiscard

Callable object creating a tuple of product types, each containing N consecutive elements from t. Tiles starts at 0 and advance by O element each time.

On record types, this function operates on elements as if they were ordered. The considered order is the order of declaration.

Note

Tiles is the most general form of tiling each inner product_type is a tile over t starting at index tile_size * tile_number + 1. The last tile will be smaller if the size of the product type is not a multiple of the tile size.

Header file

#include <kumi/algorithm/apply.hpp>

Call Signature

template<std::size_t N, std::size_t O, product_type T>
constexpr auto tiles<N,O>(T && t);

Template Parameters

• N: Size of the tile to generate
• O: Offset from the begening of the previous tile

Parameters

• t: Product Type from which to extract the tiles

Return value

• A tuple of product types, each containing N consecutive elements of t offset by O

Helper type

    template<std::size_t N, std::size_t O, kumi::concepts::product_type T> struct tiles
    {
      using type = decltype(kumi::tiles<N, O>(std::declval<T>()));
    };
 
    template<std::size_t N, std::size_t O, kumi::concepts::product_type T>
    using tiles_t = typename kumi::result::tiles<N, O, T>::type;
 

Computes the return type of a call to kumi::tiles

Examples

Tuple

#include <kumi/kumi.hpp>
#include <iostream>
 
int main()
{
  auto t = kumi::tuple{1, 'y', 3.f, short{55}, -8, 66., "Pete"};
 
  auto w = kumi::tiles<2,3>(t); 
  std::cout << "  Standard Tiles" << "\n";
  std::cout << w << "\n";
 
  kumi::for_each([&](auto tile)
  {
    get<0>(tile)++;
  },w);
  std::cout << t << "\n";
 
  auto w2 = kumi::tiles<2,3>(kumi::to_ref(t)); 
  std::cout << "  Tiles with references " << "\n";
  std::cout << w2 << "\n";
 
  kumi::for_each([&](auto tile)
  {
    get<0>(tile)++;
  },w2);
  std::cout << t << "\n";   
}

Record

#include <kumi/kumi.hpp>
#include <iostream>
 
int main()
{
  using namespace kumi::literals;
 
  auto r = kumi::record{"a"_id = 1, "b"_id = 'y', "c"_id = 3.f, "d"_id = short{55}
                       ,"e"_id = -8, "f"_id = 66., "g"_id = "Pete"};
 
  auto w = kumi::tiles<2,3>(r); 
  std::cout << "  Standard Tiles" << "\n";
  std::cout << w << "\n";
 
  kumi::for_each([&](auto tile)
  {
    get<0>(kumi::values_of(tile))++;
  },w);
  std::cout << r << "\n";
 
  auto w2 = kumi::tiles<2,3>(kumi::to_ref(r)); 
  std::cout << "  Tiles with references " << "\n";
  std::cout << w2 << "\n";
 
  kumi::for_each([&](auto tile)
  {
    get<0>(kumi::values_of(tile))++;
  },w2);
  std::cout << r << "\n";   
}