//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Base/Math/Numeric.cpp
//! @brief     Implements "almost equal" in namespace Numeric.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************

#include "Base/Math/Numeric.h"
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <limits>

//! For tests only.
void Numeric::checkScalar(double a, double b, double ulp)
{
    if (!almostEqual(a, b, ulp))
        exit(1);
}

double Numeric::relativeDifference(double a, double b)
{
    return 2 * std::abs(a - b) / (std::abs(a) + std::abs(b));
}

bool Numeric::almostEqual(double a, double b, double ulp)
{
    constexpr double eps = std::numeric_limits<double>::epsilon();
    return std::abs(a - b) <= eps * ulp * (std::abs(a) + std::abs(b)) / 2;
}

bool Numeric::lessOrAlmostEqual(double a, double b, double ulp)
{
    return a < b || almostEqual(a, b, ulp);
}

bool Numeric::almostEqual(complex_t a, complex_t b, double ulp)
{
    constexpr double eps = std::numeric_limits<double>::epsilon();
    return std::abs(a - b) <= eps * ulp * (std::abs(a) + std::abs(b)) / 2;
}

bool Numeric::almostEqual(const R3& a, const R3& b, double ulp)
{
    return almostEqual(a.x(), b.x(), ulp) && almostEqual(a.y(), b.y(), ulp)
           && almostEqual(a.z(), b.z(), ulp);
}

double Numeric::ignoreDenormalized(double value)
{
    return (std::fpclassify(value) == FP_SUBNORMAL) ? 0.0 : value;
}

int Numeric::orderOfMagnitude(double x)
{
    if (x == 0)
        return 0;

    return std::floor(std::log10(std::abs(x)));
}
