numeric.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ALGORITHM_NUMERIC_HPP__
#define NEFORCE_CORE_ALGORITHM_NUMERIC_HPP__

 
#include "NeForce/core/functional/functor.hpp"
#include "NeForce/core/typeinfo/concepts.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename Iterator, typename T, typename BinaryOperation>
NEFORCE_CONSTEXPR20 T accumulate(Iterator first, Iterator second, T init, BinaryOperation binary_op) {
    static_assert(is_ranges_input_iter_v<Iterator>, "Iterator must be input_iterator");
    for (; first != second; ++first) {
        init = binary_op(init, *first);
    }
    return init;
}

template <typename Iterator, typename T>
NEFORCE_CONSTEXPR20 T accumulate(Iterator first, Iterator second, T init) {
    return _NEFORCE accumulate(first, second, init, _NEFORCE plus<T>());
}

template <typename Iterator1, typename Iterator2, typename BinaryOperation>
NEFORCE_CONSTEXPR20 Iterator2 adjacent_difference(Iterator1 first, Iterator1 last, Iterator2 result,
                                                  BinaryOperation binary_op) {
    static_assert(is_ranges_input_iter_v<Iterator1> && is_ranges_input_iter_v<Iterator2>,
                  "Iterator must be input_iterator");
 
    if (first == last) {
        return result;
    }
 
    using T = iter_value_t<Iterator1>;
    *result = *first;
    T value = *first;
 
    while (++first != last) {
        T tem = *first;
        *++result = binary_op(tem, value);
        value = tem;
    }
    return ++result;
}

template <typename Iterator1, typename Iterator2>
NEFORCE_CONSTEXPR20 Iterator2 adjacent_difference(Iterator1 first, Iterator1 last, Iterator2 result) {
    return _NEFORCE adjacent_difference(first, last, result, _NEFORCE minus<iter_value_t<Iterator1>>());
}

template <typename Iterator1, typename Iterator2, typename T, typename BinaryOperation1, typename BinaryOperation2>
NEFORCE_CONSTEXPR20 T inner_product(Iterator1 first1, Iterator1 last1, Iterator2 first2, T init,
                                    BinaryOperation1 binary_op1, BinaryOperation2 binary_op2) {
 
    static_assert(is_ranges_input_iter_v<Iterator1> && is_ranges_input_iter_v<Iterator2>,
                  "Iterator must be input_iterator");
 
    for (; first1 != last1; ++first1, ++first2) {
        init = binary_op1(init, binary_op2(*first1, *first2));
    }
    return init;
}

template <typename Iterator1, typename Iterator2, typename T>
NEFORCE_CONSTEXPR20 T inner_product(Iterator1 first1, Iterator1 last1, Iterator2 first2, T init) {
    return _NEFORCE inner_product(first1, last1, first2, init, _NEFORCE plus<T>(), _NEFORCE multiplies<T>());
}

template <typename Iterator1, typename Iterator2, typename BinaryOperation>
NEFORCE_CONSTEXPR20 Iterator2 partial_sum(Iterator1 first, Iterator1 last, Iterator2 result,
                                          BinaryOperation binary_op) {
    static_assert(is_ranges_input_iter_v<Iterator1> && is_ranges_input_iter_v<Iterator2>,
                  "Iterator must be input_iterator");
 
    if (first == last) {
        return result;
    }
 
    *result = *first;
    iter_value_t<Iterator1> value = *first;
 
    while (++first != last) {
        value = binary_op(value, *first);
        *++result = value;
    }
    return ++result;
}

template <typename Iterator1, typename Iterator2>
NEFORCE_CONSTEXPR20 Iterator2 partial_sum(Iterator1 first, Iterator1 last, Iterator2 result) {
    return _NEFORCE partial_sum(first, last, result, _NEFORCE plus<iter_value_t<Iterator1>>());
}

template <typename Iterator, typename T>
NEFORCE_CONSTEXPR20 void sequence_fill(Iterator first, Iterator last, T value) {
    static_assert(is_ranges_input_iter_v<Iterator>, "Iterator must be input_iterator");
 
    while (first != last) {
        *first++ = value;
        ++value;
    }
}
 // NumericAlgorithms
 // StandardAlgorithms
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ALGORITHM_NUMERIC_HPP__