@lakutata/math 0.0.0-stage → 3.1.3

package/vendor/boost/math/include/boost/math/cstdfloat/cstdfloat_cmath.hpp

@@ -0,0 +1,1012 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright Christopher Kormanyos 2014.
+// Copyright John Maddock 2014.
+// Copyright Paul Bristow 2014.
+// Distributed under the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+// Implement quadruple-precision <cmath> support.
+
+#ifndef BOOST_MATH_CSTDFLOAT_CMATH_2014_02_15_HPP_
+#define BOOST_MATH_CSTDFLOAT_CMATH_2014_02_15_HPP_
+
+#include <boost/math/cstdfloat/cstdfloat_types.hpp>
+#include <boost/math/cstdfloat/cstdfloat_limits.hpp>
+
+#if (defined(__GNUC__) && defined(BOOST_HAS_FLOAT128))
+//
+// This is the only way we can avoid
+// warning: non-standard suffix on floating constant [-Wpedantic]
+// when building with -Wall -pedantic.  Neither __extension__
+// nor #pragma diagnostic ignored work :(
+//
+#pragma GCC system_header
+#endif
+
+#if defined(BOOST_CSTDFLOAT_HAS_INTERNAL_FLOAT128_T) && defined(BOOST_MATH_USE_FLOAT128) && !defined(BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT)
+
+#include <cstdint>
+#include <cmath>
+#include <stdexcept>
+#include <iostream>
+#include <type_traits>
+#include <memory>
+#include <boost/math/tools/assert.hpp>
+#include <boost/math/tools/nothrow.hpp>
+#include <boost/math/tools/throw_exception.hpp>
+
+#if defined(_WIN32) && defined(__GNUC__)
+  // Several versions of Mingw and probably cygwin too have broken
+  // libquadmath implementations that segfault as soon as you call
+  // expq or any function that depends on it.
+#define BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
+#endif
+
+// Here is a helper function used for raising the value of a given
+// floating-point type to the power of n, where n has integral type.
+namespace boost {
+   namespace math {
+      namespace cstdfloat {
+         namespace detail {
+
+            template<class float_type, class integer_type>
+            inline float_type pown(const float_type& x, const integer_type p)
+            {
+               const bool isneg = (x < 0);
+               const bool isnan = (x != x);
+               const bool isinf = ((!isneg) ? bool(+x > (std::numeric_limits<float_type>::max)())
+                  : bool(-x > (std::numeric_limits<float_type>::max)()));
+
+               if (isnan) { return x; }
+
+               if (isinf) { return std::numeric_limits<float_type>::quiet_NaN(); }
+
+               const bool       x_is_neg = (x < 0);
+               const float_type abs_x = (x_is_neg ? -x : x);
+
+               if (p < static_cast<integer_type>(0))
+               {
+                  if (abs_x < (std::numeric_limits<float_type>::min)())
+                  {
+                     return (x_is_neg ? -std::numeric_limits<float_type>::infinity()
+                        : +std::numeric_limits<float_type>::infinity());
+                  }
+                  else
+                  {
+                     return float_type(1) / pown(x, static_cast<integer_type>(-p));
+                  }
+               }
+
+               if (p == static_cast<integer_type>(0))
+               {
+                  return float_type(1);
+               }
+               else
+               {
+                  if (p == static_cast<integer_type>(1)) { return x; }
+
+                  if (abs_x > (std::numeric_limits<float_type>::max)())
+                  {
+                     return (x_is_neg ? -std::numeric_limits<float_type>::infinity()
+                        : +std::numeric_limits<float_type>::infinity());
+                  }
+
+                  if      (p == static_cast<integer_type>(2)) { return  (x * x); }
+                  else if (p == static_cast<integer_type>(3)) { return ((x * x) * x); }
+                  else if (p == static_cast<integer_type>(4)) { const float_type x2 = (x * x); return (x2 * x2); }
+                  else
+                  {
+                     // The variable xn stores the binary powers of x.
+                     float_type result(((p % integer_type(2)) != integer_type(0)) ? x : float_type(1));
+                     float_type xn(x);
+
+                     integer_type p2 = p;
+
+                     while (integer_type(p2 /= 2) != integer_type(0))
+                     {
+                        // Square xn for each binary power.
+                        xn *= xn;
+
+                        const bool has_binary_power = (integer_type(p2 % integer_type(2)) != integer_type(0));
+
+                        if (has_binary_power)
+                        {
+                           // Multiply the result with each binary power contained in the exponent.
+                           result *= xn;
+                        }
+                     }
+
+                     return result;
+                  }
+               }
+            }
+
+         }
+      }
+   }
+} // boost::math::cstdfloat::detail
+
+// We will now define preprocessor symbols representing quadruple-precision <cmath> functions.
+#if defined(__INTEL_COMPILER)
+#define BOOST_CSTDFLOAT_FLOAT128_LDEXP  __ldexpq
+#define BOOST_CSTDFLOAT_FLOAT128_FREXP  __frexpq
+#define BOOST_CSTDFLOAT_FLOAT128_FABS   __fabsq
+#define BOOST_CSTDFLOAT_FLOAT128_FLOOR  __floorq
+#define BOOST_CSTDFLOAT_FLOAT128_CEIL   __ceilq
+#if !defined(BOOST_CSTDFLOAT_FLOAT128_SQRT)
+#define BOOST_CSTDFLOAT_FLOAT128_SQRT   __sqrtq
+#endif
+#define BOOST_CSTDFLOAT_FLOAT128_TRUNC  __truncq
+#define BOOST_CSTDFLOAT_FLOAT128_EXP    __expq
+#define BOOST_CSTDFLOAT_FLOAT128_EXPM1  __expm1q
+#define BOOST_CSTDFLOAT_FLOAT128_POW    __powq
+#define BOOST_CSTDFLOAT_FLOAT128_LOG    __logq
+#define BOOST_CSTDFLOAT_FLOAT128_LOG10  __log10q
+#define BOOST_CSTDFLOAT_FLOAT128_SIN    __sinq
+#define BOOST_CSTDFLOAT_FLOAT128_COS    __cosq
+#define BOOST_CSTDFLOAT_FLOAT128_TAN    __tanq
+#define BOOST_CSTDFLOAT_FLOAT128_ASIN   __asinq
+#define BOOST_CSTDFLOAT_FLOAT128_ACOS   __acosq
+#define BOOST_CSTDFLOAT_FLOAT128_ATAN   __atanq
+#define BOOST_CSTDFLOAT_FLOAT128_SINH   __sinhq
+#define BOOST_CSTDFLOAT_FLOAT128_COSH   __coshq
+#define BOOST_CSTDFLOAT_FLOAT128_TANH   __tanhq
+#define BOOST_CSTDFLOAT_FLOAT128_ASINH  __asinhq
+#define BOOST_CSTDFLOAT_FLOAT128_ACOSH  __acoshq
+#define BOOST_CSTDFLOAT_FLOAT128_ATANH  __atanhq
+#define BOOST_CSTDFLOAT_FLOAT128_FMOD   __fmodq
+#define BOOST_CSTDFLOAT_FLOAT128_ATAN2  __atan2q
+#define BOOST_CSTDFLOAT_FLOAT128_LGAMMA __lgammaq
+#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA __tgammaq
+//   begin more functions
+#define BOOST_CSTDFLOAT_FLOAT128_REMAINDER   __remainderq
+#define BOOST_CSTDFLOAT_FLOAT128_REMQUO      __remquoq
+#define BOOST_CSTDFLOAT_FLOAT128_FMA         __fmaq
+#define BOOST_CSTDFLOAT_FLOAT128_FMAX        __fmaxq
+#define BOOST_CSTDFLOAT_FLOAT128_FMIN        __fminq
+#define BOOST_CSTDFLOAT_FLOAT128_FDIM        __fdimq
+#define BOOST_CSTDFLOAT_FLOAT128_NAN         __nanq
+//#define BOOST_CSTDFLOAT_FLOAT128_EXP2      __exp2q
+#define BOOST_CSTDFLOAT_FLOAT128_LOG2        __log2q
+#define BOOST_CSTDFLOAT_FLOAT128_LOG1P       __log1pq
+#define BOOST_CSTDFLOAT_FLOAT128_CBRT        __cbrtq
+#define BOOST_CSTDFLOAT_FLOAT128_HYPOT       __hypotq
+#define BOOST_CSTDFLOAT_FLOAT128_ERF         __erfq
+#define BOOST_CSTDFLOAT_FLOAT128_ERFC        __erfcq
+#define BOOST_CSTDFLOAT_FLOAT128_LLROUND     __llroundq
+#define BOOST_CSTDFLOAT_FLOAT128_LROUND      __lroundq
+#define BOOST_CSTDFLOAT_FLOAT128_ROUND       __roundq
+#define BOOST_CSTDFLOAT_FLOAT128_NEARBYINT   __nearbyintq
+#define BOOST_CSTDFLOAT_FLOAT128_LLRINT      __llrintq
+#define BOOST_CSTDFLOAT_FLOAT128_LRINT       __lrintq
+#define BOOST_CSTDFLOAT_FLOAT128_RINT        __rintq
+#define BOOST_CSTDFLOAT_FLOAT128_MODF        __modfq
+#define BOOST_CSTDFLOAT_FLOAT128_SCALBLN     __scalblnq
+#define BOOST_CSTDFLOAT_FLOAT128_SCALBN      __scalbnq
+#define BOOST_CSTDFLOAT_FLOAT128_ILOGB       __ilogbq
+#define BOOST_CSTDFLOAT_FLOAT128_LOGB        __logbq
+#define BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER   __nextafterq
+//#define BOOST_CSTDFLOAT_FLOAT128_NEXTTOWARD  __nexttowardq
+#define BOOST_CSTDFLOAT_FLOAT128_COPYSIGN     __copysignq
+#define BOOST_CSTDFLOAT_FLOAT128_SIGNBIT      __signbitq
+//#define BOOST_CSTDFLOAT_FLOAT128_FPCLASSIFY __fpclassifyq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISFINITE   __isfiniteq
+#define BOOST_CSTDFLOAT_FLOAT128_ISINF        __isinfq
+#define BOOST_CSTDFLOAT_FLOAT128_ISNAN        __isnanq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISNORMAL   __isnormalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISGREATER  __isgreaterq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISGREATEREQUAL __isgreaterequalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESS         __islessq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESSEQUAL    __islessequalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESSGREATER  __islessgreaterq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISUNORDERED    __isunorderedq
+//   end more functions
+#elif defined(__GNUC__)
+#define BOOST_CSTDFLOAT_FLOAT128_LDEXP  ldexpq
+#define BOOST_CSTDFLOAT_FLOAT128_FREXP  frexpq
+#define BOOST_CSTDFLOAT_FLOAT128_FABS   fabsq
+#define BOOST_CSTDFLOAT_FLOAT128_FLOOR  floorq
+#define BOOST_CSTDFLOAT_FLOAT128_CEIL   ceilq
+#if !defined(BOOST_CSTDFLOAT_FLOAT128_SQRT)
+#define BOOST_CSTDFLOAT_FLOAT128_SQRT   sqrtq
+#endif
+#define BOOST_CSTDFLOAT_FLOAT128_TRUNC  truncq
+#define BOOST_CSTDFLOAT_FLOAT128_POW    powq
+#define BOOST_CSTDFLOAT_FLOAT128_LOG    logq
+#define BOOST_CSTDFLOAT_FLOAT128_LOG10  log10q
+#define BOOST_CSTDFLOAT_FLOAT128_SIN    sinq
+#define BOOST_CSTDFLOAT_FLOAT128_COS    cosq
+#define BOOST_CSTDFLOAT_FLOAT128_TAN    tanq
+#define BOOST_CSTDFLOAT_FLOAT128_ASIN   asinq
+#define BOOST_CSTDFLOAT_FLOAT128_ACOS   acosq
+#define BOOST_CSTDFLOAT_FLOAT128_ATAN   atanq
+#define BOOST_CSTDFLOAT_FLOAT128_FMOD   fmodq
+#define BOOST_CSTDFLOAT_FLOAT128_ATAN2  atan2q
+#define BOOST_CSTDFLOAT_FLOAT128_LGAMMA lgammaq
+#if !defined(BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS)
+#define BOOST_CSTDFLOAT_FLOAT128_EXP    expq
+#define BOOST_CSTDFLOAT_FLOAT128_EXPM1  expm1q
+#define BOOST_CSTDFLOAT_FLOAT128_SINH   sinhq
+#define BOOST_CSTDFLOAT_FLOAT128_COSH   coshq
+#define BOOST_CSTDFLOAT_FLOAT128_TANH   tanhq
+#define BOOST_CSTDFLOAT_FLOAT128_ASINH  asinhq
+#define BOOST_CSTDFLOAT_FLOAT128_ACOSH  acoshq
+#define BOOST_CSTDFLOAT_FLOAT128_ATANH  atanhq
+#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA tgammaq
+#else // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
+#define BOOST_CSTDFLOAT_FLOAT128_EXP    expq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_SINH   sinhq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_COSH   coshq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_TANH   tanhq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_ASINH  asinhq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_ACOSH  acoshq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_ATANH  atanhq_patch
+#define BOOST_CSTDFLOAT_FLOAT128_TGAMMA tgammaq_patch
+#endif // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
+//   begin more functions
+#define BOOST_CSTDFLOAT_FLOAT128_REMAINDER   remainderq
+#define BOOST_CSTDFLOAT_FLOAT128_REMQUO      remquoq
+#define BOOST_CSTDFLOAT_FLOAT128_FMA         fmaq
+#define BOOST_CSTDFLOAT_FLOAT128_FMAX        fmaxq
+#define BOOST_CSTDFLOAT_FLOAT128_FMIN        fminq
+#define BOOST_CSTDFLOAT_FLOAT128_FDIM        fdimq
+#define BOOST_CSTDFLOAT_FLOAT128_NAN         nanq
+//#define BOOST_CSTDFLOAT_FLOAT128_EXP2      exp2q
+#define BOOST_CSTDFLOAT_FLOAT128_LOG2        log2q
+#define BOOST_CSTDFLOAT_FLOAT128_LOG1P       log1pq
+#define BOOST_CSTDFLOAT_FLOAT128_CBRT        cbrtq
+#define BOOST_CSTDFLOAT_FLOAT128_HYPOT       hypotq
+#define BOOST_CSTDFLOAT_FLOAT128_ERF         erfq
+#define BOOST_CSTDFLOAT_FLOAT128_ERFC        erfcq
+#define BOOST_CSTDFLOAT_FLOAT128_LLROUND     llroundq
+#define BOOST_CSTDFLOAT_FLOAT128_LROUND      lroundq
+#define BOOST_CSTDFLOAT_FLOAT128_ROUND       roundq
+#define BOOST_CSTDFLOAT_FLOAT128_NEARBYINT   nearbyintq
+#define BOOST_CSTDFLOAT_FLOAT128_LLRINT      llrintq
+#define BOOST_CSTDFLOAT_FLOAT128_LRINT       lrintq
+#define BOOST_CSTDFLOAT_FLOAT128_RINT        rintq
+#define BOOST_CSTDFLOAT_FLOAT128_MODF        modfq
+#define BOOST_CSTDFLOAT_FLOAT128_SCALBLN     scalblnq
+#define BOOST_CSTDFLOAT_FLOAT128_SCALBN      scalbnq
+#define BOOST_CSTDFLOAT_FLOAT128_ILOGB       ilogbq
+#define BOOST_CSTDFLOAT_FLOAT128_LOGB        logbq
+#define BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER   nextafterq
+//#define BOOST_CSTDFLOAT_FLOAT128_NEXTTOWARD nexttowardq
+#define BOOST_CSTDFLOAT_FLOAT128_COPYSIGN    copysignq
+#define BOOST_CSTDFLOAT_FLOAT128_SIGNBIT     signbitq
+//#define BOOST_CSTDFLOAT_FLOAT128_FPCLASSIFY fpclassifyq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISFINITE   isfiniteq
+#define BOOST_CSTDFLOAT_FLOAT128_ISINF        isinfq
+#define BOOST_CSTDFLOAT_FLOAT128_ISNAN        isnanq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISNORMAL   isnormalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISGREATER  isgreaterq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISGREATEREQUAL isgreaterequalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESS         islessq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESSEQUAL    islessequalq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISLESSGREATER  islessgreaterq
+//#define BOOST_CSTDFLOAT_FLOAT128_ISUNORDERED    isunorderedq
+//   end more functions
+#endif
+
+// Implement quadruple-precision <cmath> functions in the namespace
+// boost::math::cstdfloat::detail. Subsequently inject these into the
+// std namespace via *using* directive.
+
+// Begin with some forward function declarations. Also implement patches
+// for compilers that have broken float128 exponential functions.
+
+extern "C" int quadmath_snprintf(char*, std::size_t, const char*, ...) BOOST_MATH_NOTHROW;
+
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LDEXP(boost::math::cstdfloat::detail::float_internal128_t, int) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FREXP(boost::math::cstdfloat::detail::float_internal128_t, int*) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FABS(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FLOOR(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_CEIL(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SQRT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TRUNC(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_POW(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LOG(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LOG10(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SIN(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COS(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TAN(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASIN(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOS(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATAN(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_FMOD(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATAN2(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_LGAMMA(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+
+//   begin more functions
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_REMAINDER(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_REMQUO(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t, int*) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_FMA(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_FMAX(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_FMIN(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_FDIM(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_NAN(const char*) BOOST_MATH_NOTHROW;
+//extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_EXP2         (boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_LOG2(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_LOG1P(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_CBRT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_HYPOT(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_ERF(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_ERFC(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" long long int                                        BOOST_CSTDFLOAT_FLOAT128_LLROUND(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" long int                                             BOOST_CSTDFLOAT_FLOAT128_LROUND(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_ROUND(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_NEARBYINT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" long long int                                        BOOST_CSTDFLOAT_FLOAT128_LLRINT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" long int                                             BOOST_CSTDFLOAT_FLOAT128_LRINT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_RINT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_MODF(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t*) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_SCALBLN(boost::math::cstdfloat::detail::float_internal128_t, long int) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_SCALBN(boost::math::cstdfloat::detail::float_internal128_t, int) BOOST_MATH_NOTHROW;
+extern "C" int                                                  BOOST_CSTDFLOAT_FLOAT128_ILOGB(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_LOGB(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_NEXTTOWARD   (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_COPYSIGN(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" int                                                  BOOST_CSTDFLOAT_FLOAT128_SIGNBIT(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_FPCLASSIFY   (boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISFINITE      (boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" int                                                  BOOST_CSTDFLOAT_FLOAT128_ISINF(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+extern "C" int                                                  BOOST_CSTDFLOAT_FLOAT128_ISNAN(boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" boost::math::cstdfloat::detail::float_internal128_t  BOOST_CSTDFLOAT_FLOAT128_ISNORMAL   (boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISGREATER   (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISGREATEREQUAL(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISLESS      (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISLESSEQUAL   (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISLESSGREATER(boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+//extern "C" int                                                BOOST_CSTDFLOAT_FLOAT128_ISUNORDERED   (boost::math::cstdfloat::detail::float_internal128_t, boost::math::cstdfloat::detail::float_internal128_t) BOOST_MATH_NOTHROW;
+ //   end more functions
+
+#if !defined(BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS)
+
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXPM1(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SINH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COSH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TANH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASINH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOSH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATANH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+extern "C" boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TGAMMA(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW;
+ 
+#else // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
+
+// Forward declaration of the patched exponent function, exp(x).
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP(boost::math::cstdfloat::detail::float_internal128_t x);
+
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXPM1(boost::math::cstdfloat::detail::float_internal128_t x)
+{
+   // Compute exp(x) - 1 for x small.
+
+   // Use an order-12 Pade approximation of the exponential function.
+   // PadeApproximant[Exp[x] - 1, {x, 0, 12, 12}].
+
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+
+   float_type sum;
+
+   if (x > BOOST_FLOAT128_C(0.693147180559945309417232121458176568075500134360255))
+   {
+      sum = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x) - float_type(1);
+   }
+   else
+   {
+      const float_type x2 = (x * x);
+
+      const float_type top = (((((  float_type(BOOST_FLOAT128_C(2.4087176110456818621091195109360728010934088788572E-13))  * x2
+                                  + float_type(BOOST_FLOAT128_C(9.2735628025258751691201101171038802842096241836000E-10))) * x2
+                                  + float_type(BOOST_FLOAT128_C(9.0806726962333369656024118266681195742980640005812E-07))) * x2
+                                  + float_type(BOOST_FLOAT128_C(3.1055900621118012422360248447204968944099378881988E-04))) * x2
+                                  + float_type(BOOST_FLOAT128_C(3.6231884057971014492753623188405797101449275362319E-02))) * x2
+                                  + float_type(BOOST_FLOAT128_C(1.00000000000000000000000000000000000000000000000000000)))
+                                  ;
+
+      const float_type bot = ((((((((((((  float_type(BOOST_FLOAT128_C(+7.7202487533515444298369215094104897470942592271063E-16))  * x
+                                         + float_type(BOOST_FLOAT128_C(-1.2043588055228409310545597554680364005467044394286E-13))) * x
+                                         + float_type(BOOST_FLOAT128_C(+9.2735628025258751691201101171038802842096241836000E-12))) * x
+                                         + float_type(BOOST_FLOAT128_C(-4.6367814012629375845600550585519401421048120918000E-10))) * x
+                                         + float_type(BOOST_FLOAT128_C(+1.6692413044546575304416198210786984511577323530480E-08))) * x
+                                         + float_type(BOOST_FLOAT128_C(-4.5403363481166684828012059133340597871490320002906E-07))) * x
+                                         + float_type(BOOST_FLOAT128_C(+9.5347063310450038138825324180015255530129672006102E-06))) * x
+                                         + float_type(BOOST_FLOAT128_C(-1.5527950310559006211180124223602484472049689440994E-04))) * x
+                                         + float_type(BOOST_FLOAT128_C(+1.9409937888198757763975155279503105590062111801242E-03))) * x
+                                         + float_type(BOOST_FLOAT128_C(-1.8115942028985507246376811594202898550724637681159E-02))) * x
+                                         + float_type(BOOST_FLOAT128_C(+1.1956521739130434782608695652173913043478260869565E-01))) * x
+                                         + float_type(BOOST_FLOAT128_C(-0.50000000000000000000000000000000000000000000000000000))) * x
+                                         + float_type(BOOST_FLOAT128_C(+1.00000000000000000000000000000000000000000000000000000)))
+                                         ;
+
+      sum = (x * top) / bot;
+   }
+
+   return sum;
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_EXP(boost::math::cstdfloat::detail::float_internal128_t x)
+{
+   // Patch the expq() function for a subset of broken GCC compilers
+   // like GCC 4.7, 4.8 on MinGW.
+
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+
+   // Scale the argument x to the range (-ln2 < x < ln2).
+   constexpr float_type one_over_ln2 = float_type(BOOST_FLOAT128_C(1.44269504088896340735992468100189213742664595415299));
+   const float_type x_over_ln2 = x * one_over_ln2;
+
+   int n;
+
+   if (x != x)
+   {
+      // The argument is NaN.
+      return std::numeric_limits<float_type>::quiet_NaN();
+   }
+   else if (::BOOST_CSTDFLOAT_FLOAT128_FABS(x) > BOOST_FLOAT128_C(+0.693147180559945309417232121458176568075500134360255))
+   {
+      // The absolute value of the argument exceeds ln2.
+      n = static_cast<int>(::BOOST_CSTDFLOAT_FLOAT128_FLOOR(x_over_ln2));
+   }
+   else if (::BOOST_CSTDFLOAT_FLOAT128_FABS(x) < BOOST_FLOAT128_C(+0.693147180559945309417232121458176568075500134360255))
+   {
+      // The absolute value of the argument is less than ln2.
+      n = 0;
+   }
+   else
+   {
+      // The absolute value of the argument is exactly equal to ln2 (in the sense of floating-point equality).
+      return float_type(2);
+   }
+
+   // Check if the argument is very near an integer.
+   const float_type floor_of_x = ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(x);
+
+   if (::BOOST_CSTDFLOAT_FLOAT128_FABS(x - floor_of_x) < float_type(BOOST_CSTDFLOAT_FLOAT128_EPS))
+   {
+      // Return e^n for arguments very near an integer.
+      return boost::math::cstdfloat::detail::pown(BOOST_FLOAT128_C(2.71828182845904523536028747135266249775724709369996), static_cast<std::int_fast32_t>(floor_of_x));
+   }
+
+   // Compute the scaled argument alpha.
+   const float_type alpha = x - (n * BOOST_FLOAT128_C(0.693147180559945309417232121458176568075500134360255));
+
+   // Compute the polynomial approximation of expm1(alpha) and add to it
+   // in order to obtain the scaled result.
+   const float_type scaled_result = ::BOOST_CSTDFLOAT_FLOAT128_EXPM1(alpha) + float_type(1);
+
+   // Rescale the result and return it.
+   return scaled_result * boost::math::cstdfloat::detail::pown(float_type(2), n);
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_SINH(boost::math::cstdfloat::detail::float_internal128_t x)
+{
+   // Patch the sinhq() function for a subset of broken GCC compilers
+   // like GCC 4.7, 4.8 on MinGW.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+
+   // Here, we use the following:
+   // Set: ex  = exp(x)
+   // Set: em1 = expm1(x)
+   // Then
+   // sinh(x) = (ex - 1/ex) / 2         ; for |x| >= 1
+   // sinh(x) = (2em1 + em1^2) / (2ex)  ; for |x| < 1
+
+   const float_type ex = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
+
+   if (::BOOST_CSTDFLOAT_FLOAT128_FABS(x) < float_type(+1))
+   {
+      const float_type em1 = ::BOOST_CSTDFLOAT_FLOAT128_EXPM1(x);
+
+      return ((em1 * 2) + (em1 * em1)) / (ex * 2);
+   }
+   else
+   {
+      return (ex - (float_type(1) / ex)) / 2;
+   }
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_COSH(boost::math::cstdfloat::detail::float_internal128_t x)
+{
+   // Patch the coshq() function for a subset of broken GCC compilers
+   // like GCC 4.7, 4.8 on MinGW.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+   const float_type ex = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
+   return (ex + (float_type(1) / ex)) / 2;
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TANH(boost::math::cstdfloat::detail::float_internal128_t x)
+{
+   // Patch the tanhq() function for a subset of broken GCC compilers
+   // like GCC 4.7, 4.8 on MinGW.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+   const float_type ex_plus = ::BOOST_CSTDFLOAT_FLOAT128_EXP(x);
+   const float_type ex_minus = (float_type(1) / ex_plus);
+   return (ex_plus - ex_minus) / (ex_plus + ex_minus);
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ASINH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW
+{
+   // Patch the asinh() function since quadmath does not have it.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+   return ::BOOST_CSTDFLOAT_FLOAT128_LOG(x + ::BOOST_CSTDFLOAT_FLOAT128_SQRT((x * x) + float_type(1)));
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ACOSH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW
+{
+   // Patch the acosh() function since quadmath does not have it.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+   const float_type zp(x + float_type(1));
+   const float_type zm(x - float_type(1));
+
+   return ::BOOST_CSTDFLOAT_FLOAT128_LOG(x + (zp * ::BOOST_CSTDFLOAT_FLOAT128_SQRT(zm / zp)));
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_ATANH(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW
+{
+   // Patch the atanh() function since quadmath does not have it.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+   return (::BOOST_CSTDFLOAT_FLOAT128_LOG(float_type(1) + x)
+      - ::BOOST_CSTDFLOAT_FLOAT128_LOG(float_type(1) - x)) / 2;
+}
+inline boost::math::cstdfloat::detail::float_internal128_t BOOST_CSTDFLOAT_FLOAT128_TGAMMA(boost::math::cstdfloat::detail::float_internal128_t x) BOOST_MATH_NOTHROW
+{
+   // Patch the tgammaq() function for a subset of broken GCC compilers
+   // like GCC 4.7, 4.8 on MinGW.
+   typedef boost::math::cstdfloat::detail::float_internal128_t float_type;
+
+   if (x > float_type(0))
+   {
+      return ::BOOST_CSTDFLOAT_FLOAT128_EXP(::BOOST_CSTDFLOAT_FLOAT128_LGAMMA(x));
+   }
+   else if (x < float_type(0))
+   {
+      // For x < 0, compute tgamma(-x) and use the reflection formula.
+      const float_type positive_x = -x;
+      float_type gamma_value = ::BOOST_CSTDFLOAT_FLOAT128_TGAMMA(positive_x);
+      const float_type floor_of_positive_x = ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(positive_x);
+
+      // Take the reflection checks (slightly adapted) from <boost/math/gamma.hpp>.
+      const bool floor_of_z_is_equal_to_z = (positive_x == ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(positive_x));
+
+      constexpr float_type my_pi = BOOST_FLOAT128_C(3.14159265358979323846264338327950288419716939937511);
+
+      if (floor_of_z_is_equal_to_z)
+      {
+         const bool is_odd = ((std::int32_t(floor_of_positive_x) % std::int32_t(2)) != std::int32_t(0));
+
+         return (is_odd ? -std::numeric_limits<float_type>::infinity()
+            : +std::numeric_limits<float_type>::infinity());
+      }
+
+      const float_type sinpx_value = x * ::BOOST_CSTDFLOAT_FLOAT128_SIN(my_pi * x);
+
+      gamma_value *= sinpx_value;
+
+      const bool result_is_too_large_to_represent = ((::BOOST_CSTDFLOAT_FLOAT128_FABS(gamma_value) < float_type(1))
+         && (((std::numeric_limits<float_type>::max)() * ::BOOST_CSTDFLOAT_FLOAT128_FABS(gamma_value)) < my_pi));
+
+      if (result_is_too_large_to_represent)
+      {
+         const bool is_odd = ((std::int32_t(floor_of_positive_x) % std::int32_t(2)) != std::int32_t(0));
+
+         return (is_odd ? -std::numeric_limits<float_type>::infinity()
+            : +std::numeric_limits<float_type>::infinity());
+      }
+
+      gamma_value = -my_pi / gamma_value;
+
+      if ((gamma_value > float_type(0)) || (gamma_value < float_type(0)))
+      {
+         return gamma_value;
+      }
+      else
+      {
+         // The value of gamma is too small to represent. Return 0.0 here.
+         return float_type(0);
+      }
+   }
+   else
+   {
+      // Gamma of zero is complex infinity. Return NaN here.
+      return std::numeric_limits<float_type>::quiet_NaN();
+   }
+}
+#endif // BOOST_CSTDFLOAT_BROKEN_FLOAT128_MATH_FUNCTIONS
+
+// Define the quadruple-precision <cmath> functions in the namespace boost::math::cstdfloat::detail.
+
+namespace boost {
+   namespace math {
+      namespace cstdfloat {
+         namespace detail {
+            inline   boost::math::cstdfloat::detail::float_internal128_t ldexp(boost::math::cstdfloat::detail::float_internal128_t x, int n) { return ::BOOST_CSTDFLOAT_FLOAT128_LDEXP(x, n); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t frexp(boost::math::cstdfloat::detail::float_internal128_t x, int* pn) { return ::BOOST_CSTDFLOAT_FLOAT128_FREXP(x, pn); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t fabs(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FABS(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t abs(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FABS(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t floor(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_FLOOR(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t ceil(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_CEIL(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t sqrt(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SQRT(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t trunc(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TRUNC(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t exp(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_EXP(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t expm1(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_EXPM1(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t pow(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t a) { return ::BOOST_CSTDFLOAT_FLOAT128_POW(x, a); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t pow(boost::math::cstdfloat::detail::float_internal128_t x, int a) { return ::BOOST_CSTDFLOAT_FLOAT128_POW(x, boost::math::cstdfloat::detail::float_internal128_t(a)); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t log(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t log10(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG10(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t sin(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SIN(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t cos(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_COS(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t tan(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TAN(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t asin(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ASIN(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t acos(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ACOS(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t atan(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATAN(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t sinh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SINH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t cosh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_COSH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t tanh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TANH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t asinh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ASINH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t acosh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ACOSH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t atanh(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATANH(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t fmod(boost::math::cstdfloat::detail::float_internal128_t a, boost::math::cstdfloat::detail::float_internal128_t b) { return ::BOOST_CSTDFLOAT_FLOAT128_FMOD(a, b); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t atan2(boost::math::cstdfloat::detail::float_internal128_t y, boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ATAN2(y, x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t lgamma(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LGAMMA(x); }
+            inline   boost::math::cstdfloat::detail::float_internal128_t tgamma(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_TGAMMA(x); }
+            //   begin more functions
+            inline boost::math::cstdfloat::detail::float_internal128_t  remainder(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_REMAINDER(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  remquo(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y, int* z) { return ::BOOST_CSTDFLOAT_FLOAT128_REMQUO(x, y, z); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  fma(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y, boost::math::cstdfloat::detail::float_internal128_t z) { return BOOST_CSTDFLOAT_FLOAT128_FMA(x, y, z); }
+
+            inline boost::math::cstdfloat::detail::float_internal128_t  fmax(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMAX(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               fmax(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMAX(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               fmax(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMAX(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  fmin(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMIN(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               fmin(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMIN(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               fmin(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_FMIN(x, y); }
+
+            inline boost::math::cstdfloat::detail::float_internal128_t  fdim(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_FDIM(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  nanq(const char* x) { return ::BOOST_CSTDFLOAT_FLOAT128_NAN(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  exp2(boost::math::cstdfloat::detail::float_internal128_t x)
+            {
+               return ::BOOST_CSTDFLOAT_FLOAT128_POW(boost::math::cstdfloat::detail::float_internal128_t(2), x);
+            }
+            inline boost::math::cstdfloat::detail::float_internal128_t  log2(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG2(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  log1p(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOG1P(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  cbrt(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_CBRT(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  hypot(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y, boost::math::cstdfloat::detail::float_internal128_t z) { return ::BOOST_CSTDFLOAT_FLOAT128_SQRT(x*x + y * y + z * z); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  hypot(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_HYPOT(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               hypot(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return ::BOOST_CSTDFLOAT_FLOAT128_HYPOT(x, y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               hypot(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_HYPOT(x, y); }
+
+
+            inline boost::math::cstdfloat::detail::float_internal128_t  erf(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ERF(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  erfc(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ERFC(x); }
+            inline long long int                                        llround(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LLROUND(x); }
+            inline long int                                             lround(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LROUND(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  round(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ROUND(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  nearbyint(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_NEARBYINT(x); }
+            inline long long int                                        llrint(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LLRINT(x); }
+            inline long int                                             lrint(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LRINT(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  rint(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_RINT(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  modf(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t* y) { return ::BOOST_CSTDFLOAT_FLOAT128_MODF(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  scalbln(boost::math::cstdfloat::detail::float_internal128_t x, long int y) { return ::BOOST_CSTDFLOAT_FLOAT128_SCALBLN(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  scalbn(boost::math::cstdfloat::detail::float_internal128_t x, int y) { return ::BOOST_CSTDFLOAT_FLOAT128_SCALBN(x, y); }
+            inline int                                                  ilogb(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ILOGB(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  logb(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_LOGB(x); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  nextafter(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER(x, y); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  nexttoward(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return -(::BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER(-x, -y)); }
+            inline boost::math::cstdfloat::detail::float_internal128_t  copysign   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_COPYSIGN(x, y); }
+            inline bool                                                 signbit   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_SIGNBIT(x); }
+            inline int                                                  fpclassify BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x)
+            {
+               if (::BOOST_CSTDFLOAT_FLOAT128_ISNAN(x))
+                  return FP_NAN;
+               else if (::BOOST_CSTDFLOAT_FLOAT128_ISINF(x))
+                  return FP_INFINITE;
+               else if (x == BOOST_FLOAT128_C(0.0))
+                  return FP_ZERO;
+
+               if (::BOOST_CSTDFLOAT_FLOAT128_FABS(x) < BOOST_CSTDFLOAT_FLOAT128_MIN)
+                  return FP_SUBNORMAL;
+               else
+                  return FP_NORMAL;
+            }
+            inline bool                                      isfinite   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x)
+            {
+               return !::BOOST_CSTDFLOAT_FLOAT128_ISNAN(x) && !::BOOST_CSTDFLOAT_FLOAT128_ISINF(x);
+            }
+            inline bool                                      isinf      BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ISINF(x); }
+            inline bool                                      isnan      BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x) { return ::BOOST_CSTDFLOAT_FLOAT128_ISNAN(x); }
+            inline bool                                      isnormal   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x) { return boost::math::cstdfloat::detail::fpclassify BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) == FP_NORMAL; }
+            inline bool                                      isgreater      BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y)
+            {
+               if (isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) || isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(y))
+                  return false;
+               return x > y;
+            }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return isgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return isgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+            inline bool                                      isgreaterequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y)
+            {
+               if (isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) || isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(y))
+                  return false;
+               return x >= y;
+            }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isgreaterequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return isgreaterequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isgreaterequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return isgreaterequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+            inline bool                                      isless      BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y)
+            {
+               if (isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) || isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(y))
+                  return false;
+               return x < y;
+            }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isless BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return isless BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isless BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return isless BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+
+            inline bool                                      islessequal   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y)
+            {
+               if (isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) || isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(y))
+                  return false;
+               return x <= y;
+            }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               islessequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return islessequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               islessequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return islessequal BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+
+            inline bool                                      islessgreater   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y)
+            {
+               if (isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x) || isnan BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(y))
+                  return false;
+               return (x < y) || (x > y);
+            }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               islessgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return islessgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               islessgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return islessgreater BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+
+            inline bool                                      isunordered   BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, boost::math::cstdfloat::detail::float_internal128_t y) { return ::BOOST_CSTDFLOAT_FLOAT128_ISNAN(x) || ::BOOST_CSTDFLOAT_FLOAT128_ISNAN(y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isunordered BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(boost::math::cstdfloat::detail::float_internal128_t x, T y) { return isunordered BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(x, (boost::math::cstdfloat::detail::float_internal128_t)y); }
+            template <class T>
+            inline typename std::enable_if<
+               std::is_convertible<T, boost::math::cstdfloat::detail::float_internal128_t>::value
+               && !std::is_same<T, boost::math::cstdfloat::detail::float_internal128_t>::value, boost::math::cstdfloat::detail::float_internal128_t>::type
+               isunordered BOOST_MATH_PREVENT_MACRO_SUBSTITUTION(T x, boost::math::cstdfloat::detail::float_internal128_t y) { return isunordered BOOST_MATH_PREVENT_MACRO_SUBSTITUTION((boost::math::cstdfloat::detail::float_internal128_t)x, y); }
+
+
+            //   end more functions
+         }
+      }
+   }
+} // boost::math::cstdfloat::detail
+
+// We will now inject the quadruple-precision <cmath> functions
+// into the std namespace. This is done via *using* directive.
+namespace std
+{
+   using boost::math::cstdfloat::detail::ldexp;
+   using boost::math::cstdfloat::detail::frexp;
+   using boost::math::cstdfloat::detail::fabs;
+
+#if !(defined(_GLIBCXX_USE_FLOAT128) && defined(__GNUC__) && (__GNUC__ >= 7))
+#if (defined(__clang__) && !(!defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128))) || (__GNUC__ <= 6 && !defined(__clang__)) 
+   // workaround for clang using libstdc++ and old GCC
+   using boost::math::cstdfloat::detail::abs;
+#endif
+#endif
+
+   using boost::math::cstdfloat::detail::floor;
+   using boost::math::cstdfloat::detail::ceil;
+   using boost::math::cstdfloat::detail::sqrt;
+   using boost::math::cstdfloat::detail::trunc;
+   using boost::math::cstdfloat::detail::exp;
+   using boost::math::cstdfloat::detail::expm1;
+   using boost::math::cstdfloat::detail::pow;
+   using boost::math::cstdfloat::detail::log;
+   using boost::math::cstdfloat::detail::log10;
+   using boost::math::cstdfloat::detail::sin;
+   using boost::math::cstdfloat::detail::cos;
+   using boost::math::cstdfloat::detail::tan;
+   using boost::math::cstdfloat::detail::asin;
+   using boost::math::cstdfloat::detail::acos;
+   using boost::math::cstdfloat::detail::atan;
+   using boost::math::cstdfloat::detail::sinh;
+   using boost::math::cstdfloat::detail::cosh;
+   using boost::math::cstdfloat::detail::tanh;
+   using boost::math::cstdfloat::detail::asinh;
+   using boost::math::cstdfloat::detail::acosh;
+   using boost::math::cstdfloat::detail::atanh;
+   using boost::math::cstdfloat::detail::fmod;
+   using boost::math::cstdfloat::detail::atan2;
+   using boost::math::cstdfloat::detail::lgamma;
+   using boost::math::cstdfloat::detail::tgamma;
+
+   //   begin more functions
+   using boost::math::cstdfloat::detail::remainder;
+   using boost::math::cstdfloat::detail::remquo;
+   using boost::math::cstdfloat::detail::fma;
+   using boost::math::cstdfloat::detail::fmax;
+   using boost::math::cstdfloat::detail::fmin;
+   using boost::math::cstdfloat::detail::fdim;
+   using boost::math::cstdfloat::detail::nanq;
+   using boost::math::cstdfloat::detail::exp2;
+   using boost::math::cstdfloat::detail::log2;
+   using boost::math::cstdfloat::detail::log1p;
+   using boost::math::cstdfloat::detail::cbrt;
+   using boost::math::cstdfloat::detail::hypot;
+   using boost::math::cstdfloat::detail::erf;
+   using boost::math::cstdfloat::detail::erfc;
+   using boost::math::cstdfloat::detail::llround;
+   using boost::math::cstdfloat::detail::lround;
+   using boost::math::cstdfloat::detail::round;
+   using boost::math::cstdfloat::detail::nearbyint;
+   using boost::math::cstdfloat::detail::llrint;
+   using boost::math::cstdfloat::detail::lrint;
+   using boost::math::cstdfloat::detail::rint;
+   using boost::math::cstdfloat::detail::modf;
+   using boost::math::cstdfloat::detail::scalbln;
+   using boost::math::cstdfloat::detail::scalbn;
+   using boost::math::cstdfloat::detail::ilogb;
+   using boost::math::cstdfloat::detail::logb;
+   using boost::math::cstdfloat::detail::nextafter;
+   using boost::math::cstdfloat::detail::nexttoward;
+   using boost::math::cstdfloat::detail::copysign;
+   using boost::math::cstdfloat::detail::signbit;
+   using boost::math::cstdfloat::detail::fpclassify;
+   using boost::math::cstdfloat::detail::isfinite;
+   using boost::math::cstdfloat::detail::isinf;
+   using boost::math::cstdfloat::detail::isnan;
+   using boost::math::cstdfloat::detail::isnormal;
+   using boost::math::cstdfloat::detail::isgreater;
+   using boost::math::cstdfloat::detail::isgreaterequal;
+   using boost::math::cstdfloat::detail::isless;
+   using boost::math::cstdfloat::detail::islessequal;
+   using boost::math::cstdfloat::detail::islessgreater;
+   using boost::math::cstdfloat::detail::isunordered;
+   //   end more functions
+
+} // namespace std
+
+// We will now remove the preprocessor symbols representing quadruple-precision <cmath>
+// functions from the preprocessor.
+
+#undef BOOST_CSTDFLOAT_FLOAT128_LDEXP
+#undef BOOST_CSTDFLOAT_FLOAT128_FREXP
+#undef BOOST_CSTDFLOAT_FLOAT128_FABS
+#undef BOOST_CSTDFLOAT_FLOAT128_FLOOR
+#undef BOOST_CSTDFLOAT_FLOAT128_CEIL
+#undef BOOST_CSTDFLOAT_FLOAT128_SQRT
+#undef BOOST_CSTDFLOAT_FLOAT128_TRUNC
+#undef BOOST_CSTDFLOAT_FLOAT128_EXP
+#undef BOOST_CSTDFLOAT_FLOAT128_EXPM1
+#undef BOOST_CSTDFLOAT_FLOAT128_POW
+#undef BOOST_CSTDFLOAT_FLOAT128_LOG
+#undef BOOST_CSTDFLOAT_FLOAT128_LOG10
+#undef BOOST_CSTDFLOAT_FLOAT128_SIN
+#undef BOOST_CSTDFLOAT_FLOAT128_COS
+#undef BOOST_CSTDFLOAT_FLOAT128_TAN
+#undef BOOST_CSTDFLOAT_FLOAT128_ASIN
+#undef BOOST_CSTDFLOAT_FLOAT128_ACOS
+#undef BOOST_CSTDFLOAT_FLOAT128_ATAN
+#undef BOOST_CSTDFLOAT_FLOAT128_SINH
+#undef BOOST_CSTDFLOAT_FLOAT128_COSH
+#undef BOOST_CSTDFLOAT_FLOAT128_TANH
+#undef BOOST_CSTDFLOAT_FLOAT128_ASINH
+#undef BOOST_CSTDFLOAT_FLOAT128_ACOSH
+#undef BOOST_CSTDFLOAT_FLOAT128_ATANH
+#undef BOOST_CSTDFLOAT_FLOAT128_FMOD
+#undef BOOST_CSTDFLOAT_FLOAT128_ATAN2
+#undef BOOST_CSTDFLOAT_FLOAT128_LGAMMA
+#undef BOOST_CSTDFLOAT_FLOAT128_TGAMMA
+
+//   begin more functions
+#undef BOOST_CSTDFLOAT_FLOAT128_REMAINDER
+#undef BOOST_CSTDFLOAT_FLOAT128_REMQUO
+#undef BOOST_CSTDFLOAT_FLOAT128_FMA
+#undef BOOST_CSTDFLOAT_FLOAT128_FMAX
+#undef BOOST_CSTDFLOAT_FLOAT128_FMIN
+#undef BOOST_CSTDFLOAT_FLOAT128_FDIM
+#undef BOOST_CSTDFLOAT_FLOAT128_NAN
+#undef BOOST_CSTDFLOAT_FLOAT128_EXP2
+#undef BOOST_CSTDFLOAT_FLOAT128_LOG2
+#undef BOOST_CSTDFLOAT_FLOAT128_LOG1P
+#undef BOOST_CSTDFLOAT_FLOAT128_CBRT
+#undef BOOST_CSTDFLOAT_FLOAT128_HYPOT
+#undef BOOST_CSTDFLOAT_FLOAT128_ERF
+#undef BOOST_CSTDFLOAT_FLOAT128_ERFC
+#undef BOOST_CSTDFLOAT_FLOAT128_LLROUND
+#undef BOOST_CSTDFLOAT_FLOAT128_LROUND
+#undef BOOST_CSTDFLOAT_FLOAT128_ROUND
+#undef BOOST_CSTDFLOAT_FLOAT128_NEARBYINT
+#undef BOOST_CSTDFLOAT_FLOAT128_LLRINT
+#undef BOOST_CSTDFLOAT_FLOAT128_LRINT
+#undef BOOST_CSTDFLOAT_FLOAT128_RINT
+#undef BOOST_CSTDFLOAT_FLOAT128_MODF
+#undef BOOST_CSTDFLOAT_FLOAT128_SCALBLN
+#undef BOOST_CSTDFLOAT_FLOAT128_SCALBN
+#undef BOOST_CSTDFLOAT_FLOAT128_ILOGB
+#undef BOOST_CSTDFLOAT_FLOAT128_LOGB
+#undef BOOST_CSTDFLOAT_FLOAT128_NEXTAFTER
+#undef BOOST_CSTDFLOAT_FLOAT128_NEXTTOWARD
+#undef BOOST_CSTDFLOAT_FLOAT128_COPYSIGN
+#undef BOOST_CSTDFLOAT_FLOAT128_SIGNBIT
+#undef BOOST_CSTDFLOAT_FLOAT128_FPCLASSIFY
+#undef BOOST_CSTDFLOAT_FLOAT128_ISFINITE
+#undef BOOST_CSTDFLOAT_FLOAT128_ISINF
+#undef BOOST_CSTDFLOAT_FLOAT128_ISNAN
+#undef BOOST_CSTDFLOAT_FLOAT128_ISNORMAL
+#undef BOOST_CSTDFLOAT_FLOAT128_ISGREATER
+#undef BOOST_CSTDFLOAT_FLOAT128_ISGREATEREQUAL
+#undef BOOST_CSTDFLOAT_FLOAT128_ISLESS
+#undef BOOST_CSTDFLOAT_FLOAT128_ISLESSEQUAL
+#undef BOOST_CSTDFLOAT_FLOAT128_ISLESSGREATER
+#undef BOOST_CSTDFLOAT_FLOAT128_ISUNORDERED
+//   end more functions
+
+#endif // Not BOOST_CSTDFLOAT_NO_LIBQUADMATH_SUPPORT (i.e., the user would like to have libquadmath support)
+
+#endif // BOOST_MATH_CSTDFLOAT_CMATH_2014_02_15_HPP_
+