multiply.hpp

#pragma once

#include <algorithm>

#include "traits.hpp"

namespace aaa {

// iterators

template<typename InputIterator1, typename InputIterator2, typename OutputIterator,
    check_product<value_type_i<InputIterator1>, value_type_i<InputIterator2>, value_type_i<OutputIterator>> = nullptr>
void multiply(InputIterator1 first_left, InputIterator1 last_left, InputIterator2 first_right, OutputIterator first_out)
{
    auto f = [](const value_type_i<InputIterator1>& left, const value_type_i<InputIterator2>& right)
    {
        return left * right;
    };
    std::transform(first_left, last_left, first_right, first_out, f);
}

template<typename Element, typename InputIterator, typename OutputIterator,
    check_product<Element, value_type_i<InputIterator>, value_type_i<OutputIterator>> = nullptr>
void multiply(const Element& left, InputIterator first_right, InputIterator last_right, OutputIterator first_out)
{
    auto f = [&](const value_type_i<InputIterator>& right) { return left * right; };
    std::transform(first_right, last_right, first_out, f);
}

template<typename InputIterator, typename Element, typename OutputIterator,
    check_product<value_type_i<InputIterator>, Element, value_type_i<OutputIterator>> = nullptr>
void multiply(InputIterator first_left, InputIterator last_left, const Element& right, OutputIterator first_out)
{
    auto f = [&](const value_type_i<InputIterator>& left) { return left * right; };
    std::transform(first_left, last_left, first_out, f);
}

// containers

template<typename Container1, typename Container2, typename Container3,
    check_product<value_type<Container1>, value_type<Container2>, value_type<Container3>> = nullptr>
    void multiply(const Container1& left, const Container2& right, Container3& out)
{
    assert(left.size() == out.size());
    assert(right.size() == out.size());
    using std::begin;
    using std::end;
    multiply(begin(left), end(left), begin(right), begin(out));
}

template<typename Element, typename Container1, typename Container2,
    check_product<Element, value_type<Container1>, value_type<Container2>> = nullptr>
    void multiply(const Element& left, const Container1& right, Container2& out)
{
    assert(right.size() == out.size());
    using std::begin;
    using std::end;
    multiply(left, begin(right), end(right), begin(out));
}

template<typename Container1, typename Element, typename Container2,
    check_product<value_type<Container1>, Element, value_type<Container2>> = nullptr>
    void multiply(const Container1& left, const Element& right, Container2& out)
{
    assert(left.size() == out.size());
    using std::begin;
    using std::end;
    multiply(begin(left), end(left), right, begin(out));
}

// make container

template<typename Container>
Container multiply(const Container& left, const Container& right)
{
    auto out = left;
    multiply(left, right, out);
    return out;
}

template<typename Container>
Container multiply(const Container& left, const value_type<Container>& right)
{
    auto out = left;
    multiply(left, right, out);
    return out;
}

template<typename Container>
Container multiply(const value_type<Container>& left, const Container& right)
{
    auto out = right;
    multiply(left, right, out);
    return out;
}

} // namespace aaa