Numeric.h

Go to the documentation of this file.

#ifndef INCLUDE_TEMPLE_CONSTEXPR_NUMERIC_H
#define INCLUDE_TEMPLE_CONSTEXPR_NUMERIC_H

#include "Molassembler/Temple/Traits.h"
#include "Molassembler/Temple/constexpr/Math.h"

#include <numeric>
#include <functional>
#include <cassert>

namespace Scine {
namespace Molassembler {
namespace Temple {

template<class ContainerType>
constexpr Traits::getValueType<ContainerType> sum(const ContainerType& container) {
  using ValueType = Traits::getValueType<ContainerType>;

  return std::accumulate(
    std::begin(container),
    std::end(container),
    ValueType {0},
    std::plus<ValueType>()
  );
}

template<class ContainerType>
constexpr std::enable_if_t<
  std::is_floating_point<Traits::getValueType<ContainerType>>::value,
  Traits::getValueType<ContainerType>
> average(const ContainerType& container) {
  if(container.begin() == container.end()) {
    throw "Average called on an empty container!";
  }

  return sum(container) / container.size();
}

template<class ContainerType>
constexpr std::enable_if_t<
  !std::is_floating_point<Traits::getValueType<ContainerType>>::value,
  double
> average(const ContainerType& container) {
  if(container.begin() == container.end()) {
    throw "Average called on an empty container!";
  }

  return static_cast<double>(
    sum(container)
  ) / container.size();
}

template<class ContainerType>
constexpr std::enable_if_t<
  std::is_floating_point<Traits::getValueType<ContainerType>>::value,
  Traits::getValueType<ContainerType>
> geometricMean(const ContainerType& container) {
  if(container.begin() == container.end()) {
    throw "geometricMean called on an empty container!";
  }

  using ValueType = Traits::getValueType<ContainerType>;

  return Math::pow(
    reduce(
      container,
      ValueType {1.0},
      std::multiplies<ValueType>()
    ),
    1.0 / container.size()
  );
}

template<class ContainerType, typename FloatingType>
constexpr std::enable_if_t<
  std::is_floating_point<FloatingType>::value,
  FloatingType
> stddev(
  const ContainerType& container,
  const FloatingType averageValue
) {
  assert(container.begin() != container.end());

  FloatingType sum = 0;

  for(const auto value : container) {
    auto diff = static_cast<FloatingType>(value) - averageValue;
    sum += diff * diff;
  }

  return Math::sqrt(sum / container.size());
}


template<class ContainerType>
constexpr auto stddev(const ContainerType& container) {
  assert(container.begin() != container.end());

  return stddev(container, average(container));
}

template<class ContainerType>
constexpr auto min(const ContainerType& container) {
  if(container.begin() == container.end()) {
    throw "Min called on empty container!";
  }

  auto smallestIter = container.begin();
  for(auto it = container.begin(); it != container.end(); ++it) {
    if(*it < *smallestIter) {
      smallestIter = it;
    }
  }

  return *smallestIter;
}

template<class ContainerType>
constexpr auto max(const ContainerType& container) {
  if(container.begin() == container.end()) {
    throw "Max called on empty container!";
  }

  auto largestIter = container.begin();

  for(auto it = container.begin(); it != container.end(); ++it) {
    if(*largestIter < *it) {
      largestIter = it;
    }
  }

  return *largestIter;
}

} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif