Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <iterator>
       7              : #include <numeric>
       8              : 
       9              : #include "Utilities/Gsl.hpp"
      10              : 
      11              : /// C++ STL code present in C++2b.
      12            1 : namespace cpp2b {
      13              : /*!
      14              :  * \ingroup UtilitiesGroup
      15              :  * Reimplementation of std::iota that is constexpr;
      16              :  * taken from the LLVM source at
      17              :  * https://github.com/llvm-mirror/libcxx/blob/master/include/numeric
      18              :  */
      19              : template <class ForwardIterator, class T>
      20            1 : constexpr void iota(ForwardIterator first, ForwardIterator last, T value) {
      21              :   for (; first != last; ++first, (void)++value) {
      22              :     *first = value;
      23              :   }
      24              : }
      25              : 
      26              : /*!
      27              :  * \ingroup UtilitiesGroup
      28              :  * Reimplementation of std::accumulate that is constexpr;
      29              :  * taken from the LLVM source at
      30              :  * https://github.com/llvm-mirror/libcxx/blob/master/include/numeric
      31              :  */
      32              : template <class InputIt, class T>
      33            1 : constexpr T accumulate(InputIt first, InputIt last, T init) {
      34              :   for (; first != last; ++first) {
      35              :     init = std::move(init) + *first;  // std::move since C++20
      36              :   }
      37              :   return init;
      38              : }
      39              : }  // namespace cpp2b
      40              : 
      41              : namespace alg {
      42              : template <class Container, class T>
      43            0 : constexpr decltype(auto) iota(Container&& c, T value) {
      44              :   for (auto& t : c) {
      45              :     t = value;
      46              :     ++value;
      47              :   }
      48              :   return std::forward<Container>(c);
      49              : }
      50              : 
      51              : /// Convenience wrapper around std::accumulate, returns
      52              : /// `std::accumulate(begin(c), end(c), init)`.
      53              : template <class Container, class T>
      54            1 : decltype(auto) accumulate(const Container& c, T init) {
      55              :   using std::begin;
      56              :   using std::end;
      57              :   return std::accumulate(begin(c), end(c), std::move(init));
      58              : }
      59              : 
      60              : /// Convenience wrapper around std::accumulate, returns
      61              : /// `std::accumulate(begin(c), end(c), init, f)`.
      62              : template <class Container, class T, class BinaryFunction>
      63            1 : decltype(auto) accumulate(const Container& c, T init, BinaryFunction&& f) {
      64              :   using std::begin;
      65              :   using std::end;
      66              :   return std::accumulate(begin(c), end(c), std::move(init),
      67              :                          std::forward<BinaryFunction>(f));
      68              : }
      69              : }  // namespace alg