core/math.hh

#ifndef VTESTBED_CORE_MATH_HH
#define VTESTBED_CORE_MATH_HH

#include <cmath>

#include <vtestbed/base/constants.hh>
#include <vtestbed/core/types.hh>

namespace vtb {

    namespace core {

        template <class T>
        inline bool
        is_positive_infinity(T x) noexcept {
            return !std::isfinite(x) && x > T(0);
        }

        template <class T>
        inline bool
        is_negative_infinity(T x) noexcept {
            return !std::isfinite(x) && x < T(0);
        }

        template <class T,int N>
        inline T
        scale(blitz::Array<T,N> x) {
            auto m = blitz::minmax(x);
            return m.max - m.min;
        }

        template <class T>
        inline T
        fma(T a, T x, T b) {
            return a*x + b;
        }

        #if defined(FP_FAST_FMAF) || \
            defined(__FMA__) || \
            defined(__FMA4__)
        template <>
        inline float
        fma<float>(float a, float x, float b) {
            return std::fma(a,x,b);
        }
        #endif

        #if defined(FP_FAST_FMA) || \
            defined(__FMA__) || \
            defined(__FMA4__)
        template <>
        inline double
        fma<double>(double a, double x, double b) {
            return std::fma(a,x,b);
        }
        #endif

        inline float
        pow2(float x) {
            return x*x;
        }

        inline double
        pow2(double x) {
            return x*x;
        }

        template <class T>
        inline std::complex<T>
        pow2(const std::complex<T>& x) {
            return x*x;
        }

    }

}

#endif // vim:filetype=cpp