euclidean_space.hpp

#pragma once

#include <numeric>

#include "traits.hpp"

namespace aaa {
namespace euclidean {

template<typename InputIterator1, typename InputIterator2, typename T = value_type_i<InputIterator1>>
T dot(InputIterator1 first_left, InputIterator1 last_left, InputIterator2 first_right, T init = T{})
{
    return std::inner_product(first_left, last_left, first_right, init);
}

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

template<typename InputIterator, typename T = value_type_i<InputIterator>>
T squared_norm(InputIterator first, InputIterator last, T init = T{})
{
    return dot(first, last, first, init);
}

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 InputIterator, typename T = value_type_i<InputIterator>>
sqrt_type_t<T> norm(InputIterator first, InputIterator last, T init = T{})
{
    return sqrt(squared_norm(first, last, init));
}

template<typename Container, typename T = value_type<Container>>
sqrt_type_t<T> norm(const Container& a, T init = T{})
{
    using std::begin;
    using std::end;
    return norm(begin(a), end(a), 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{})
{
    auto op1 = [](const T left, const T right) -> T
    {
        return left + right;
    };
    auto op2 = [](const auto left, const auto right) -> T
    {
        return (left - right) * (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 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);
}

template<typename InputIterator1, typename InputIterator2, typename T = value_type_i<InputIterator1>>
sqrt_type_t<T> distance(InputIterator1 first_left, InputIterator1 last_left, InputIterator2 first_right, T init = T{})
{
    return sqrt(squared_distance(first_left, last_left, first_right, init));
}

template<typename Container1, typename Container2, typename T = value_type<Container1>>
sqrt_type_t<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);
}

} // namespace euclidean
} // namespace aaa