MathTools.hpp

Go to the documentation of this file.

#ifndef CPP_TOOLS_MATH_TOOLS_HPP
#define CPP_TOOLS_MATH_TOOLS_HPP
 
#include <vector>
#include <cmath>

namespace CppTools
{
   template <typename T> 
   T MaximumFromCArray(const T *entries, const unsigned long n)
   {
      T result = entries[0];
      for (unsigned long i = 1; i < n; i++)
      {
         if (entries[i] > result) result = entries[i];
      }
      return result;
   }

   template <typename... Ts> 
   double Maximum(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return MaximumFromCArray(entries, size);
   }

   template <typename T> 
   T MinimumFromCArray(const T *entries, const unsigned long n)
   {
      T result = entries[0];
      for (unsigned long i = 1; i < n; i++)
      {
         if (entries[i] < result) result = entries[i];
      }
      return result;
   }

   template <typename... Ts> 
   double Minimum(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return MinimumFromCArray(entries, size);
   }

   template <typename T> 
   T AverageFromCArray(const T *entries, const unsigned long n)
   {
      T result = 0;
      for (unsigned long i = 0; i < n; i++)
      {
         result += entries[i];
      }
      return result/static_cast<T>(n);
   }

   template <typename... Ts> 
   double Average(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return AverageFromCArray(entries, size);
   }

   double WeightedAverage(const double *entries, const double *weights, const unsigned long n)
   {
      double result = 0;
      double sumOfWeights = 0;
      for (unsigned long i = 0; i < n; i++)
      {
         result += entries[i]*weights[i];
         sumOfWeights += weights[i];
      }
      return result/sumOfWeights;
   }

   template <typename T> 
   double StandardErrorFromCArray(const T *entries, const unsigned long n, const double average)
   {
      T result = 0;
      for (unsigned long i = 0; i < n; i++)
      {
         result += (average - static_cast<double>(entries[i]))*
                   (average - static_cast<double>(entries[i]));
      }
      return result/sqrt(static_cast<double>(n*(n - 1)));
   }

   template <typename... Ts> 
   double StandardError(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return StandardErrorFromCArray(entries, size - 1, entries[size - 1]);
   }

   template <typename T> 
   double UncertaintyPropFromCArray(const T *entries, const unsigned long n)
   {
      double result = 0;
      for (unsigned long i = 0; i < n; i++)
      {
         result += static_cast<double>(entries[i]*entries[i]);
      }
      return sqrt(result);
   }

   template<typename... Ts>
   double UncertaintyProp(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return UncertaintyPropFromCArray(entries, size);
   }

   template <typename T> 
   T ProductFromCArray(const T *entries, const unsigned long n)
   {
      T result = entries[0];
      for (unsigned long i = 1; i < n; i++)
      {
         result *= entries[i];
      }
      return result;
   }

   template <typename... Ts> 
   double Product(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return ProductFromCArray(entries, size);
   }

   template <typename T> 
   double AtLeast1ProbFromCArray(const T *entries, const unsigned long n)
   {
      double prod = 1.;
      for (unsigned long i = 0; i < n; i++)
      {
         prod *= 1. - static_cast<double>(entries[i]);
      }
      return 1. - prod;
   }

   template <typename... Ts> 
   double AtLeast1Prob(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return AtLeast1ProbFromCArray(entries, size);
   }

   template <typename T> 
   double RMSFromCArray(const T *entries, const unsigned long n)
   {
      double result = 0.;
      for (unsigned long i = 0; i < n; i++)
      {
         result += static_cast<double>(entries[i]*entries[i]);
      }
      return sqrt(result/static_cast<double>(n));
   }

   template<typename... Ts>
   double RMS(Ts... args)
   {
      constexpr unsigned long size = sizeof...(args);
      double entries[size] = {static_cast<double>(args)...};
      return RMSFromCArray(entries, size);
   }
}
 
#endif /* CPP_TOOLS_MATH_TOOLS_HPP */