maximum_space.hpp

#pragma once

#include <cmath>
#include <numeric>

#include "traits.hpp"

namespace aaa {
namespace maximum {

template<typename InputIterator, typename T = value_type_i<InputIterator>>
T norm(InputIterator first, InputIterator last, T init = T{})
{
    const auto max_abs = [](const T left, const T right) -> T
    {
        return std::max(left, std::abs(right));
    };
    return std::accumulate(first, last, init, max_abs);
}

template<typename Container, typename T = value_type<Container>>
T norm(const Container& a, T init = T{})
{
    using std::begin;
    using std::end;
    return norm(begin(a), end(a), init);
}

template<typename InputIterator, typename T = value_type_i<InputIterator>>
T squared_norm(InputIterator first, InputIterator last, T init = T{})
{
    const auto n = norm(first, last, init);
    return n * n;
}

template<typename Container, typename T = value_type<Container>>
T squared_norm(const Container& a, T init = T{})
{
    using std::begin;
    using std::end;
    return squared_norm(begin(a), end(a), init);
}

template<typename InputIterator1, typename InputIterator2, typename T = value_type_i<InputIterator1>>
T distance(InputIterator1 first_left, InputIterator1 last_left, InputIterator2 first_right, T init = T{})
{
    auto op1 = [](const T left, const T right) -> T
    {
        return std::max(left, right);
    };
    auto op2 = [](const auto left, const auto right) -> T
    {
        return std::abs(left - right);
    };
    return std::inner_product(first_left, last_left, first_right, init, op1, op2);
}

template<typename Container1, typename Container2, typename T = value_type<Container1>>
T distance(const Container1& left, const Container2& right, T init = T{})
{
    assert(left.size() == right.size());
    using std::begin;
    using std::end;
    return distance(begin(left), end(left), begin(right), init);
}

template<typename InputIterator1, typename InputIterator2, typename T = value_type_i<InputIterator1>>
T squared_distance(InputIterator1 first_left, InputIterator1 last_left, InputIterator2 first_right, T init = T{})
{
    const auto d = distance(first_left, last_left, first_right, init);
    return d * d;
}

template<typename Container1, typename Container2, typename T = value_type<Container1>>
T squared_distance(const Container1& left, const Container2& right, T init = T{})
{
    assert(left.size() == right.size());
    using std::begin;
    using std::end;
    return squared_distance(begin(left), end(left), begin(right), init);
}

} // namespace maximum
} // namespace aaa