| /* SPDX-License-Identifier: MIT |
| * |
| * Permission is hereby granted, free of charge, to any person |
| * obtaining a copy of this software and associated documentation |
| * files (the "Software"), to deal in the Software without |
| * restriction, including without limitation the rights to use, copy, |
| * modify, merge, publish, distribute, sublicense, and/or sell copies |
| * of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| * |
| * Copyright: |
| * 2017-2020 Evan Nemerson <evan@nemerson.com> |
| * 2023 Yi-Yen Chung <eric681@andestech.com> (Copyright owned by Andes Technology) |
| */ |
| |
| /* Attempt to find math functions. Functions may be in <cmath>, |
| * <math.h>, compiler built-ins/intrinsics, or platform/architecture |
| * specific headers. In some cases, especially those not built in to |
| * libm, we may need to define our own implementations. */ |
| |
| #if !defined(SIMDE_MATH_H) |
| #define SIMDE_MATH_H 1 |
| |
| #include "hedley.h" |
| #include "simde-features.h" |
| |
| #include <stdint.h> |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| #include <arm_neon.h> |
| #endif |
| |
| HEDLEY_DIAGNOSTIC_PUSH |
| SIMDE_DISABLE_UNWANTED_DIAGNOSTICS |
| |
| /* SLEEF support |
| * https://sleef.org/ |
| * |
| * If you include <sleef.h> prior to including SIMDe, SIMDe will use |
| * SLEEF. You can also define SIMDE_MATH_SLEEF_ENABLE prior to |
| * including SIMDe to force the issue. |
| * |
| * Note that SLEEF does requires linking to libsleef. |
| * |
| * By default, SIMDe will use the 1 ULP functions, but if you use |
| * SIMDE_ACCURACY_PREFERENCE of 0 we will use up to 4 ULP. This is |
| * only the case for the simde_math_* functions; for code in other |
| * SIMDe headers which calls SLEEF directly we may use functions with |
| * greater error if the API we're implementing is less precise (for |
| * example, SVML guarantees 4 ULP, so we will generally use the 3.5 |
| * ULP functions from SLEEF). */ |
| #if !defined(SIMDE_MATH_SLEEF_DISABLE) |
| #if defined(__SLEEF_H__) |
| #define SIMDE_MATH_SLEEF_ENABLE |
| #endif |
| #endif |
| |
| #if defined(SIMDE_MATH_SLEEF_ENABLE) && !defined(__SLEEF_H__) |
| HEDLEY_DIAGNOSTIC_PUSH |
| SIMDE_DIAGNOSTIC_DISABLE_IGNORED_QUALIFIERS_ |
| #include <sleef.h> |
| HEDLEY_DIAGNOSTIC_POP |
| #endif |
| |
| #if defined(SIMDE_MATH_SLEEF_ENABLE) && defined(__SLEEF_H__) |
| #if defined(SLEEF_VERSION_MAJOR) |
| #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (HEDLEY_VERSION_ENCODE(SLEEF_VERSION_MAJOR, SLEEF_VERSION_MINOR, SLEEF_VERSION_PATCHLEVEL) >= HEDLEY_VERSION_ENCODE(major, minor, patch)) |
| #else |
| #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (HEDLEY_VERSION_ENCODE(3,0,0) >= HEDLEY_VERSION_ENCODE(major, minor, patch)) |
| #endif |
| #else |
| #define SIMDE_MATH_SLEEF_VERSION_CHECK(major, minor, patch) (0) |
| #endif |
| |
| #if defined(__has_builtin) |
| #define SIMDE_MATH_BUILTIN_LIBM(func) __has_builtin(__builtin_##func) |
| #elif \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_GCC_VERSION_CHECK(4,4,0) |
| #define SIMDE_MATH_BUILTIN_LIBM(func) (1) |
| #else |
| #define SIMDE_MATH_BUILTIN_LIBM(func) (0) |
| #endif |
| |
| #if defined(HUGE_VAL) |
| /* Looks like <math.h> or <cmath> has already been included. */ |
| |
| /* The math.h from libc++ (yes, the C header from the C++ standard |
| * library) will define an isnan function, but not an isnan macro |
| * like the C standard requires. So we detect the header guards |
| * macro libc++ uses. */ |
| #if defined(isnan) || (defined(_LIBCPP_MATH_H) && !defined(_LIBCPP_CMATH)) |
| #define SIMDE_MATH_HAVE_MATH_H |
| #elif defined(__cplusplus) && !defined(HEDLEY_MSVC_VERSION) |
| #define SIMDE_MATH_HAVE_CMATH |
| #endif |
| #endif |
| #if defined(__has_include) && !(defined(SIMDE_MATH_HAVE_MATH_H) || defined(SIMDE_MATH_HAVE_CMATH)) |
| #if defined(__cplusplus) && (__cplusplus >= 201103L) && __has_include(<cmath>) |
| #define SIMDE_MATH_HAVE_CMATH |
| #include <cmath> |
| #elif __has_include(<math.h>) |
| #define SIMDE_MATH_HAVE_MATH_H |
| #include <math.h> |
| #elif !defined(SIMDE_MATH_NO_LIBM) |
| #define SIMDE_MATH_NO_LIBM |
| #endif |
| #elif !defined(SIMDE_MATH_NO_LIBM) |
| #if defined(__cplusplus) && (__cplusplus >= 201103L) |
| #define SIMDE_MATH_HAVE_CMATH |
| HEDLEY_DIAGNOSTIC_PUSH |
| #if defined(HEDLEY_MSVC_VERSION) |
| /* VS 14 emits this diagnostic about noexcept being used on a |
| * <cmath> function, which we can't do anything about. */ |
| #pragma warning(disable:4996) |
| #endif |
| #include <cmath> |
| HEDLEY_DIAGNOSTIC_POP |
| #else |
| #define SIMDE_MATH_HAVE_MATH_H |
| #include <math.h> |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_INFINITY) |
| #if \ |
| HEDLEY_HAS_BUILTIN(__builtin_inf) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_CRAY_VERSION_CHECK(8,1,0) |
| #define SIMDE_MATH_INFINITY (__builtin_inf()) |
| #elif defined(INFINITY) |
| #define SIMDE_MATH_INFINITY INFINITY |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_INFINITYF) |
| #if \ |
| HEDLEY_HAS_BUILTIN(__builtin_inff) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ |
| HEDLEY_IBM_VERSION_CHECK(13,1,0) |
| #define SIMDE_MATH_INFINITYF (__builtin_inff()) |
| #elif defined(INFINITYF) |
| #define SIMDE_MATH_INFINITYF INFINITYF |
| #elif defined(SIMDE_MATH_INFINITY) |
| #define SIMDE_MATH_INFINITYF HEDLEY_STATIC_CAST(float, SIMDE_MATH_INFINITY) |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_NAN) |
| #if \ |
| HEDLEY_HAS_BUILTIN(__builtin_nan) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ |
| HEDLEY_IBM_VERSION_CHECK(13,1,0) |
| #define SIMDE_MATH_NAN (__builtin_nan("")) |
| #elif defined(NAN) |
| #define SIMDE_MATH_NAN NAN |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_NANF) |
| #if \ |
| HEDLEY_HAS_BUILTIN(__builtin_nanf) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_CRAY_VERSION_CHECK(8,1,0) |
| #define SIMDE_MATH_NANF (__builtin_nanf("")) |
| #elif defined(NANF) |
| #define SIMDE_MATH_NANF NANF |
| #elif defined(SIMDE_MATH_NAN) |
| #define SIMDE_MATH_NANF HEDLEY_STATIC_CAST(float, SIMDE_MATH_NAN) |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_PI) |
| #if defined(M_PI) |
| #define SIMDE_MATH_PI M_PI |
| #else |
| #define SIMDE_MATH_PI 3.14159265358979323846 |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_PIF) |
| #if defined(M_PI) |
| #define SIMDE_MATH_PIF HEDLEY_STATIC_CAST(float, M_PI) |
| #else |
| #define SIMDE_MATH_PIF 3.14159265358979323846f |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_PI_OVER_180) |
| #define SIMDE_MATH_PI_OVER_180 0.0174532925199432957692369076848861271344287188854172545609719144 |
| #endif |
| |
| #if !defined(SIMDE_MATH_PI_OVER_180F) |
| #define SIMDE_MATH_PI_OVER_180F 0.0174532925199432957692369076848861271344287188854172545609719144f |
| #endif |
| |
| #if !defined(SIMDE_MATH_180_OVER_PI) |
| #define SIMDE_MATH_180_OVER_PI 57.295779513082320876798154814105170332405472466564321549160243861 |
| #endif |
| |
| #if !defined(SIMDE_MATH_180_OVER_PIF) |
| #define SIMDE_MATH_180_OVER_PIF 57.295779513082320876798154814105170332405472466564321549160243861f |
| #endif |
| |
| #if !defined(SIMDE_MATH_FLT_MIN) |
| #if defined(__FLT_MIN__) |
| #define SIMDE_MATH_FLT_MIN __FLT_MIN__ |
| #else |
| #if !defined(FLT_MIN) |
| #if defined(__cplusplus) |
| #include <cfloat> |
| #else |
| #include <float.h> |
| #endif |
| #endif |
| #define SIMDE_MATH_FLT_MIN FLT_MIN |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_FLT_MAX) |
| #if defined(__FLT_MAX__) |
| #define SIMDE_MATH_FLT_MAX __FLT_MAX__ |
| #else |
| #if !defined(FLT_MAX) |
| #if defined(__cplusplus) |
| #include <cfloat> |
| #else |
| #include <float.h> |
| #endif |
| #endif |
| #define SIMDE_MATH_FLT_MAX FLT_MAX |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_DBL_MIN) |
| #if defined(__DBL_MIN__) |
| #define SIMDE_MATH_DBL_MIN __DBL_MIN__ |
| #else |
| #if !defined(DBL_MIN) |
| #if defined(__cplusplus) |
| #include <cfloat> |
| #else |
| #include <float.h> |
| #endif |
| #endif |
| #define SIMDE_MATH_DBL_MIN DBL_MIN |
| #endif |
| #endif |
| |
| #if !defined(SIMDE_MATH_DBL_MAX) |
| #if defined(__DBL_MAX__) |
| #define SIMDE_MATH_DBL_MAX __DBL_MAX__ |
| #else |
| #if !defined(DBL_MAX) |
| #if defined(__cplusplus) |
| #include <cfloat> |
| #else |
| #include <float.h> |
| #endif |
| #endif |
| #define SIMDE_MATH_DBL_MAX DBL_MAX |
| #endif |
| #endif |
| |
| /*** Classification macros from C99 ***/ |
| |
| #if !defined(simde_math_isinf) |
| #if SIMDE_MATH_BUILTIN_LIBM(isinf) |
| #define simde_math_isinf(v) __builtin_isinf(v) |
| #elif defined(isinf) || defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_isinf(v) isinf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isinf(v) std::isinf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_isinff) |
| #if HEDLEY_HAS_BUILTIN(__builtin_isinff) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) |
| #define simde_math_isinff(v) __builtin_isinff(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isinff(v) std::isinf(v) |
| #elif defined(simde_math_isinf) |
| #define simde_math_isinff(v) simde_math_isinf(HEDLEY_STATIC_CAST(double, v)) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_isnan) |
| #if SIMDE_MATH_BUILTIN_LIBM(isnan) |
| #define simde_math_isnan(v) __builtin_isnan(v) |
| #elif defined(isnan) || defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_isnan(v) isnan(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isnan(v) std::isnan(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_isnanf) |
| #if HEDLEY_HAS_BUILTIN(__builtin_isnanf) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) |
| /* XL C/C++ has __builtin_isnan but not __builtin_isnanf */ |
| #define simde_math_isnanf(v) __builtin_isnanf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isnanf(v) std::isnan(v) |
| #elif defined(simde_math_isnan) |
| #define simde_math_isnanf(v) simde_math_isnan(HEDLEY_STATIC_CAST(double, v)) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_isnormal) |
| #if SIMDE_MATH_BUILTIN_LIBM(isnormal) |
| #define simde_math_isnormal(v) __builtin_isnormal(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_isnormal(v) isnormal(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isnormal(v) std::isnormal(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_isnormalf) |
| #if HEDLEY_HAS_BUILTIN(__builtin_isnormalf) |
| #define simde_math_isnormalf(v) __builtin_isnormalf(v) |
| #elif SIMDE_MATH_BUILTIN_LIBM(isnormal) |
| #define simde_math_isnormalf(v) __builtin_isnormal(v) |
| #elif defined(isnormalf) |
| #define simde_math_isnormalf(v) isnormalf(v) |
| #elif defined(isnormal) || defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_isnormalf(v) isnormal(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_isnormalf(v) std::isnormal(v) |
| #elif defined(simde_math_isnormal) |
| #define simde_math_isnormalf(v) simde_math_isnormal(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_issubnormalf) |
| #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) |
| #define simde_math_issubnormalf(v) __builtin_fpclassify(0, 0, 0, 1, 0, v) |
| #elif defined(fpclassify) |
| #define simde_math_issubnormalf(v) (fpclassify(v) == FP_SUBNORMAL) |
| #elif defined(SIMDE_IEEE754_STORAGE) |
| #define simde_math_issubnormalf(v) (((simde_float32_as_uint32(v) & UINT32_C(0x7F800000)) == UINT32_C(0)) && ((simde_float32_as_uint32(v) & UINT32_C(0x007FFFFF)) != UINT32_C(0))) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_issubnormal) |
| #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) |
| #define simde_math_issubnormal(v) __builtin_fpclassify(0, 0, 0, 1, 0, v) |
| #elif defined(fpclassify) |
| #define simde_math_issubnormal(v) (fpclassify(v) == FP_SUBNORMAL) |
| #elif defined(SIMDE_IEEE754_STORAGE) |
| #define simde_math_issubnormal(v) (((simde_float64_as_uint64(v) & UINT64_C(0x7FF0000000000000)) == UINT64_C(0)) && ((simde_float64_as_uint64(v) & UINT64_C(0x00FFFFFFFFFFFFF)) != UINT64_C(0))) |
| #endif |
| #endif |
| |
| #if defined(FP_NAN) |
| #define SIMDE_MATH_FP_NAN FP_NAN |
| #else |
| #define SIMDE_MATH_FP_NAN 0 |
| #endif |
| #if defined(FP_INFINITE) |
| #define SIMDE_MATH_FP_INFINITE FP_INFINITE |
| #else |
| #define SIMDE_MATH_FP_INFINITE 1 |
| #endif |
| #if defined(FP_ZERO) |
| #define SIMDE_MATH_FP_ZERO FP_ZERO |
| #else |
| #define SIMDE_MATH_FP_ZERO 2 |
| #endif |
| #if defined(FP_SUBNORMAL) |
| #define SIMDE_MATH_FP_SUBNORMAL FP_SUBNORMAL |
| #else |
| #define SIMDE_MATH_FP_SUBNORMAL 3 |
| #endif |
| #if defined(FP_NORMAL) |
| #define SIMDE_MATH_FP_NORMAL FP_NORMAL |
| #else |
| #define SIMDE_MATH_FP_NORMAL 4 |
| #endif |
| |
| static HEDLEY_INLINE |
| int |
| simde_math_fpclassifyf(float v) { |
| #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) |
| return __builtin_fpclassify(SIMDE_MATH_FP_NAN, SIMDE_MATH_FP_INFINITE, SIMDE_MATH_FP_NORMAL, SIMDE_MATH_FP_SUBNORMAL, SIMDE_MATH_FP_ZERO, v); |
| #elif defined(fpclassify) |
| return fpclassify(v); |
| #else |
| return |
| simde_math_isnormalf(v) ? SIMDE_MATH_FP_NORMAL : |
| (v == 0.0f) ? SIMDE_MATH_FP_ZERO : |
| simde_math_isnanf(v) ? SIMDE_MATH_FP_NAN : |
| simde_math_isinff(v) ? SIMDE_MATH_FP_INFINITE : |
| SIMDE_MATH_FP_SUBNORMAL; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int |
| simde_math_fpclassify(double v) { |
| #if SIMDE_MATH_BUILTIN_LIBM(fpclassify) |
| return __builtin_fpclassify(SIMDE_MATH_FP_NAN, SIMDE_MATH_FP_INFINITE, SIMDE_MATH_FP_NORMAL, SIMDE_MATH_FP_SUBNORMAL, SIMDE_MATH_FP_ZERO, v); |
| #elif defined(fpclassify) |
| return fpclassify(v); |
| #else |
| return |
| simde_math_isnormal(v) ? SIMDE_MATH_FP_NORMAL : |
| (v == 0.0) ? SIMDE_MATH_FP_ZERO : |
| simde_math_isnan(v) ? SIMDE_MATH_FP_NAN : |
| simde_math_isinf(v) ? SIMDE_MATH_FP_INFINITE : |
| SIMDE_MATH_FP_SUBNORMAL; |
| #endif |
| } |
| |
| #define SIMDE_MATH_FP_QNAN 0x01 |
| #define SIMDE_MATH_FP_PZERO 0x02 |
| #define SIMDE_MATH_FP_NZERO 0x04 |
| #define SIMDE_MATH_FP_PINF 0x08 |
| #define SIMDE_MATH_FP_NINF 0x10 |
| #define SIMDE_MATH_FP_DENORMAL 0x20 |
| #define SIMDE_MATH_FP_NEGATIVE 0x40 |
| #define SIMDE_MATH_FP_SNAN 0x80 |
| |
| static HEDLEY_INLINE |
| uint8_t |
| simde_math_fpclassf(float v, const int imm8) { |
| union { |
| float f; |
| uint32_t u; |
| } fu; |
| fu.f = v; |
| uint32_t bits = fu.u; |
| uint8_t NegNum = (bits >> 31) & 1; |
| uint32_t const ExpMask = 0x3F800000; // [30:23] |
| uint32_t const MantMask = 0x007FFFFF; // [22:0] |
| uint8_t ExpAllOnes = ((bits & ExpMask) == ExpMask); |
| uint8_t ExpAllZeros = ((bits & ExpMask) == 0); |
| uint8_t MantAllZeros = ((bits & MantMask) == 0); |
| uint8_t ZeroNumber = ExpAllZeros & MantAllZeros; |
| uint8_t SignalingBit = (bits >> 22) & 1; |
| |
| uint8_t result = 0; |
| uint8_t qNaN_res = ExpAllOnes & (!MantAllZeros) & SignalingBit; |
| uint8_t Pzero_res = (!NegNum) & ExpAllZeros & MantAllZeros; |
| uint8_t Nzero_res = NegNum & ExpAllZeros & MantAllZeros; |
| uint8_t Pinf_res = (!NegNum) & ExpAllOnes & MantAllZeros; |
| uint8_t Ninf_res = NegNum & ExpAllOnes & MantAllZeros; |
| uint8_t Denorm_res = ExpAllZeros & (!MantAllZeros); |
| uint8_t FinNeg_res = NegNum & (!ExpAllOnes) & (!ZeroNumber); |
| uint8_t sNaN_res = ExpAllOnes & (!MantAllZeros) & (!SignalingBit); |
| result = (((imm8 >> 0) & qNaN_res) | \ |
| ((imm8 >> 1) & Pzero_res) | \ |
| ((imm8 >> 2) & Nzero_res) | \ |
| ((imm8 >> 3) & Pinf_res) | \ |
| ((imm8 >> 4) & Ninf_res) | \ |
| ((imm8 >> 5) & Denorm_res) | \ |
| ((imm8 >> 6) & FinNeg_res) | \ |
| ((imm8 >> 7) & sNaN_res)); |
| return result; |
| } |
| |
| static HEDLEY_INLINE |
| uint8_t |
| simde_math_fpclass(double v, const int imm8) { |
| union { |
| double d; |
| uint64_t u; |
| } du; |
| du.d = v; |
| uint64_t bits = du.u; |
| uint8_t NegNum = (bits >> 63) & 1; |
| uint64_t const ExpMask = 0x3FF0000000000000; // [62:52] |
| uint64_t const MantMask = 0x000FFFFFFFFFFFFF; // [51:0] |
| uint8_t ExpAllOnes = ((bits & ExpMask) == ExpMask); |
| uint8_t ExpAllZeros = ((bits & ExpMask) == 0); |
| uint8_t MantAllZeros = ((bits & MantMask) == 0); |
| uint8_t ZeroNumber = ExpAllZeros & MantAllZeros; |
| uint8_t SignalingBit = (bits >> 51) & 1; |
| |
| uint8_t result = 0; |
| uint8_t qNaN_res = ExpAllOnes & (!MantAllZeros) & SignalingBit; |
| uint8_t Pzero_res = (!NegNum) & ExpAllZeros & MantAllZeros; |
| uint8_t Nzero_res = NegNum & ExpAllZeros & MantAllZeros; |
| uint8_t Pinf_res = (!NegNum) & ExpAllOnes & MantAllZeros; |
| uint8_t Ninf_res = NegNum & ExpAllOnes & MantAllZeros; |
| uint8_t Denorm_res = ExpAllZeros & (!MantAllZeros); |
| uint8_t FinNeg_res = NegNum & (!ExpAllOnes) & (!ZeroNumber); |
| uint8_t sNaN_res = ExpAllOnes & (!MantAllZeros) & (!SignalingBit); |
| result = (((imm8 >> 0) & qNaN_res) | \ |
| ((imm8 >> 1) & Pzero_res) | \ |
| ((imm8 >> 2) & Nzero_res) | \ |
| ((imm8 >> 3) & Pinf_res) | \ |
| ((imm8 >> 4) & Ninf_res) | \ |
| ((imm8 >> 5) & Denorm_res) | \ |
| ((imm8 >> 6) & FinNeg_res) | \ |
| ((imm8 >> 7) & sNaN_res)); |
| return result; |
| } |
| |
| /*** Manipulation functions ***/ |
| |
| #if !defined(simde_math_nextafter) |
| #if \ |
| (HEDLEY_HAS_BUILTIN(__builtin_nextafter) && !defined(HEDLEY_IBM_VERSION)) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) |
| #define simde_math_nextafter(x, y) __builtin_nextafter(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_nextafter(x, y) std::nextafter(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_nextafter(x, y) nextafter(x, y) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_nextafterf) |
| #if \ |
| (HEDLEY_HAS_BUILTIN(__builtin_nextafterf) && !defined(HEDLEY_IBM_VERSION)) || \ |
| HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ |
| HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ |
| HEDLEY_INTEL_VERSION_CHECK(13,0,0) |
| #define simde_math_nextafterf(x, y) __builtin_nextafterf(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_nextafterf(x, y) std::nextafter(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_nextafterf(x, y) nextafterf(x, y) |
| #endif |
| #endif |
| |
| /*** Functions from C99 ***/ |
| |
| #if !defined(simde_math_abs) |
| #if SIMDE_MATH_BUILTIN_LIBM(abs) |
| #define simde_math_abs(v) __builtin_abs(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_abs(v) std::abs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_abs(v) abs(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_labs) |
| #if SIMDE_MATH_BUILTIN_LIBM(labs) |
| #define simde_math_labs(v) __builtin_labs(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_labs(v) std::labs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_labs(v) labs(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_llabs) |
| #if SIMDE_MATH_BUILTIN_LIBM(llabs) |
| #define simde_math_llabs(v) __builtin_llabs(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_llabs(v) std::llabs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_llabs(v) llabs(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fabsf) |
| #if SIMDE_MATH_BUILTIN_LIBM(fabsf) |
| #define simde_math_fabsf(v) __builtin_fabsf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fabsf(v) std::abs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fabsf(v) fabsf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_acos) |
| #if SIMDE_MATH_BUILTIN_LIBM(acos) |
| #define simde_math_acos(v) __builtin_acos(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_acos(v) std::acos(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_acos(v) acos(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_acosf) |
| #if SIMDE_MATH_BUILTIN_LIBM(acosf) |
| #define simde_math_acosf(v) __builtin_acosf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_acosf(v) std::acos(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_acosf(v) acosf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_acosh) |
| #if SIMDE_MATH_BUILTIN_LIBM(acosh) |
| #define simde_math_acosh(v) __builtin_acosh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_acosh(v) std::acosh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_acosh(v) acosh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_acoshf) |
| #if SIMDE_MATH_BUILTIN_LIBM(acoshf) |
| #define simde_math_acoshf(v) __builtin_acoshf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_acoshf(v) std::acosh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_acoshf(v) acoshf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_asin) |
| #if SIMDE_MATH_BUILTIN_LIBM(asin) |
| #define simde_math_asin(v) __builtin_asin(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_asin(v) std::asin(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_asin(v) asin(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_asinf) |
| #if SIMDE_MATH_BUILTIN_LIBM(asinf) |
| #define simde_math_asinf(v) __builtin_asinf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_asinf(v) std::asin(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_asinf(v) asinf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_asinh) |
| #if SIMDE_MATH_BUILTIN_LIBM(asinh) |
| #define simde_math_asinh(v) __builtin_asinh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_asinh(v) std::asinh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_asinh(v) asinh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_asinhf) |
| #if SIMDE_MATH_BUILTIN_LIBM(asinhf) |
| #define simde_math_asinhf(v) __builtin_asinhf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_asinhf(v) std::asinh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_asinhf(v) asinhf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atan) |
| #if SIMDE_MATH_BUILTIN_LIBM(atan) |
| #define simde_math_atan(v) __builtin_atan(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atan(v) std::atan(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atan(v) atan(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atan2) |
| #if SIMDE_MATH_BUILTIN_LIBM(atan2) |
| #define simde_math_atan2(y, x) __builtin_atan2(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atan2(y, x) std::atan2(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atan2(y, x) atan2(y, x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atan2f) |
| #if SIMDE_MATH_BUILTIN_LIBM(atan2f) |
| #define simde_math_atan2f(y, x) __builtin_atan2f(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atan2f(y, x) std::atan2(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atan2f(y, x) atan2f(y, x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atanf) |
| #if SIMDE_MATH_BUILTIN_LIBM(atanf) |
| #define simde_math_atanf(v) __builtin_atanf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atanf(v) std::atan(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atanf(v) atanf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atanh) |
| #if SIMDE_MATH_BUILTIN_LIBM(atanh) |
| #define simde_math_atanh(v) __builtin_atanh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atanh(v) std::atanh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atanh(v) atanh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_atanhf) |
| #if SIMDE_MATH_BUILTIN_LIBM(atanhf) |
| #define simde_math_atanhf(v) __builtin_atanhf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_atanhf(v) std::atanh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_atanhf(v) atanhf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_cbrt) |
| #if SIMDE_MATH_BUILTIN_LIBM(cbrt) |
| #define simde_math_cbrt(v) __builtin_cbrt(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_cbrt(v) std::cbrt(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_cbrt(v) cbrt(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_cbrtf) |
| #if SIMDE_MATH_BUILTIN_LIBM(cbrtf) |
| #define simde_math_cbrtf(v) __builtin_cbrtf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_cbrtf(v) std::cbrt(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_cbrtf(v) cbrtf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_ceil) |
| #if SIMDE_MATH_BUILTIN_LIBM(ceil) |
| #define simde_math_ceil(v) __builtin_ceil(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_ceil(v) std::ceil(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_ceil(v) ceil(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_ceilf) |
| #if SIMDE_MATH_BUILTIN_LIBM(ceilf) |
| #define simde_math_ceilf(v) __builtin_ceilf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_ceilf(v) std::ceil(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_ceilf(v) ceilf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_copysign) |
| #if SIMDE_MATH_BUILTIN_LIBM(copysign) |
| #define simde_math_copysign(x, y) __builtin_copysign(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_copysign(x, y) std::copysign(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_copysign(x, y) copysign(x, y) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_copysignf) |
| #if SIMDE_MATH_BUILTIN_LIBM(copysignf) |
| #define simde_math_copysignf(x, y) __builtin_copysignf(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_copysignf(x, y) std::copysignf(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_copysignf(x, y) copysignf(x, y) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_signbit) |
| #if SIMDE_MATH_BUILTIN_LIBM(signbit) |
| #if (!defined(__clang__) || SIMDE_DETECT_CLANG_VERSION_CHECK(7,0,0)) |
| #define simde_math_signbit(x) __builtin_signbit(x) |
| #else |
| #define simde_math_signbit(x) __builtin_signbit(HEDLEY_STATIC_CAST(double, (x))) |
| #endif |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_signbit(x) std::signbit(x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_signbit(x) signbit(x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_cos) |
| #if SIMDE_MATH_BUILTIN_LIBM(cos) |
| #define simde_math_cos(v) __builtin_cos(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_cos(v) std::cos(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_cos(v) cos(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_cosf) |
| #if defined(SIMDE_MATH_SLEEF_ENABLE) |
| #if SIMDE_ACCURACY_PREFERENCE < 1 |
| #define simde_math_cosf(v) Sleef_cosf_u35(v) |
| #else |
| #define simde_math_cosf(v) Sleef_cosf_u10(v) |
| #endif |
| #elif SIMDE_MATH_BUILTIN_LIBM(cosf) |
| #define simde_math_cosf(v) __builtin_cosf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_cosf(v) std::cos(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_cosf(v) cosf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_cosh) |
| #if SIMDE_MATH_BUILTIN_LIBM(cosh) |
| #define simde_math_cosh(v) __builtin_cosh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_cosh(v) std::cosh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_cosh(v) cosh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_coshf) |
| #if SIMDE_MATH_BUILTIN_LIBM(coshf) |
| #define simde_math_coshf(v) __builtin_coshf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_coshf(v) std::cosh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_coshf(v) coshf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_erf) |
| #if SIMDE_MATH_BUILTIN_LIBM(erf) |
| #define simde_math_erf(v) __builtin_erf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_erf(v) std::erf(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_erf(v) erf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_erff) |
| #if SIMDE_MATH_BUILTIN_LIBM(erff) |
| #define simde_math_erff(v) __builtin_erff(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_erff(v) std::erf(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_erff(v) erff(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_erfc) |
| #if SIMDE_MATH_BUILTIN_LIBM(erfc) |
| #define simde_math_erfc(v) __builtin_erfc(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_erfc(v) std::erfc(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_erfc(v) erfc(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_erfcf) |
| #if SIMDE_MATH_BUILTIN_LIBM(erfcf) |
| #define simde_math_erfcf(v) __builtin_erfcf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_erfcf(v) std::erfc(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_erfcf(v) erfcf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_exp) |
| #if SIMDE_MATH_BUILTIN_LIBM(exp) |
| #define simde_math_exp(v) __builtin_exp(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_exp(v) std::exp(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_exp(v) exp(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_expf) |
| #if SIMDE_MATH_BUILTIN_LIBM(expf) |
| #define simde_math_expf(v) __builtin_expf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_expf(v) std::exp(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_expf(v) expf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_expm1) |
| #if SIMDE_MATH_BUILTIN_LIBM(expm1) |
| #define simde_math_expm1(v) __builtin_expm1(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_expm1(v) std::expm1(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_expm1(v) expm1(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_expm1f) |
| #if SIMDE_MATH_BUILTIN_LIBM(expm1f) |
| #define simde_math_expm1f(v) __builtin_expm1f(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_expm1f(v) std::expm1(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_expm1f(v) expm1f(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_exp2) |
| #if SIMDE_MATH_BUILTIN_LIBM(exp2) |
| #define simde_math_exp2(v) __builtin_exp2(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_exp2(v) std::exp2(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_exp2(v) exp2(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_exp2f) |
| #if SIMDE_MATH_BUILTIN_LIBM(exp2f) |
| #define simde_math_exp2f(v) __builtin_exp2f(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_exp2f(v) std::exp2(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_exp2f(v) exp2f(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_pow) |
| #if SIMDE_MATH_BUILTIN_LIBM(pow) |
| #define simde_math_pow(y, x) __builtin_pow(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_pow(y, x) std::pow(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_pow(y, x) pow(y, x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_powf) |
| #if SIMDE_MATH_BUILTIN_LIBM(powf) |
| #define simde_math_powf(y, x) __builtin_powf(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_powf(y, x) std::pow(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_powf(y, x) powf(y, x) |
| #endif |
| #endif |
| |
| #if HEDLEY_HAS_BUILTIN(__builtin_exp10) || HEDLEY_GCC_VERSION_CHECK(3,4,0) |
| # define simde_math_exp10(v) __builtin_exp10(v) |
| #else |
| # define simde_math_exp10(v) simde_math_pow(10.0, (v)) |
| #endif |
| |
| #if HEDLEY_HAS_BUILTIN(__builtin_exp10f) || HEDLEY_GCC_VERSION_CHECK(3,4,0) |
| # define simde_math_exp10f(v) __builtin_exp10f(v) |
| #else |
| # define simde_math_exp10f(v) simde_math_powf(10.0f, (v)) |
| #endif |
| |
| #if !defined(simde_math_fabs) |
| #if SIMDE_MATH_BUILTIN_LIBM(fabs) |
| #define simde_math_fabs(v) __builtin_fabs(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fabs(v) std::fabs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fabs(v) fabs(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fabsf) |
| #if SIMDE_MATH_BUILTIN_LIBM(fabsf) |
| #define simde_math_fabsf(v) __builtin_fabsf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fabsf(v) std::fabs(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fabsf(v) fabsf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_floor) |
| #if SIMDE_MATH_BUILTIN_LIBM(floor) |
| #define simde_math_floor(v) __builtin_floor(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_floor(v) std::floor(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_floor(v) floor(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_floorf) |
| #if SIMDE_MATH_BUILTIN_LIBM(floorf) |
| #define simde_math_floorf(v) __builtin_floorf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_floorf(v) std::floor(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_floorf(v) floorf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fma) |
| #if SIMDE_MATH_BUILTIN_LIBM(fma) |
| #define simde_math_fma(x, y, z) __builtin_fma(x, y, z) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fma(x, y, z) std::fma(x, y, z) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fma(x, y, z) fma(x, y, z) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fmaf) |
| #if SIMDE_MATH_BUILTIN_LIBM(fmaf) |
| #define simde_math_fmaf(x, y, z) __builtin_fmaf(x, y, z) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fmaf(x, y, z) std::fma(x, y, z) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fmaf(x, y, z) fmaf(x, y, z) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fmax) |
| #if SIMDE_MATH_BUILTIN_LIBM(fmax) |
| #define simde_math_fmax(x, y) __builtin_fmax(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fmax(x, y) std::fmax(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fmax(x, y) fmax(x, y) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_fmaxf) |
| #if SIMDE_MATH_BUILTIN_LIBM(fmaxf) |
| #define simde_math_fmaxf(x, y) __builtin_fmaxf(x, y) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_fmaxf(x, y) std::fmax(x, y) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_fmaxf(x, y) fmaxf(x, y) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_hypot) |
| #if SIMDE_MATH_BUILTIN_LIBM(hypot) |
| #define simde_math_hypot(y, x) __builtin_hypot(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_hypot(y, x) std::hypot(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_hypot(y, x) hypot(y, x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_hypotf) |
| #if SIMDE_MATH_BUILTIN_LIBM(hypotf) |
| #define simde_math_hypotf(y, x) __builtin_hypotf(y, x) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_hypotf(y, x) std::hypot(y, x) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_hypotf(y, x) hypotf(y, x) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log) |
| #if SIMDE_MATH_BUILTIN_LIBM(log) |
| #define simde_math_log(v) __builtin_log(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log(v) std::log(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log(v) log(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_logf) |
| #if SIMDE_MATH_BUILTIN_LIBM(logf) |
| #define simde_math_logf(v) __builtin_logf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_logf(v) std::log(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_logf(v) logf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_logb) |
| #if SIMDE_MATH_BUILTIN_LIBM(logb) |
| #define simde_math_logb(v) __builtin_logb(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_logb(v) std::logb(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_logb(v) logb(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_logbf) |
| #if SIMDE_MATH_BUILTIN_LIBM(logbf) |
| #define simde_math_logbf(v) __builtin_logbf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_logbf(v) std::logb(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_logbf(v) logbf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log1p) |
| #if SIMDE_MATH_BUILTIN_LIBM(log1p) |
| #define simde_math_log1p(v) __builtin_log1p(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log1p(v) std::log1p(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log1p(v) log1p(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log1pf) |
| #if SIMDE_MATH_BUILTIN_LIBM(log1pf) |
| #define simde_math_log1pf(v) __builtin_log1pf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log1pf(v) std::log1p(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log1pf(v) log1pf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log2) |
| #if SIMDE_MATH_BUILTIN_LIBM(log2) |
| #define simde_math_log2(v) __builtin_log2(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log2(v) std::log2(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log2(v) log2(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log2f) |
| #if SIMDE_MATH_BUILTIN_LIBM(log2f) |
| #define simde_math_log2f(v) __builtin_log2f(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log2f(v) std::log2(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log2f(v) log2f(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log10) |
| #if SIMDE_MATH_BUILTIN_LIBM(log10) |
| #define simde_math_log10(v) __builtin_log10(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log10(v) std::log10(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log10(v) log10(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_log10f) |
| #if SIMDE_MATH_BUILTIN_LIBM(log10f) |
| #define simde_math_log10f(v) __builtin_log10f(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_log10f(v) std::log10(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_log10f(v) log10f(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_modf) |
| #if SIMDE_MATH_BUILTIN_LIBM(modf) |
| #define simde_math_modf(x, iptr) __builtin_modf(x, iptr) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_modf(x, iptr) std::modf(x, iptr) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_modf(x, iptr) modf(x, iptr) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_modff) |
| #if SIMDE_MATH_BUILTIN_LIBM(modff) |
| #define simde_math_modff(x, iptr) __builtin_modff(x, iptr) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_modff(x, iptr) std::modf(x, iptr) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_modff(x, iptr) modff(x, iptr) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_nearbyint) |
| #if SIMDE_MATH_BUILTIN_LIBM(nearbyint) |
| #define simde_math_nearbyint(v) __builtin_nearbyint(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_nearbyint(v) std::nearbyint(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_nearbyint(v) nearbyint(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_nearbyintf) |
| #if SIMDE_MATH_BUILTIN_LIBM(nearbyintf) |
| #define simde_math_nearbyintf(v) __builtin_nearbyintf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_nearbyintf(v) std::nearbyint(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_nearbyintf(v) nearbyintf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_rint) |
| #if SIMDE_MATH_BUILTIN_LIBM(rint) |
| #define simde_math_rint(v) __builtin_rint(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_rint(v) std::rint(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_rint(v) rint(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_rintf) |
| #if SIMDE_MATH_BUILTIN_LIBM(rintf) |
| #define simde_math_rintf(v) __builtin_rintf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_rintf(v) std::rint(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_rintf(v) rintf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_round) |
| #if SIMDE_MATH_BUILTIN_LIBM(round) |
| #define simde_math_round(v) __builtin_round(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_round(v) std::round(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_round(v) round(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_roundf) |
| #if SIMDE_MATH_BUILTIN_LIBM(roundf) |
| #define simde_math_roundf(v) __builtin_roundf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_roundf(v) std::round(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_roundf(v) roundf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_roundeven) |
| #if \ |
| ((!defined(HEDLEY_EMSCRIPTEN_VERSION) || HEDLEY_EMSCRIPTEN_VERSION_CHECK(3, 1, 43)) && HEDLEY_HAS_BUILTIN(__builtin_roundeven)) || \ |
| HEDLEY_GCC_VERSION_CHECK(10,0,0) |
| #define simde_math_roundeven(v) __builtin_roundeven(v) |
| #elif defined(simde_math_round) && defined(simde_math_fabs) |
| static HEDLEY_INLINE |
| double |
| simde_math_roundeven(double v) { |
| double rounded = simde_math_round(v); |
| double diff = rounded - v; |
| if (HEDLEY_UNLIKELY(simde_math_fabs(diff) == 0.5) && (HEDLEY_STATIC_CAST(int64_t, rounded) & 1)) { |
| rounded = v - diff; |
| } |
| return rounded; |
| } |
| #define simde_math_roundeven simde_math_roundeven |
| #endif |
| #endif |
| |
| #if !defined(simde_math_roundevenf) |
| #if \ |
| ((!defined(HEDLEY_EMSCRIPTEN_VERSION) || HEDLEY_EMSCRIPTEN_VERSION_CHECK(3, 1, 43)) && HEDLEY_HAS_BUILTIN(__builtin_roundevenf)) || \ |
| HEDLEY_GCC_VERSION_CHECK(10,0,0) |
| #define simde_math_roundevenf(v) __builtin_roundevenf(v) |
| #elif defined(simde_math_roundf) && defined(simde_math_fabsf) |
| static HEDLEY_INLINE |
| float |
| simde_math_roundevenf(float v) { |
| float rounded = simde_math_roundf(v); |
| float diff = rounded - v; |
| if (HEDLEY_UNLIKELY(simde_math_fabsf(diff) == 0.5f) && (HEDLEY_STATIC_CAST(int32_t, rounded) & 1)) { |
| rounded = v - diff; |
| } |
| return rounded; |
| } |
| #define simde_math_roundevenf simde_math_roundevenf |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sin) |
| #if SIMDE_MATH_BUILTIN_LIBM(sin) |
| #define simde_math_sin(v) __builtin_sin(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sin(v) std::sin(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sin(v) sin(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sinf) |
| #if SIMDE_MATH_BUILTIN_LIBM(sinf) |
| #define simde_math_sinf(v) __builtin_sinf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sinf(v) std::sin(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sinf(v) sinf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sinh) |
| #if SIMDE_MATH_BUILTIN_LIBM(sinh) |
| #define simde_math_sinh(v) __builtin_sinh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sinh(v) std::sinh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sinh(v) sinh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sinhf) |
| #if SIMDE_MATH_BUILTIN_LIBM(sinhf) |
| #define simde_math_sinhf(v) __builtin_sinhf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sinhf(v) std::sinh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sinhf(v) sinhf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sqrt) |
| #if SIMDE_MATH_BUILTIN_LIBM(sqrt) |
| #define simde_math_sqrt(v) __builtin_sqrt(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sqrt(v) std::sqrt(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sqrt(v) sqrt(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sqrtf) |
| #if SIMDE_MATH_BUILTIN_LIBM(sqrtf) |
| #define simde_math_sqrtf(v) __builtin_sqrtf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sqrtf(v) std::sqrt(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sqrtf(v) sqrtf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_sqrtl) |
| #if SIMDE_MATH_BUILTIN_LIBM(sqrtl) |
| #define simde_math_sqrtl(v) __builtin_sqrtl(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_sqrtl(v) std::sqrt(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_sqrtl(v) sqrtl(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_tan) |
| #if SIMDE_MATH_BUILTIN_LIBM(tan) |
| #define simde_math_tan(v) __builtin_tan(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_tan(v) std::tan(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_tan(v) tan(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_tanf) |
| #if SIMDE_MATH_BUILTIN_LIBM(tanf) |
| #define simde_math_tanf(v) __builtin_tanf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_tanf(v) std::tan(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_tanf(v) tanf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_tanh) |
| #if SIMDE_MATH_BUILTIN_LIBM(tanh) |
| #define simde_math_tanh(v) __builtin_tanh(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_tanh(v) std::tanh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_tanh(v) tanh(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_tanhf) |
| #if SIMDE_MATH_BUILTIN_LIBM(tanhf) |
| #define simde_math_tanhf(v) __builtin_tanhf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_tanhf(v) std::tanh(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_tanhf(v) tanhf(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_trunc) |
| #if SIMDE_MATH_BUILTIN_LIBM(trunc) |
| #define simde_math_trunc(v) __builtin_trunc(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_trunc(v) std::trunc(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_trunc(v) trunc(v) |
| #endif |
| #endif |
| |
| #if !defined(simde_math_truncf) |
| #if SIMDE_MATH_BUILTIN_LIBM(truncf) |
| #define simde_math_truncf(v) __builtin_truncf(v) |
| #elif defined(SIMDE_MATH_HAVE_CMATH) |
| #define simde_math_truncf(v) std::trunc(v) |
| #elif defined(SIMDE_MATH_HAVE_MATH_H) |
| #define simde_math_truncf(v) truncf(v) |
| #endif |
| #endif |
| |
| /*** Comparison macros (which don't raise invalid errors) ***/ |
| |
| #if defined(isunordered) |
| #define simde_math_isunordered(x, y) isunordered(x, y) |
| #elif HEDLEY_HAS_BUILTIN(__builtin_isunordered) |
| #define simde_math_isunordered(x, y) __builtin_isunordered(x, y) |
| #else |
| static HEDLEY_INLINE |
| int simde_math_isunordered(double x, double y) { |
| return (x != y) && (x != x || y != y); |
| } |
| #define simde_math_isunordered simde_math_isunordered |
| |
| static HEDLEY_INLINE |
| int simde_math_isunorderedf(float x, float y) { |
| return (x != y) && (x != x || y != y); |
| } |
| #define simde_math_isunorderedf simde_math_isunorderedf |
| #endif |
| #if !defined(simde_math_isunorderedf) |
| #define simde_math_isunorderedf simde_math_isunordered |
| #endif |
| |
| /*** Additional functions not in libm ***/ |
| |
| #if defined(simde_math_fabs) && defined(simde_math_sqrt) && defined(simde_math_exp) |
| static HEDLEY_INLINE |
| double |
| simde_math_cdfnorm(double x) { |
| /* https://www.johndcook.com/blog/cpp_phi/ |
| * Public Domain */ |
| static const double a1 = 0.254829592; |
| static const double a2 = -0.284496736; |
| static const double a3 = 1.421413741; |
| static const double a4 = -1.453152027; |
| static const double a5 = 1.061405429; |
| static const double p = 0.3275911; |
| |
| const int sign = x < 0; |
| x = simde_math_fabs(x) / simde_math_sqrt(2.0); |
| |
| /* A&S formula 7.1.26 */ |
| double t = 1.0 / (1.0 + p * x); |
| double y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * simde_math_exp(-x * x); |
| |
| return 0.5 * (1.0 + (sign ? -y : y)); |
| } |
| #define simde_math_cdfnorm simde_math_cdfnorm |
| #endif |
| |
| #if defined(simde_math_fabsf) && defined(simde_math_sqrtf) && defined(simde_math_expf) |
| static HEDLEY_INLINE |
| float |
| simde_math_cdfnormf(float x) { |
| /* https://www.johndcook.com/blog/cpp_phi/ |
| * Public Domain */ |
| static const float a1 = 0.254829592f; |
| static const float a2 = -0.284496736f; |
| static const float a3 = 1.421413741f; |
| static const float a4 = -1.453152027f; |
| static const float a5 = 1.061405429f; |
| static const float p = 0.3275911f; |
| |
| const int sign = x < 0; |
| x = simde_math_fabsf(x) / simde_math_sqrtf(2.0f); |
| |
| /* A&S formula 7.1.26 */ |
| float t = 1.0f / (1.0f + p * x); |
| float y = 1.0f - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * simde_math_expf(-x * x); |
| |
| return 0.5f * (1.0f + (sign ? -y : y)); |
| } |
| #define simde_math_cdfnormf simde_math_cdfnormf |
| #endif |
| |
| #if !defined(simde_math_cdfnorminv) && defined(simde_math_log) && defined(simde_math_sqrt) |
| /*https://web.archive.org/web/20150910081113/http://home.online.no/~pjacklam/notes/invnorm/impl/sprouse/ltqnorm.c*/ |
| static HEDLEY_INLINE |
| double |
| simde_math_cdfnorminv(double p) { |
| static const double a[6] = { |
| -3.969683028665376e+01, |
| 2.209460984245205e+02, |
| -2.759285104469687e+02, |
| 1.383577518672690e+02, |
| -3.066479806614716e+01, |
| 2.506628277459239e+00 |
| }; |
| |
| static const double b[5] = { |
| -5.447609879822406e+01, |
| 1.615858368580409e+02, |
| -1.556989798598866e+02, |
| 6.680131188771972e+01, |
| -1.328068155288572e+01 |
| }; |
| |
| static const double c[6] = { |
| -7.784894002430293e-03, |
| -3.223964580411365e-01, |
| -2.400758277161838e+00, |
| -2.549732539343734e+00, |
| 4.374664141464968e+00, |
| 2.938163982698783e+00 |
| }; |
| |
| static const double d[4] = { |
| 7.784695709041462e-03, |
| 3.224671290700398e-01, |
| 2.445134137142996e+00, |
| 3.754408661907416e+00 |
| }; |
| |
| static const double low = 0.02425; |
| static const double high = 0.97575; |
| double q, r; |
| |
| if (p < 0 || p > 1) { |
| return 0.0; |
| } else if (p == 0) { |
| return -SIMDE_MATH_INFINITY; |
| } else if (p == 1) { |
| return SIMDE_MATH_INFINITY; |
| } else if (p < low) { |
| q = simde_math_sqrt(-2.0 * simde_math_log(p)); |
| return |
| (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / |
| (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); |
| } else if (p > high) { |
| q = simde_math_sqrt(-2.0 * simde_math_log(1.0 - p)); |
| return |
| -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / |
| (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); |
| } else { |
| q = p - 0.5; |
| r = q * q; |
| return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * |
| q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1); |
| } |
| } |
| #define simde_math_cdfnorminv simde_math_cdfnorminv |
| #endif |
| |
| #if !defined(simde_math_cdfnorminvf) && defined(simde_math_logf) && defined(simde_math_sqrtf) |
| static HEDLEY_INLINE |
| float |
| simde_math_cdfnorminvf(float p) { |
| static const float a[6] = { |
| -3.969683028665376e+01f, |
| 2.209460984245205e+02f, |
| -2.759285104469687e+02f, |
| 1.383577518672690e+02f, |
| -3.066479806614716e+01f, |
| 2.506628277459239e+00f |
| }; |
| static const float b[5] = { |
| -5.447609879822406e+01f, |
| 1.615858368580409e+02f, |
| -1.556989798598866e+02f, |
| 6.680131188771972e+01f, |
| -1.328068155288572e+01f |
| }; |
| static const float c[6] = { |
| -7.784894002430293e-03f, |
| -3.223964580411365e-01f, |
| -2.400758277161838e+00f, |
| -2.549732539343734e+00f, |
| 4.374664141464968e+00f, |
| 2.938163982698783e+00f |
| }; |
| static const float d[4] = { |
| 7.784695709041462e-03f, |
| 3.224671290700398e-01f, |
| 2.445134137142996e+00f, |
| 3.754408661907416e+00f |
| }; |
| static const float low = 0.02425f; |
| static const float high = 0.97575f; |
| float q, r; |
| |
| if (p < 0 || p > 1) { |
| return 0.0f; |
| } else if (p == 0) { |
| return -SIMDE_MATH_INFINITYF; |
| } else if (p == 1) { |
| return SIMDE_MATH_INFINITYF; |
| } else if (p < low) { |
| q = simde_math_sqrtf(-2.0f * simde_math_logf(p)); |
| return |
| (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / |
| (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); |
| } else if (p > high) { |
| q = simde_math_sqrtf(-2.0f * simde_math_logf(1.0f - p)); |
| return |
| -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / |
| (((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)); |
| } else { |
| q = p - 0.5f; |
| r = q * q; |
| return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * |
| q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1); |
| } |
| } |
| #define simde_math_cdfnorminvf simde_math_cdfnorminvf |
| #endif |
| |
| #if !defined(simde_math_erfinv) && defined(simde_math_log) && defined(simde_math_copysign) && defined(simde_math_sqrt) |
| static HEDLEY_INLINE |
| double |
| simde_math_erfinv(double x) { |
| /* https://stackoverflow.com/questions/27229371/inverse-error-function-in-c |
| * |
| * The original answer on SO uses a constant of 0.147, but in my |
| * testing 0.14829094707965850830078125 gives a lower average absolute error |
| * (0.0001410958211636170744895935 vs. 0.0001465479290345683693885803). |
| * That said, if your goal is to minimize the *maximum* absolute |
| * error, 0.15449436008930206298828125 provides significantly better |
| * results; 0.0009250640869140625000000000 vs ~ 0.005. */ |
| double tt1, tt2, lnx; |
| double sgn = simde_math_copysign(1.0, x); |
| |
| x = (1.0 - x) * (1.0 + x); |
| lnx = simde_math_log(x); |
| |
| tt1 = 2.0 / (SIMDE_MATH_PI * 0.14829094707965850830078125) + 0.5 * lnx; |
| tt2 = (1.0 / 0.14829094707965850830078125) * lnx; |
| |
| return sgn * simde_math_sqrt(-tt1 + simde_math_sqrt(tt1 * tt1 - tt2)); |
| } |
| #define simde_math_erfinv simde_math_erfinv |
| #endif |
| |
| #if !defined(simde_math_erfinvf) && defined(simde_math_logf) && defined(simde_math_copysignf) && defined(simde_math_sqrtf) |
| static HEDLEY_INLINE |
| float |
| simde_math_erfinvf(float x) { |
| float tt1, tt2, lnx; |
| float sgn = simde_math_copysignf(1.0f, x); |
| |
| x = (1.0f - x) * (1.0f + x); |
| lnx = simde_math_logf(x); |
| |
| tt1 = 2.0f / (SIMDE_MATH_PIF * 0.14829094707965850830078125f) + 0.5f * lnx; |
| tt2 = (1.0f / 0.14829094707965850830078125f) * lnx; |
| |
| return sgn * simde_math_sqrtf(-tt1 + simde_math_sqrtf(tt1 * tt1 - tt2)); |
| } |
| #define simde_math_erfinvf simde_math_erfinvf |
| #endif |
| |
| #if !defined(simde_math_erfcinv) && defined(simde_math_erfinv) && defined(simde_math_log) && defined(simde_math_sqrt) |
| static HEDLEY_INLINE |
| double |
| simde_math_erfcinv(double x) { |
| if(x >= 0.0625 && x < 2.0) { |
| return simde_math_erfinv(1.0 - x); |
| } else if (x < 0.0625 && x >= 1.0e-100) { |
| static const double p[6] = { |
| 0.1550470003116, |
| 1.382719649631, |
| 0.690969348887, |
| -1.128081391617, |
| 0.680544246825, |
| -0.16444156791 |
| }; |
| static const double q[3] = { |
| 0.155024849822, |
| 1.385228141995, |
| 1.000000000000 |
| }; |
| |
| const double t = 1.0 / simde_math_sqrt(-simde_math_log(x)); |
| return (p[0] / t + p[1] + t * (p[2] + t * (p[3] + t * (p[4] + t * p[5])))) / |
| (q[0] + t * (q[1] + t * (q[2]))); |
| } else if (x < 1.0e-100 && x >= SIMDE_MATH_DBL_MIN) { |
| static const double p[4] = { |
| 0.00980456202915, |
| 0.363667889171, |
| 0.97302949837, |
| -0.5374947401 |
| }; |
| static const double q[3] = { |
| 0.00980451277802, |
| 0.363699971544, |
| 1.000000000000 |
| }; |
| |
| const double t = 1.0 / simde_math_sqrt(-simde_math_log(x)); |
| return (p[0] / t + p[1] + t * (p[2] + t * p[3])) / |
| (q[0] + t * (q[1] + t * (q[2]))); |
| } else if (!simde_math_isnormal(x)) { |
| return SIMDE_MATH_INFINITY; |
| } else { |
| return -SIMDE_MATH_INFINITY; |
| } |
| } |
| |
| #define simde_math_erfcinv simde_math_erfcinv |
| #endif |
| |
| #if !defined(simde_math_erfcinvf) && defined(simde_math_erfinvf) && defined(simde_math_logf) && defined(simde_math_sqrtf) |
| static HEDLEY_INLINE |
| float |
| simde_math_erfcinvf(float x) { |
| if(x >= 0.0625f && x < 2.0f) { |
| return simde_math_erfinvf(1.0f - x); |
| } else if (x < 0.0625f && x >= SIMDE_MATH_FLT_MIN) { |
| static const float p[6] = { |
| 0.1550470003116f, |
| 1.382719649631f, |
| 0.690969348887f, |
| -1.128081391617f, |
| 0.680544246825f, |
| -0.164441567910f |
| }; |
| static const float q[3] = { |
| 0.155024849822f, |
| 1.385228141995f, |
| 1.000000000000f |
| }; |
| |
| const float t = 1.0f / simde_math_sqrtf(-simde_math_logf(x)); |
| return (p[0] / t + p[1] + t * (p[2] + t * (p[3] + t * (p[4] + t * p[5])))) / |
| (q[0] + t * (q[1] + t * (q[2]))); |
| } else if (x < SIMDE_MATH_FLT_MIN && simde_math_isnormalf(x)) { |
| static const float p[4] = { |
| 0.00980456202915f, |
| 0.36366788917100f, |
| 0.97302949837000f, |
| -0.5374947401000f |
| }; |
| static const float q[3] = { |
| 0.00980451277802f, |
| 0.36369997154400f, |
| 1.00000000000000f |
| }; |
| |
| const float t = 1.0f / simde_math_sqrtf(-simde_math_logf(x)); |
| return (p[0] / t + p[1] + t * (p[2] + t * p[3])) / |
| (q[0] + t * (q[1] + t * (q[2]))); |
| } else { |
| return simde_math_isnormalf(x) ? -SIMDE_MATH_INFINITYF : SIMDE_MATH_INFINITYF; |
| } |
| } |
| |
| #define simde_math_erfcinvf simde_math_erfcinvf |
| #endif |
| |
| static HEDLEY_INLINE |
| double |
| simde_math_rad2deg(double radians) { |
| return radians * SIMDE_MATH_180_OVER_PI; |
| } |
| |
| static HEDLEY_INLINE |
| float |
| simde_math_rad2degf(float radians) { |
| return radians * SIMDE_MATH_180_OVER_PIF; |
| } |
| |
| static HEDLEY_INLINE |
| double |
| simde_math_deg2rad(double degrees) { |
| return degrees * SIMDE_MATH_PI_OVER_180; |
| } |
| |
| static HEDLEY_INLINE |
| float |
| simde_math_deg2radf(float degrees) { |
| return degrees * (SIMDE_MATH_PI_OVER_180F); |
| } |
| |
| /*** Saturated arithmetic ***/ |
| |
| static HEDLEY_INLINE |
| int8_t |
| simde_math_adds_i8(int8_t a, int8_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddb_s8(a, b); |
| #else |
| uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a); |
| uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b); |
| uint8_t r_ = a_ + b_; |
| |
| a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT8_MAX; |
| if (HEDLEY_STATIC_CAST(int8_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int8_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int16_t |
| simde_math_adds_i16(int16_t a, int16_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddh_s16(a, b); |
| #else |
| uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a); |
| uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b); |
| uint16_t r_ = a_ + b_; |
| |
| a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT16_MAX; |
| if (HEDLEY_STATIC_CAST(int16_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int16_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int32_t |
| simde_math_adds_i32(int32_t a, int32_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqadds_s32(a, b); |
| #else |
| uint32_t a_ = HEDLEY_STATIC_CAST(uint32_t, a); |
| uint32_t b_ = HEDLEY_STATIC_CAST(uint32_t, b); |
| uint32_t r_ = a_ + b_; |
| |
| a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT32_MAX; |
| if (HEDLEY_STATIC_CAST(int32_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int32_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int64_t |
| simde_math_adds_i64(int64_t a, int64_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddd_s64(a, b); |
| #else |
| uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a); |
| uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b); |
| uint64_t r_ = a_ + b_; |
| |
| a_ = (a_ >> ((8 * sizeof(r_)) - 1)) + INT64_MAX; |
| if (HEDLEY_STATIC_CAST(int64_t, ((a_ ^ b_) | ~(b_ ^ r_))) >= 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int64_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint8_t |
| simde_math_adds_u8(uint8_t a, uint8_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddb_u8(a, b); |
| #else |
| uint8_t r = a + b; |
| r |= -(r < a); |
| return r; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint16_t |
| simde_math_adds_u16(uint16_t a, uint16_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddh_u16(a, b); |
| #else |
| uint16_t r = a + b; |
| r |= -(r < a); |
| return r; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint32_t |
| simde_math_adds_u32(uint32_t a, uint32_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqadds_u32(a, b); |
| #else |
| uint32_t r = a + b; |
| r |= HEDLEY_STATIC_CAST(uint32_t, -(r < a)); |
| return r; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint64_t |
| simde_math_adds_u64(uint64_t a, uint64_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqaddd_u64(a, b); |
| #else |
| uint64_t r = a + b; |
| r |= HEDLEY_STATIC_CAST(uint64_t, -(r < a)); |
| return r; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int8_t |
| simde_math_subs_i8(int8_t a, int8_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubb_s8(a, b); |
| #else |
| uint8_t a_ = HEDLEY_STATIC_CAST(uint8_t, a); |
| uint8_t b_ = HEDLEY_STATIC_CAST(uint8_t, b); |
| uint8_t r_ = a_ - b_; |
| |
| a_ = (a_ >> 7) + INT8_MAX; |
| |
| if (HEDLEY_STATIC_CAST(int8_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int8_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int16_t |
| simde_math_subs_i16(int16_t a, int16_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubh_s16(a, b); |
| #else |
| uint16_t a_ = HEDLEY_STATIC_CAST(uint16_t, a); |
| uint16_t b_ = HEDLEY_STATIC_CAST(uint16_t, b); |
| uint16_t r_ = a_ - b_; |
| |
| a_ = (a_ >> 15) + INT16_MAX; |
| |
| if (HEDLEY_STATIC_CAST(int16_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int16_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int32_t |
| simde_math_subs_i32(int32_t a, int32_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubs_s32(a, b); |
| #else |
| uint32_t a_ = HEDLEY_STATIC_CAST(uint32_t, a); |
| uint32_t b_ = HEDLEY_STATIC_CAST(uint32_t, b); |
| uint32_t r_ = a_ - b_; |
| |
| a_ = (a_ >> 31) + INT32_MAX; |
| |
| if (HEDLEY_STATIC_CAST(int32_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int32_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| int64_t |
| simde_math_subs_i64(int64_t a, int64_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubd_s64(a, b); |
| #else |
| uint64_t a_ = HEDLEY_STATIC_CAST(uint64_t, a); |
| uint64_t b_ = HEDLEY_STATIC_CAST(uint64_t, b); |
| uint64_t r_ = a_ - b_; |
| |
| a_ = (a_ >> 63) + INT64_MAX; |
| |
| if (HEDLEY_STATIC_CAST(int64_t, (a_ ^ b_) & (a_ ^ r_)) < 0) { |
| r_ = a_; |
| } |
| |
| return HEDLEY_STATIC_CAST(int64_t, r_); |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint8_t |
| simde_math_subs_u8(uint8_t a, uint8_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubb_u8(a, b); |
| #else |
| uint8_t res = a - b; |
| res &= -(res <= a); |
| return res; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint16_t |
| simde_math_subs_u16(uint16_t a, uint16_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubh_u16(a, b); |
| #else |
| uint16_t res = a - b; |
| res &= -(res <= a); |
| return res; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint32_t |
| simde_math_subs_u32(uint32_t a, uint32_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubs_u32(a, b); |
| #else |
| uint32_t res = a - b; |
| res &= HEDLEY_STATIC_CAST(uint32_t, -(res <= a)); |
| return res; |
| #endif |
| } |
| |
| static HEDLEY_INLINE |
| uint64_t |
| simde_math_subs_u64(uint64_t a, uint64_t b) { |
| #if defined(SIMDE_ARM_NEON_A64V8_NATIVE) |
| return vqsubd_u64(a, b); |
| #else |
| uint64_t res = a - b; |
| res &= HEDLEY_STATIC_CAST(uint64_t, -(res <= a)); |
| return res; |
| #endif |
| } |
| |
| HEDLEY_DIAGNOSTIC_POP |
| |
| #endif /* !defined(SIMDE_MATH_H) */ |
