nested_containers.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
#include "barretenberg/common/tuple.hpp"
#include "barretenberg/polynomials/univariate.hpp"
 
namespace bb {
 
template <template <typename, size_t, size_t, size_t> typename InnerContainer,
          typename ValueType,
          auto domain_end,
          size_t domain_start = 0,
          size_t skip_count = 0,
          typename IS = decltype(std::make_index_sequence<domain_end.size()>())>
struct TupleOfContainersOverArray;
template <template <typename, size_t, size_t, size_t> typename InnerContainer,
          typename ValueType,
          auto domain_end,
          size_t domain_start,
          size_t skip_count,
          std::size_t... I>
struct TupleOfContainersOverArray<InnerContainer,
                                  ValueType,
                                  domain_end,
                                  domain_start,
                                  skip_count,
                                  std::index_sequence<I...>> {
    using type = flat_tuple::tuple<InnerContainer<ValueType, domain_end[I], domain_start, skip_count>...>;
};
 
// Helpers
template <typename ValueType, size_t, size_t, size_t> using ExtractValueType = ValueType;
 
template <typename Tuple>
using HomogeneousTupleToArray = std::array<std::tuple_element_t<0, Tuple>, std::tuple_size_v<Tuple>>;
 
// Types needed for sumcheck and folding.
template <typename FF, auto LENGTHS>
using TupleOfUnivariates = typename TupleOfContainersOverArray<bb::Univariate, FF, LENGTHS, 0, 0>::type;
 
// Types needed for sumcheck and folding.
template <typename FF, auto LENGTHS, size_t SKIP_COUNT>
using TupleOfUnivariatesWithOptimisticSkipping =
    typename TupleOfContainersOverArray<bb::Univariate, FF, LENGTHS, 0, SKIP_COUNT>::type;
 
template <typename FF, auto LENGTHS>
using TupleOfValues = typename TupleOfContainersOverArray<ExtractValueType, FF, LENGTHS>::type;
 
template <typename FF, auto LENGTHS> using ArrayOfValues = HomogeneousTupleToArray<TupleOfValues<FF, LENGTHS>>;
 
} // namespace bb