Math.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <cmath>
#include <vector>
 
namespace autopas::utils::Math {
 
const double normalScale = 1. / std::sqrt(2 * M_PI);
 
template <class Int_t, std::enable_if_t<std::is_integral_v<Int_t>, bool> = true>
Int_t safeAdd(const Int_t &a, const Int_t &b, const Int_t &valUnderflow = std::numeric_limits<Int_t>::min(),
              const Int_t &valOverflow = std::numeric_limits<Int_t>::max()) {
  Int_t result;
  bool overflow = __builtin_add_overflow(a, b, &result);
  if (overflow) {
    // if both args are negative this is an underflow.
    if (a < 0 and b < 0) {
      result = valUnderflow;
    } else {
      result = valOverflow;
    }
  }
  return result;
}
 
template <class Float_t, std::enable_if_t<std::is_floating_point_v<Float_t>, bool> = true>
Float_t safeAdd(const Float_t &a, const Float_t &b, const Float_t &valUnderflow = -std::numeric_limits<Float_t>::max(),
                const Float_t &valOverflow = std::numeric_limits<Float_t>::max()) {
  Float_t result = a + b;
  if (std::isinf(result)) {
    if (result > 0) {
      result = valOverflow;
    } else {
      result = valUnderflow;
    }
  }
  return result;
}
 
template <class Int_t, std::enable_if_t<std::is_integral_v<Int_t>, bool> = true>
Int_t safeSub(const Int_t &a, const Int_t &b, const Int_t &valUnderflow = std::numeric_limits<Int_t>::min(),
              const Int_t &valOverflow = std::numeric_limits<Int_t>::max()) {
  Int_t result;
  bool overflow = __builtin_sub_overflow(a, b, &result);
  if (overflow) {
    // underflow is only possible if we subtract a positive number. Everything else is an overflow.
    if (b > 0) {
      result = valUnderflow;
    } else {
      result = valOverflow;
    }
  }
  return result;
}
 
template <class Float_t, std::enable_if_t<std::is_floating_point_v<Float_t>, bool> = true>
Float_t safeSub(const Float_t &a, const Float_t &b, const Float_t &valUnderflow = -std::numeric_limits<Float_t>::max(),
                const Float_t &valOverflow = std::numeric_limits<Float_t>::max()) {
  Float_t result = a - b;
  if (std::isinf(result)) {
    if (result > 0) {
      result = valOverflow;
    } else {
      result = valUnderflow;
    }
  }
  return result;
}
 
template <class Int_t, std::enable_if_t<std::is_integral_v<Int_t>, bool> = true>
Int_t safeMul(const Int_t &a, const Int_t &b, const Int_t &valUnderflow = std::numeric_limits<Int_t>::min(),
              const Int_t &valOverflow = std::numeric_limits<Int_t>::max()) {
  Int_t result;
  bool overflow = __builtin_mul_overflow(a, b, &result);
  if (overflow) {
    // if exactly one arg is negative this is an underflow.
    if ((a < 0) xor (b < 0)) {
      result = valUnderflow;
    } else {
      result = valOverflow;
    }
  }
  return result;
}
 
template <class Float_t, std::enable_if_t<std::is_floating_point_v<Float_t>, bool> = true>
Float_t safeMul(const Float_t &a, const Float_t &b, const Float_t &valUnderflow = -std::numeric_limits<Float_t>::max(),
                const Float_t &valOverflow = std::numeric_limits<Float_t>::max()) {
  Float_t result = a * b;
  if (std::isinf(result)) {
    if (result > 0) {
      result = valOverflow;
    } else {
      result = valUnderflow;
    }
  }
  return result;
}
 
template <size_t exponent, class T>
T pow(const T &base) {
  if (exponent == 0) {
    return 1;
  }
 
  T res = base;
  // the compiler should unroll this loop
  for (size_t i = 0; i < exponent - 1; ++i) {
    res *= base;
  }
  return res;
}
 
double normalPDF(double x);
 
double normalCDF(double x);
 
double sigmoid(double x);
 
bool isNearRel(double a, double b, double maxRelativeDifference = 1e-9);
 
bool isNearAbs(double a, double b, double maxAbsoluteDifference);
 
double roundFixed(double d, int fixedPrecision);
 
double roundFloating(double d, int floatingPrecision);
 
Eigen::VectorXd makeVectorXd(const std::vector<double> &elements);
 
Eigen::VectorXi makeVectorXi(const std::vector<int> &elements);
 
}  // namespace autopas::utils::Math