С++ stl свертка

Есть ли хорошая реализация алгоритма для вычисления свертки двух диапазонов в С++ STL (или даже повышения)? то есть с прототипом (свертка двух диапазонов a..b и c..d):

template< class Iterator >
void convolution(Iterator a, Iterator b, Iterator c, Iterator d);

который изменяет диапазон a..b

Ответ 1

Я не совсем уверен, что должна быть "свертка" из двух последовательностей в одну из этих двух последовательностей: похоже, это другое понимание, чем мое понимание. Ниже приведена версия convolution с использованием переменного числа итераторов. Поскольку на данный момент я просто слишком ленив, я буду использовать несколько необычное представление о передаче итератора назначения в качестве первого аргумента, а не в качестве последнего аргумента. Ниже приведена реализация соответствующих алгоритмов zip():

#include <tuple>

namespace algo
{
    template <typename... T>
    void dummy(T...)
    {
    }

    template <typename To, typename InIt, typename... It>
    To zip(To to, InIt it, InIt end, It... its)
    {
        for (; it != end; ++it, ++to) {
            *to = std::make_tuple(*it, *its...);
            algo::dummy(++its...);
        }
        return to;
    }
}

Ниже приведена простая тестовая программа, которую я использовал для проверки того, что приведенное выше делает то, что я намеревался сделать:

#include <deque>
#include <iostream>
#include <iterator>
#include <list>
#include <vector>

enum class e { a = 'a', b = 'b', c = 'c' };

std::ostream& operator<< (std::ostream& out,
                          std::tuple<int, double, e> const& v)
{
    return out << "["
               << std::get<0>(v) << ", "
               << std::get<1>(v) << ", "
               << char(std::get<2>(v)) << "]";
}

int main()
{
    typedef std::tuple<int, double, e> tuple;
    std::vector<int>   v{ 1, 2, 3 };
    std::deque<double> d{ 1.1, 2.2, 3.3 };
    std::list<e>       l{ e::a, e::b, e::c };
    std::vector<tuple> r;

    algo::zip(std::back_inserter(r), v.begin(), v.end(), d.begin(), l.begin());

    std::copy(r.begin(), r.end(),
              std::ostream_iterator<tuple>(std::cout, "\n"));
}

Ответ 2

Да std:: transform

std::transform(a, b, c, a, Op);

// a b is the the first input range
// c   is the start of the second range (which must be at least as large as (b-a)
// 
// We then use a as the output iterator as well.

// Op is a BinaryFunction

Чтобы ответить на комментарий о том, как выполнить накопление состояния в комментариях:

struct Operator
{
    State& state;
    Operator(Sate& state) : state(state) {}
    Type operator()(TypeR1 const& r1Value, TypeR2 const& r2Value) const
    {
        Plop(state, r1Value, r2Value);
        return Convolute(state, r2Value, r2Value);
    }
};
State  theState  = 0;
Operator Op(theState);