std_quadmath.hh

#ifndef NPSTAT_STD_QUADMATH_HH_
#define NPSTAT_STD_QUADMATH_HH_
 
#include <complex>
 
#define npstat_convert_to_complex128(from, to) /**/ \
    __complex128 to;                                \
    __real__ to = (from).real();                    \
    __imag__ to = (from).imag();
 
#define npstat_adapt_float128_1arg_fcn(quadname, stdname) /**/ \
    inline lapack_double stdname (const lapack_double c)       \
    {                                                          \
        return quadname (c);                                   \
    }
 
#define npstat_adapt_float128_2arg_fcn(quadname, stdname) /**/ \
    inline lapack_double stdname (const lapack_double c1,      \
                                  const lapack_double c2)      \
    {                                                          \
        return quadname (c1, c2);                              \
    }
 
#define npstat_adapt_complex128_1arg_fcn(quadname, stdname) /**/   \
    inline std::complex<lapack_double> stdname (                   \
        const std::complex<lapack_double> c)                       \
    {                                                              \
        npstat_convert_to_complex128(c, y);                        \
        const __complex128 r = quadname (y);                       \
        return std::complex<lapack_double>(__real__ r, __imag__ r);\
    }
 
namespace std {
    inline lapack_double abs(const lapack_double c)
    {
        return c >= 0.0 ? c : -c;
    }
 
    npstat_adapt_float128_1arg_fcn(acosq, acos)
    npstat_adapt_float128_1arg_fcn(acoshq, acosh)
    npstat_adapt_float128_1arg_fcn(asinq, asin)
    npstat_adapt_float128_1arg_fcn(asinhq, asinh)
    npstat_adapt_float128_1arg_fcn(atanq, atan)
    npstat_adapt_float128_1arg_fcn(atanhq, atanh)
    npstat_adapt_float128_2arg_fcn(atan2q, atan2)
    npstat_adapt_float128_1arg_fcn(cbrtq, cbrt)
    npstat_adapt_float128_1arg_fcn(ceilq, ceil)
    npstat_adapt_float128_2arg_fcn(copysignq, copysign)
    npstat_adapt_float128_1arg_fcn(coshq, cosh)
    npstat_adapt_float128_1arg_fcn(cosq, cos)
    npstat_adapt_float128_1arg_fcn(erfq, erf)
    npstat_adapt_float128_1arg_fcn(erfcq, erfc)
    npstat_adapt_float128_1arg_fcn(expq, exp)
    npstat_adapt_float128_1arg_fcn(expm1q, expm1)
    npstat_adapt_float128_2arg_fcn(fmaxq, max)
    npstat_adapt_float128_2arg_fcn(fminq, min)
    npstat_adapt_float128_2arg_fcn(fmodq, mod)
    npstat_adapt_float128_2arg_fcn(hypotq, hypot)
    npstat_adapt_float128_1arg_fcn(j0q, j0)
    npstat_adapt_float128_1arg_fcn(j1q, j1)
    npstat_adapt_float128_1arg_fcn(lgammaq, lgamma)
    npstat_adapt_float128_1arg_fcn(logq, log)
    npstat_adapt_float128_1arg_fcn(log10q, log10)
    npstat_adapt_float128_1arg_fcn(log2q, log2)
    npstat_adapt_float128_1arg_fcn(log1pq, log1p)
    npstat_adapt_float128_1arg_fcn(nearbyintq, nearbyint)
    npstat_adapt_float128_2arg_fcn(nextafterq, nextafter)
    npstat_adapt_float128_2arg_fcn(powq, pow)
    npstat_adapt_float128_2arg_fcn(remainderq, remainder)
    npstat_adapt_float128_1arg_fcn(rintq, rint)
    npstat_adapt_float128_1arg_fcn(roundq, round)
    npstat_adapt_float128_1arg_fcn(sinhq, sinh)
    npstat_adapt_float128_1arg_fcn(sinq, sin)
    npstat_adapt_float128_1arg_fcn(sqrtq, sqrt)
    npstat_adapt_float128_1arg_fcn(tanq, tan)
    npstat_adapt_float128_1arg_fcn(tanhq, tanh)
    npstat_adapt_float128_1arg_fcn(tgammaq, tgamma)
    npstat_adapt_float128_1arg_fcn(truncq, trunc)
    npstat_adapt_float128_1arg_fcn(y0q, y0)
    npstat_adapt_float128_1arg_fcn(y1q, y1)
 
    inline int finite(const lapack_double c)
    {
        return finiteq(c);
    }
 
    inline int isinf(const lapack_double c)
    {
        return isinfq(c);
    }
 
    inline int isnan(const lapack_double c)
    {
        return isnanq(c);
    }
 
    inline int signbit(const lapack_double c)
    {
        return signbitq(c);
    }
 
    inline long long int llrint(const lapack_double c)
    {
        return llrintq(c);
    }
 
    inline long long int llround(const lapack_double c)
    {
        return llroundq(c);
    }
 
    inline long int lrint(const lapack_double c)
    {
        return lrintq(c);
    }
 
    inline long int lround(const lapack_double c)
    {
        return lroundq(c);
    }
 
    inline lapack_double abs(const std::complex<lapack_double> c)
    {
        return hypotq(c.real(), c.imag());
    }
 
    inline lapack_double arg(const std::complex<lapack_double> c)
    {
        npstat_convert_to_complex128(c, y);
        return cargq(y);
    }
 
    inline std::complex<lapack_double> expi(const lapack_double c)
    {
        const __complex128 r = cexpiq(c);
        return std::complex<lapack_double>(__real__ r, __imag__ r);
    }
 
    npstat_adapt_complex128_1arg_fcn(cacosq, acos)
    npstat_adapt_complex128_1arg_fcn(cacoshq, acosh)
    npstat_adapt_complex128_1arg_fcn(casinq, asin)
    npstat_adapt_complex128_1arg_fcn(casinhq, asinh)
    npstat_adapt_complex128_1arg_fcn(catanq, atan)
    npstat_adapt_complex128_1arg_fcn(catanhq, atanh)
    npstat_adapt_complex128_1arg_fcn(ccosq, cos)
    npstat_adapt_complex128_1arg_fcn(ccoshq, cosh)
    npstat_adapt_complex128_1arg_fcn(cexpq, exp)
    npstat_adapt_complex128_1arg_fcn(clogq, log)
    npstat_adapt_complex128_1arg_fcn(clog10q, log10)
    npstat_adapt_complex128_1arg_fcn(cprojq, proj)
    npstat_adapt_complex128_1arg_fcn(csinq, sin)
    npstat_adapt_complex128_1arg_fcn(csinhq, sinh)
    npstat_adapt_complex128_1arg_fcn(csqrtq, sqrt)
    npstat_adapt_complex128_1arg_fcn(ctanq, tan)
    npstat_adapt_complex128_1arg_fcn(ctanhq, tanh)
 
    inline std::complex<lapack_double> pow(const std::complex<lapack_double> c1,
                                           const std::complex<lapack_double> c2)
    {
        npstat_convert_to_complex128(c1, y1);
        npstat_convert_to_complex128(c2, y2);
        const __complex128 r = cpowq(y1, y2);
        return std::complex<lapack_double>(__real__ r, __imag__ r);
    }
}
 
#endif // NPSTAT_STD_QUADMATH_HH_