Math/Utils.hh

Go to the documentation of this file.

///
/// @file  Utils.hh
/// @brief Hammer math utilities class
///

//**** This file is a part of the HAMMER library
//**** Copyright (C) 2016 - 2020 The HAMMER Collaboration
//**** HAMMER is licensed under version 3 of the GPL; see COPYING for details
//**** Please note the MCnet academic guidelines; see GUIDELINES for details

// -*- C++ -*-
#ifndef HAMMER_MATH_UTILS
#define HAMMER_MATH_UTILS

#include <complex>
#include <limits>

namespace Hammer {

    static const double precision = 0.001;

    /// @brief
    /// @param[in] val
    /// @return
    inline bool isZero(const std::complex<double> val) {
        return ((fabs(val.real()) < std::numeric_limits<double>::min()) &&
                (fabs(val.imag()) < std::numeric_limits<double>::min()));

    }

    /// @brief
    /// @param[in] val
    /// @return
    inline bool isZero(const double val) {
        return (fabs(val) < std::numeric_limits<double>::min());
    }

    /// @brief
    /// @param[in] val1
    /// @param[in] val2
    /// @return
    inline bool fuzzyLess(const double val1, const double val2) {
        return (val1-val2 < -1.*std::max(precision, std::numeric_limits<double>::min()));
    }

    /// @brief
    /// @param[in] val1
    /// @param[in] val2
    /// @return
    double compareVals(const double val1, const double val2);

    /// @brief
    /// @param[in] val1
    /// @param[in] val2
    /// @return
    std::complex<double> compareVals(const std::complex<double> val1, const std::complex<double> val2);


    inline double regularize(const double regularVal, const double problematicValue,
                             const double delta = std::numeric_limits<double>::min(), int direction = 0) {
        if (fabs(problematicValue - regularVal) > delta) {
            return regularVal;
        }
        return problematicValue + delta * (direction == 0 ? ((problematicValue > regularVal) ? -1.0 : 1.0) : 1.*direction);
    }

    template <typename T>
    typename std::enable_if<std::is_arithmetic<typename std::remove_reference<T>::type>::value, double>::type
    toDouble(T value) {
        return static_cast<double>(value);
    }

    template <typename T>
    typename std::enable_if<
        std::is_same<typename std::remove_reference<typename std::remove_cv<T>::type>::type, std::string>::value,
        double>::type
    toDouble(T value) {
        return stod(value);
    }

    template <typename T>
    typename std::enable_if<std::is_same<typename std::remove_reference<typename std::remove_cv<T>::type>::type,
                                         std::complex<double>>::value,
                            double>::type
    toDouble(T value) {
        return value.real();
    }

    template <typename T>
    typename std::enable_if<std::is_unsigned<T>::value && std::is_integral<T>::value, T>::type minPadding(T value) {
        if (value == 0u)
            return value;
        if (value == 1u)
            return 0;
        T pad = 0u;
        --value;
        while (value != 0u) {
            value = static_cast<T>(value >> 1);
            ++pad;
        }
        return pad;
    }


} // namespace Hammer

#endif