average.hpp

Go to the documentation of this file.

# /*
#  * Created by YongGyu Lee on 2020/12/08.
#  */
#
# ifndef VCCC_NUMERIC_AVERAGE_HPP
# define VCCC_NUMERIC_AVERAGE_HPP
#
# include <cassert>
# include <iterator>
#
# include "vccc/type_traits.hpp"
# include "vccc/__numeric/sum.hpp"
 
namespace vccc {
 
 
template<typename InputIterator, std::enable_if_t<is_iterable<InputIterator>::value, int> = 0>
constexpr auto average(InputIterator first, InputIterator last) {
  assert(((void)"input size muse be larger than 0", first != last));
  using return_type = decltype(*first);
  if(first == last) return impl::default_value<decltype(*first)>() / static_cast<decay_if_float_t<return_type>>(1);
  return sum(first, last) / static_cast<decay_if_float_t<return_type>>(std::distance(first, last));
}
 
template<typename InputIterator, typename UnaryOperation,
    std::enable_if_t<is_iterable<InputIterator>::value, int> = 0>
constexpr auto
average(InputIterator first, InputIterator last, UnaryOperation unary_op)
{
  assert(((void)"input size muse be larger than 0", first != last));
  using return_type = decltype(unary_op(*first));
  if(first == last) return static_cast<decay_if_float_t<return_type>>(sum(first, last, std::move(unary_op)));
  return sum(first, last, unary_op) / static_cast<decay_if_float_t<return_type>>(std::distance(first, last));
}
 
template<typename ...Numbers,
         std::enable_if_t<conjunction<std::is_arithmetic<Numbers>...>::value, int> = 0>
constexpr inline auto
average(Numbers... numbers)
{
  return sum(numbers...) / static_cast<decay_if_float_t<Numbers...>>(sizeof...(numbers));
}
 
 
template<typename ...Args,
         std::enable_if_t<
           conjunction<
             negation<disjunction<is_iterable<Args>...>>,
             negation<disjunction<std::is_arithmetic<Args>...>>
           >::value, int> = 0>
constexpr inline
auto
average(const Args&... args)
{
  return sum(args...) / static_cast<double>(sizeof...(args));
}
 
 
 
template<typename ...Ints,
    std::enable_if_t<conjunction<std::is_integral<Ints>...>::value, int> = 0>
constexpr inline
auto
int_average(Ints... ints)
{
  return sum(ints...) / static_cast<signed_bigger_type_t<Ints...>>(sizeof...(Ints));
}
 
 
} // namespace vccc
 
# endif // VCCC_NUMERIC_AVERAGE_HPP