math.h (313215B) - Raw
1 /*! @header 2 * The interfaces declared in this header provide elementwise math operations 3 * on vectors; each lane of the result vector depends only on the data in the 4 * corresponding lane of the argument(s) to the function. 5 * 6 * You should not use the C functions declared in this header directly (these 7 * are functions with names like `__tg_cos(x)`). These are merely 8 * implementation details of <tgmath.h> overloading; instead of calling 9 * `__tg_cos(x)`, call `cos(x)`. If you are writing C++, use `simd::cos(x)`. 10 * 11 * Note that while these vector functions are relatively recent additions, 12 * scalar fallback is provided for all of them, so they are available even 13 * when targeting older OS versions. 14 * 15 * The following functions are available: 16 * 17 * C name C++ name Notes 18 * ---------------------------------------------------------------------- 19 * acos(x) simd::acos(x) 20 * asin(x) simd::asin(x) 21 * atan(x) simd::atan(x) 22 * atan2(y,x) simd::atan2(y,x) The argument order matches the scalar 23 * atan2 function, which gives the angle 24 * of a line with slope y/x. 25 * cos(x) simd::cos(x) 26 * sin(x) simd::sin(x) 27 * tan(x) simd::tan(x) 28 * sincos(x) simd::sincos(x) Computes sin(x) and cos(x) more efficiently 29 * 30 * cospi(x) simd::cospi(x) Returns cos(pi*x), sin(pi*x), tan(pi*x) 31 * sinpi(x) simd::sinpi(x) more efficiently and accurately than 32 * tanpi(x) simd::tanpi(x) would otherwise be possible 33 * sincospi(x) simd::sincospi(x) Computes sin(pi*x) and cos(pi*x) more efficiently 34 * 35 * acosh(x) simd::acosh(x) 36 * asinh(x) simd::asinh(x) 37 * atanh(x) simd::atanh(x) 38 * 39 * cosh(x) simd::cosh(x) 40 * sinh(x) simd::sinh(x) 41 * tanh(x) simd::tanh(x) 42 * 43 * exp(x) simd::exp(x) 44 * exp2(x) simd::exp2(x) 45 * exp10(x) simd::exp10(x) More efficient that pow(10,x). 46 * expm1(x) simd::expm1(x) exp(x)-1, accurate even for tiny x. 47 * 48 * log(x) simd::log(x) 49 * log2(x) simd::log2(x) 50 * log10(x) simd::log10(x) 51 * log1p(x) simd::log1p(x) log(1+x), accurate even for tiny x. 52 * 53 * fabs(x) simd::fabs(x) 54 * cbrt(x) simd::cbrt(x) 55 * sqrt(x) simd::sqrt(x) 56 * pow(x,y) simd::pow(x,y) 57 * copysign(x,y) simd::copysign(x,y) 58 * hypot(x,y) simd::hypot(x,y) sqrt(x*x + y*y), computed without 59 * overflow.1 60 * erf(x) simd::erf(x) 61 * erfc(x) simd::erfc(x) 62 * tgamma(x) simd::tgamma(x) 63 * lgamma(x) simd::lgamma(x) 64 * 65 * fmod(x,y) simd::fmod(x,y) 66 * remainder(x,y) simd::remainder(x,y) 67 * 68 * ceil(x) simd::ceil(x) 69 * floor(x) simd::floor(x) 70 * rint(x) simd::rint(x) 71 * round(x) simd::round(x) 72 * trunc(x) simd::trunc(x) 73 * 74 * fdim(x,y) simd::fdim(x,y) 75 * fmax(x,y) simd::fmax(x,y) When one argument to fmin or fmax is 76 * fmin(x,y) simd::fmin(x,y) constant, use it as the *second* (y) 77 * argument to get better codegen on some 78 * architectures. E.g., write fmin(x,2) 79 * instead of fmin(2,x). 80 * fma(x,y,z) simd::fma(x,y,z) Fast on arm64 and when targeting AVX2 81 * and later; may be quite expensive on 82 * older hardware. 83 * simd_muladd(x,y,z) simd::muladd(x,y,z) 84 * @copyright 2014-2017 Apple, Inc. All rights reserved. 85 * @unsorted */ 86 87 #ifndef SIMD_MATH_HEADER 88 #define SIMD_MATH_HEADER 89 90 #include <simd/base.h> 91 #if SIMD_COMPILER_HAS_REQUIRED_FEATURES 92 #include <simd/vector_make.h> 93 #include <simd/logic.h> 94 95 #ifdef __cplusplus 96 extern "C" { 97 #endif 98 /*! @abstract Do not call this function; instead use `acos` in C and 99 * Objective-C, and `simd::acos` in C++. */ 100 static inline SIMD_CFUNC simd_float2 __tg_acos(simd_float2 x); 101 /*! @abstract Do not call this function; instead use `acos` in C and 102 * Objective-C, and `simd::acos` in C++. */ 103 static inline SIMD_CFUNC simd_float3 __tg_acos(simd_float3 x); 104 /*! @abstract Do not call this function; instead use `acos` in C and 105 * Objective-C, and `simd::acos` in C++. */ 106 static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x); 107 /*! @abstract Do not call this function; instead use `acos` in C and 108 * Objective-C, and `simd::acos` in C++. */ 109 static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x); 110 /*! @abstract Do not call this function; instead use `acos` in C and 111 * Objective-C, and `simd::acos` in C++. */ 112 static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x); 113 /*! @abstract Do not call this function; instead use `acos` in C and 114 * Objective-C, and `simd::acos` in C++. */ 115 static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x); 116 /*! @abstract Do not call this function; instead use `acos` in C and 117 * Objective-C, and `simd::acos` in C++. */ 118 static inline SIMD_CFUNC simd_double3 __tg_acos(simd_double3 x); 119 /*! @abstract Do not call this function; instead use `acos` in C and 120 * Objective-C, and `simd::acos` in C++. */ 121 static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x); 122 /*! @abstract Do not call this function; instead use `acos` in C and 123 * Objective-C, and `simd::acos` in C++. */ 124 static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x); 125 126 /*! @abstract Do not call this function; instead use `asin` in C and 127 * Objective-C, and `simd::asin` in C++. */ 128 static inline SIMD_CFUNC simd_float2 __tg_asin(simd_float2 x); 129 /*! @abstract Do not call this function; instead use `asin` in C and 130 * Objective-C, and `simd::asin` in C++. */ 131 static inline SIMD_CFUNC simd_float3 __tg_asin(simd_float3 x); 132 /*! @abstract Do not call this function; instead use `asin` in C and 133 * Objective-C, and `simd::asin` in C++. */ 134 static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x); 135 /*! @abstract Do not call this function; instead use `asin` in C and 136 * Objective-C, and `simd::asin` in C++. */ 137 static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x); 138 /*! @abstract Do not call this function; instead use `asin` in C and 139 * Objective-C, and `simd::asin` in C++. */ 140 static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x); 141 /*! @abstract Do not call this function; instead use `asin` in C and 142 * Objective-C, and `simd::asin` in C++. */ 143 static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x); 144 /*! @abstract Do not call this function; instead use `asin` in C and 145 * Objective-C, and `simd::asin` in C++. */ 146 static inline SIMD_CFUNC simd_double3 __tg_asin(simd_double3 x); 147 /*! @abstract Do not call this function; instead use `asin` in C and 148 * Objective-C, and `simd::asin` in C++. */ 149 static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x); 150 /*! @abstract Do not call this function; instead use `asin` in C and 151 * Objective-C, and `simd::asin` in C++. */ 152 static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x); 153 154 /*! @abstract Do not call this function; instead use `atan` in C and 155 * Objective-C, and `simd::atan` in C++. */ 156 static inline SIMD_CFUNC simd_float2 __tg_atan(simd_float2 x); 157 /*! @abstract Do not call this function; instead use `atan` in C and 158 * Objective-C, and `simd::atan` in C++. */ 159 static inline SIMD_CFUNC simd_float3 __tg_atan(simd_float3 x); 160 /*! @abstract Do not call this function; instead use `atan` in C and 161 * Objective-C, and `simd::atan` in C++. */ 162 static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x); 163 /*! @abstract Do not call this function; instead use `atan` in C and 164 * Objective-C, and `simd::atan` in C++. */ 165 static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x); 166 /*! @abstract Do not call this function; instead use `atan` in C and 167 * Objective-C, and `simd::atan` in C++. */ 168 static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x); 169 /*! @abstract Do not call this function; instead use `atan` in C and 170 * Objective-C, and `simd::atan` in C++. */ 171 static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x); 172 /*! @abstract Do not call this function; instead use `atan` in C and 173 * Objective-C, and `simd::atan` in C++. */ 174 static inline SIMD_CFUNC simd_double3 __tg_atan(simd_double3 x); 175 /*! @abstract Do not call this function; instead use `atan` in C and 176 * Objective-C, and `simd::atan` in C++. */ 177 static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x); 178 /*! @abstract Do not call this function; instead use `atan` in C and 179 * Objective-C, and `simd::atan` in C++. */ 180 static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x); 181 182 /*! @abstract Do not call this function; instead use `cos` in C and 183 * Objective-C, and `simd::cos` in C++. */ 184 static inline SIMD_CFUNC simd_float2 __tg_cos(simd_float2 x); 185 /*! @abstract Do not call this function; instead use `cos` in C and 186 * Objective-C, and `simd::cos` in C++. */ 187 static inline SIMD_CFUNC simd_float3 __tg_cos(simd_float3 x); 188 /*! @abstract Do not call this function; instead use `cos` in C and 189 * Objective-C, and `simd::cos` in C++. */ 190 static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x); 191 /*! @abstract Do not call this function; instead use `cos` in C and 192 * Objective-C, and `simd::cos` in C++. */ 193 static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x); 194 /*! @abstract Do not call this function; instead use `cos` in C and 195 * Objective-C, and `simd::cos` in C++. */ 196 static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x); 197 /*! @abstract Do not call this function; instead use `cos` in C and 198 * Objective-C, and `simd::cos` in C++. */ 199 static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x); 200 /*! @abstract Do not call this function; instead use `cos` in C and 201 * Objective-C, and `simd::cos` in C++. */ 202 static inline SIMD_CFUNC simd_double3 __tg_cos(simd_double3 x); 203 /*! @abstract Do not call this function; instead use `cos` in C and 204 * Objective-C, and `simd::cos` in C++. */ 205 static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x); 206 /*! @abstract Do not call this function; instead use `cos` in C and 207 * Objective-C, and `simd::cos` in C++. */ 208 static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x); 209 210 /*! @abstract Do not call this function; instead use `sin` in C and 211 * Objective-C, and `simd::sin` in C++. */ 212 static inline SIMD_CFUNC simd_float2 __tg_sin(simd_float2 x); 213 /*! @abstract Do not call this function; instead use `sin` in C and 214 * Objective-C, and `simd::sin` in C++. */ 215 static inline SIMD_CFUNC simd_float3 __tg_sin(simd_float3 x); 216 /*! @abstract Do not call this function; instead use `sin` in C and 217 * Objective-C, and `simd::sin` in C++. */ 218 static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x); 219 /*! @abstract Do not call this function; instead use `sin` in C and 220 * Objective-C, and `simd::sin` in C++. */ 221 static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x); 222 /*! @abstract Do not call this function; instead use `sin` in C and 223 * Objective-C, and `simd::sin` in C++. */ 224 static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x); 225 /*! @abstract Do not call this function; instead use `sin` in C and 226 * Objective-C, and `simd::sin` in C++. */ 227 static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x); 228 /*! @abstract Do not call this function; instead use `sin` in C and 229 * Objective-C, and `simd::sin` in C++. */ 230 static inline SIMD_CFUNC simd_double3 __tg_sin(simd_double3 x); 231 /*! @abstract Do not call this function; instead use `sin` in C and 232 * Objective-C, and `simd::sin` in C++. */ 233 static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x); 234 /*! @abstract Do not call this function; instead use `sin` in C and 235 * Objective-C, and `simd::sin` in C++. */ 236 static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x); 237 238 /*! @abstract Do not call this function; instead use `tan` in C and 239 * Objective-C, and `simd::tan` in C++. */ 240 static inline SIMD_CFUNC simd_float2 __tg_tan(simd_float2 x); 241 /*! @abstract Do not call this function; instead use `tan` in C and 242 * Objective-C, and `simd::tan` in C++. */ 243 static inline SIMD_CFUNC simd_float3 __tg_tan(simd_float3 x); 244 /*! @abstract Do not call this function; instead use `tan` in C and 245 * Objective-C, and `simd::tan` in C++. */ 246 static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x); 247 /*! @abstract Do not call this function; instead use `tan` in C and 248 * Objective-C, and `simd::tan` in C++. */ 249 static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x); 250 /*! @abstract Do not call this function; instead use `tan` in C and 251 * Objective-C, and `simd::tan` in C++. */ 252 static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x); 253 /*! @abstract Do not call this function; instead use `tan` in C and 254 * Objective-C, and `simd::tan` in C++. */ 255 static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x); 256 /*! @abstract Do not call this function; instead use `tan` in C and 257 * Objective-C, and `simd::tan` in C++. */ 258 static inline SIMD_CFUNC simd_double3 __tg_tan(simd_double3 x); 259 /*! @abstract Do not call this function; instead use `tan` in C and 260 * Objective-C, and `simd::tan` in C++. */ 261 static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x); 262 /*! @abstract Do not call this function; instead use `tan` in C and 263 * Objective-C, and `simd::tan` in C++. */ 264 static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x); 265 266 #if SIMD_LIBRARY_VERSION >= 1 267 /*! @abstract Do not call this function; instead use `cospi` in C and 268 * Objective-C, and `simd::cospi` in C++. */ 269 static inline SIMD_CFUNC simd_float2 __tg_cospi(simd_float2 x); 270 /*! @abstract Do not call this function; instead use `cospi` in C and 271 * Objective-C, and `simd::cospi` in C++. */ 272 static inline SIMD_CFUNC simd_float3 __tg_cospi(simd_float3 x); 273 /*! @abstract Do not call this function; instead use `cospi` in C and 274 * Objective-C, and `simd::cospi` in C++. */ 275 static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x); 276 /*! @abstract Do not call this function; instead use `cospi` in C and 277 * Objective-C, and `simd::cospi` in C++. */ 278 static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x); 279 /*! @abstract Do not call this function; instead use `cospi` in C and 280 * Objective-C, and `simd::cospi` in C++. */ 281 static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x); 282 /*! @abstract Do not call this function; instead use `cospi` in C and 283 * Objective-C, and `simd::cospi` in C++. */ 284 static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x); 285 /*! @abstract Do not call this function; instead use `cospi` in C and 286 * Objective-C, and `simd::cospi` in C++. */ 287 static inline SIMD_CFUNC simd_double3 __tg_cospi(simd_double3 x); 288 /*! @abstract Do not call this function; instead use `cospi` in C and 289 * Objective-C, and `simd::cospi` in C++. */ 290 static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x); 291 /*! @abstract Do not call this function; instead use `cospi` in C and 292 * Objective-C, and `simd::cospi` in C++. */ 293 static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x); 294 #endif 295 296 #if SIMD_LIBRARY_VERSION >= 1 297 /*! @abstract Do not call this function; instead use `sinpi` in C and 298 * Objective-C, and `simd::sinpi` in C++. */ 299 static inline SIMD_CFUNC simd_float2 __tg_sinpi(simd_float2 x); 300 /*! @abstract Do not call this function; instead use `sinpi` in C and 301 * Objective-C, and `simd::sinpi` in C++. */ 302 static inline SIMD_CFUNC simd_float3 __tg_sinpi(simd_float3 x); 303 /*! @abstract Do not call this function; instead use `sinpi` in C and 304 * Objective-C, and `simd::sinpi` in C++. */ 305 static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x); 306 /*! @abstract Do not call this function; instead use `sinpi` in C and 307 * Objective-C, and `simd::sinpi` in C++. */ 308 static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x); 309 /*! @abstract Do not call this function; instead use `sinpi` in C and 310 * Objective-C, and `simd::sinpi` in C++. */ 311 static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x); 312 /*! @abstract Do not call this function; instead use `sinpi` in C and 313 * Objective-C, and `simd::sinpi` in C++. */ 314 static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x); 315 /*! @abstract Do not call this function; instead use `sinpi` in C and 316 * Objective-C, and `simd::sinpi` in C++. */ 317 static inline SIMD_CFUNC simd_double3 __tg_sinpi(simd_double3 x); 318 /*! @abstract Do not call this function; instead use `sinpi` in C and 319 * Objective-C, and `simd::sinpi` in C++. */ 320 static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x); 321 /*! @abstract Do not call this function; instead use `sinpi` in C and 322 * Objective-C, and `simd::sinpi` in C++. */ 323 static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x); 324 #endif 325 326 #if SIMD_LIBRARY_VERSION >= 1 327 /*! @abstract Do not call this function; instead use `tanpi` in C and 328 * Objective-C, and `simd::tanpi` in C++. */ 329 static inline SIMD_CFUNC simd_float2 __tg_tanpi(simd_float2 x); 330 /*! @abstract Do not call this function; instead use `tanpi` in C and 331 * Objective-C, and `simd::tanpi` in C++. */ 332 static inline SIMD_CFUNC simd_float3 __tg_tanpi(simd_float3 x); 333 /*! @abstract Do not call this function; instead use `tanpi` in C and 334 * Objective-C, and `simd::tanpi` in C++. */ 335 static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x); 336 /*! @abstract Do not call this function; instead use `tanpi` in C and 337 * Objective-C, and `simd::tanpi` in C++. */ 338 static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x); 339 /*! @abstract Do not call this function; instead use `tanpi` in C and 340 * Objective-C, and `simd::tanpi` in C++. */ 341 static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x); 342 /*! @abstract Do not call this function; instead use `tanpi` in C and 343 * Objective-C, and `simd::tanpi` in C++. */ 344 static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x); 345 /*! @abstract Do not call this function; instead use `tanpi` in C and 346 * Objective-C, and `simd::tanpi` in C++. */ 347 static inline SIMD_CFUNC simd_double3 __tg_tanpi(simd_double3 x); 348 /*! @abstract Do not call this function; instead use `tanpi` in C and 349 * Objective-C, and `simd::tanpi` in C++. */ 350 static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x); 351 /*! @abstract Do not call this function; instead use `tanpi` in C and 352 * Objective-C, and `simd::tanpi` in C++. */ 353 static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x); 354 #endif 355 356 /*! @abstract Do not call this function; instead use `acosh` in C and 357 * Objective-C, and `simd::acosh` in C++. */ 358 static inline SIMD_CFUNC simd_float2 __tg_acosh(simd_float2 x); 359 /*! @abstract Do not call this function; instead use `acosh` in C and 360 * Objective-C, and `simd::acosh` in C++. */ 361 static inline SIMD_CFUNC simd_float3 __tg_acosh(simd_float3 x); 362 /*! @abstract Do not call this function; instead use `acosh` in C and 363 * Objective-C, and `simd::acosh` in C++. */ 364 static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x); 365 /*! @abstract Do not call this function; instead use `acosh` in C and 366 * Objective-C, and `simd::acosh` in C++. */ 367 static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x); 368 /*! @abstract Do not call this function; instead use `acosh` in C and 369 * Objective-C, and `simd::acosh` in C++. */ 370 static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x); 371 /*! @abstract Do not call this function; instead use `acosh` in C and 372 * Objective-C, and `simd::acosh` in C++. */ 373 static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x); 374 /*! @abstract Do not call this function; instead use `acosh` in C and 375 * Objective-C, and `simd::acosh` in C++. */ 376 static inline SIMD_CFUNC simd_double3 __tg_acosh(simd_double3 x); 377 /*! @abstract Do not call this function; instead use `acosh` in C and 378 * Objective-C, and `simd::acosh` in C++. */ 379 static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x); 380 /*! @abstract Do not call this function; instead use `acosh` in C and 381 * Objective-C, and `simd::acosh` in C++. */ 382 static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x); 383 384 /*! @abstract Do not call this function; instead use `asinh` in C and 385 * Objective-C, and `simd::asinh` in C++. */ 386 static inline SIMD_CFUNC simd_float2 __tg_asinh(simd_float2 x); 387 /*! @abstract Do not call this function; instead use `asinh` in C and 388 * Objective-C, and `simd::asinh` in C++. */ 389 static inline SIMD_CFUNC simd_float3 __tg_asinh(simd_float3 x); 390 /*! @abstract Do not call this function; instead use `asinh` in C and 391 * Objective-C, and `simd::asinh` in C++. */ 392 static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x); 393 /*! @abstract Do not call this function; instead use `asinh` in C and 394 * Objective-C, and `simd::asinh` in C++. */ 395 static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x); 396 /*! @abstract Do not call this function; instead use `asinh` in C and 397 * Objective-C, and `simd::asinh` in C++. */ 398 static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x); 399 /*! @abstract Do not call this function; instead use `asinh` in C and 400 * Objective-C, and `simd::asinh` in C++. */ 401 static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x); 402 /*! @abstract Do not call this function; instead use `asinh` in C and 403 * Objective-C, and `simd::asinh` in C++. */ 404 static inline SIMD_CFUNC simd_double3 __tg_asinh(simd_double3 x); 405 /*! @abstract Do not call this function; instead use `asinh` in C and 406 * Objective-C, and `simd::asinh` in C++. */ 407 static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x); 408 /*! @abstract Do not call this function; instead use `asinh` in C and 409 * Objective-C, and `simd::asinh` in C++. */ 410 static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x); 411 412 /*! @abstract Do not call this function; instead use `atanh` in C and 413 * Objective-C, and `simd::atanh` in C++. */ 414 static inline SIMD_CFUNC simd_float2 __tg_atanh(simd_float2 x); 415 /*! @abstract Do not call this function; instead use `atanh` in C and 416 * Objective-C, and `simd::atanh` in C++. */ 417 static inline SIMD_CFUNC simd_float3 __tg_atanh(simd_float3 x); 418 /*! @abstract Do not call this function; instead use `atanh` in C and 419 * Objective-C, and `simd::atanh` in C++. */ 420 static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x); 421 /*! @abstract Do not call this function; instead use `atanh` in C and 422 * Objective-C, and `simd::atanh` in C++. */ 423 static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x); 424 /*! @abstract Do not call this function; instead use `atanh` in C and 425 * Objective-C, and `simd::atanh` in C++. */ 426 static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x); 427 /*! @abstract Do not call this function; instead use `atanh` in C and 428 * Objective-C, and `simd::atanh` in C++. */ 429 static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x); 430 /*! @abstract Do not call this function; instead use `atanh` in C and 431 * Objective-C, and `simd::atanh` in C++. */ 432 static inline SIMD_CFUNC simd_double3 __tg_atanh(simd_double3 x); 433 /*! @abstract Do not call this function; instead use `atanh` in C and 434 * Objective-C, and `simd::atanh` in C++. */ 435 static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x); 436 /*! @abstract Do not call this function; instead use `atanh` in C and 437 * Objective-C, and `simd::atanh` in C++. */ 438 static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x); 439 440 /*! @abstract Do not call this function; instead use `cosh` in C and 441 * Objective-C, and `simd::cosh` in C++. */ 442 static inline SIMD_CFUNC simd_float2 __tg_cosh(simd_float2 x); 443 /*! @abstract Do not call this function; instead use `cosh` in C and 444 * Objective-C, and `simd::cosh` in C++. */ 445 static inline SIMD_CFUNC simd_float3 __tg_cosh(simd_float3 x); 446 /*! @abstract Do not call this function; instead use `cosh` in C and 447 * Objective-C, and `simd::cosh` in C++. */ 448 static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x); 449 /*! @abstract Do not call this function; instead use `cosh` in C and 450 * Objective-C, and `simd::cosh` in C++. */ 451 static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x); 452 /*! @abstract Do not call this function; instead use `cosh` in C and 453 * Objective-C, and `simd::cosh` in C++. */ 454 static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x); 455 /*! @abstract Do not call this function; instead use `cosh` in C and 456 * Objective-C, and `simd::cosh` in C++. */ 457 static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x); 458 /*! @abstract Do not call this function; instead use `cosh` in C and 459 * Objective-C, and `simd::cosh` in C++. */ 460 static inline SIMD_CFUNC simd_double3 __tg_cosh(simd_double3 x); 461 /*! @abstract Do not call this function; instead use `cosh` in C and 462 * Objective-C, and `simd::cosh` in C++. */ 463 static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x); 464 /*! @abstract Do not call this function; instead use `cosh` in C and 465 * Objective-C, and `simd::cosh` in C++. */ 466 static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x); 467 468 /*! @abstract Do not call this function; instead use `sinh` in C and 469 * Objective-C, and `simd::sinh` in C++. */ 470 static inline SIMD_CFUNC simd_float2 __tg_sinh(simd_float2 x); 471 /*! @abstract Do not call this function; instead use `sinh` in C and 472 * Objective-C, and `simd::sinh` in C++. */ 473 static inline SIMD_CFUNC simd_float3 __tg_sinh(simd_float3 x); 474 /*! @abstract Do not call this function; instead use `sinh` in C and 475 * Objective-C, and `simd::sinh` in C++. */ 476 static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x); 477 /*! @abstract Do not call this function; instead use `sinh` in C and 478 * Objective-C, and `simd::sinh` in C++. */ 479 static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x); 480 /*! @abstract Do not call this function; instead use `sinh` in C and 481 * Objective-C, and `simd::sinh` in C++. */ 482 static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x); 483 /*! @abstract Do not call this function; instead use `sinh` in C and 484 * Objective-C, and `simd::sinh` in C++. */ 485 static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x); 486 /*! @abstract Do not call this function; instead use `sinh` in C and 487 * Objective-C, and `simd::sinh` in C++. */ 488 static inline SIMD_CFUNC simd_double3 __tg_sinh(simd_double3 x); 489 /*! @abstract Do not call this function; instead use `sinh` in C and 490 * Objective-C, and `simd::sinh` in C++. */ 491 static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x); 492 /*! @abstract Do not call this function; instead use `sinh` in C and 493 * Objective-C, and `simd::sinh` in C++. */ 494 static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x); 495 496 /*! @abstract Do not call this function; instead use `tanh` in C and 497 * Objective-C, and `simd::tanh` in C++. */ 498 static inline SIMD_CFUNC simd_float2 __tg_tanh(simd_float2 x); 499 /*! @abstract Do not call this function; instead use `tanh` in C and 500 * Objective-C, and `simd::tanh` in C++. */ 501 static inline SIMD_CFUNC simd_float3 __tg_tanh(simd_float3 x); 502 /*! @abstract Do not call this function; instead use `tanh` in C and 503 * Objective-C, and `simd::tanh` in C++. */ 504 static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x); 505 /*! @abstract Do not call this function; instead use `tanh` in C and 506 * Objective-C, and `simd::tanh` in C++. */ 507 static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x); 508 /*! @abstract Do not call this function; instead use `tanh` in C and 509 * Objective-C, and `simd::tanh` in C++. */ 510 static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x); 511 /*! @abstract Do not call this function; instead use `tanh` in C and 512 * Objective-C, and `simd::tanh` in C++. */ 513 static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x); 514 /*! @abstract Do not call this function; instead use `tanh` in C and 515 * Objective-C, and `simd::tanh` in C++. */ 516 static inline SIMD_CFUNC simd_double3 __tg_tanh(simd_double3 x); 517 /*! @abstract Do not call this function; instead use `tanh` in C and 518 * Objective-C, and `simd::tanh` in C++. */ 519 static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x); 520 /*! @abstract Do not call this function; instead use `tanh` in C and 521 * Objective-C, and `simd::tanh` in C++. */ 522 static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x); 523 524 /*! @abstract Do not call this function; instead use `exp` in C and 525 * Objective-C, and `simd::exp` in C++. */ 526 static inline SIMD_CFUNC simd_float2 __tg_exp(simd_float2 x); 527 /*! @abstract Do not call this function; instead use `exp` in C and 528 * Objective-C, and `simd::exp` in C++. */ 529 static inline SIMD_CFUNC simd_float3 __tg_exp(simd_float3 x); 530 /*! @abstract Do not call this function; instead use `exp` in C and 531 * Objective-C, and `simd::exp` in C++. */ 532 static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x); 533 /*! @abstract Do not call this function; instead use `exp` in C and 534 * Objective-C, and `simd::exp` in C++. */ 535 static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x); 536 /*! @abstract Do not call this function; instead use `exp` in C and 537 * Objective-C, and `simd::exp` in C++. */ 538 static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x); 539 /*! @abstract Do not call this function; instead use `exp` in C and 540 * Objective-C, and `simd::exp` in C++. */ 541 static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x); 542 /*! @abstract Do not call this function; instead use `exp` in C and 543 * Objective-C, and `simd::exp` in C++. */ 544 static inline SIMD_CFUNC simd_double3 __tg_exp(simd_double3 x); 545 /*! @abstract Do not call this function; instead use `exp` in C and 546 * Objective-C, and `simd::exp` in C++. */ 547 static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x); 548 /*! @abstract Do not call this function; instead use `exp` in C and 549 * Objective-C, and `simd::exp` in C++. */ 550 static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x); 551 552 /*! @abstract Do not call this function; instead use `exp2` in C and 553 * Objective-C, and `simd::exp2` in C++. */ 554 static inline SIMD_CFUNC simd_float2 __tg_exp2(simd_float2 x); 555 /*! @abstract Do not call this function; instead use `exp2` in C and 556 * Objective-C, and `simd::exp2` in C++. */ 557 static inline SIMD_CFUNC simd_float3 __tg_exp2(simd_float3 x); 558 /*! @abstract Do not call this function; instead use `exp2` in C and 559 * Objective-C, and `simd::exp2` in C++. */ 560 static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x); 561 /*! @abstract Do not call this function; instead use `exp2` in C and 562 * Objective-C, and `simd::exp2` in C++. */ 563 static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x); 564 /*! @abstract Do not call this function; instead use `exp2` in C and 565 * Objective-C, and `simd::exp2` in C++. */ 566 static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x); 567 /*! @abstract Do not call this function; instead use `exp2` in C and 568 * Objective-C, and `simd::exp2` in C++. */ 569 static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x); 570 /*! @abstract Do not call this function; instead use `exp2` in C and 571 * Objective-C, and `simd::exp2` in C++. */ 572 static inline SIMD_CFUNC simd_double3 __tg_exp2(simd_double3 x); 573 /*! @abstract Do not call this function; instead use `exp2` in C and 574 * Objective-C, and `simd::exp2` in C++. */ 575 static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x); 576 /*! @abstract Do not call this function; instead use `exp2` in C and 577 * Objective-C, and `simd::exp2` in C++. */ 578 static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x); 579 580 #if SIMD_LIBRARY_VERSION >= 1 581 /*! @abstract Do not call this function; instead use `exp10` in C and 582 * Objective-C, and `simd::exp10` in C++. */ 583 static inline SIMD_CFUNC simd_float2 __tg_exp10(simd_float2 x); 584 /*! @abstract Do not call this function; instead use `exp10` in C and 585 * Objective-C, and `simd::exp10` in C++. */ 586 static inline SIMD_CFUNC simd_float3 __tg_exp10(simd_float3 x); 587 /*! @abstract Do not call this function; instead use `exp10` in C and 588 * Objective-C, and `simd::exp10` in C++. */ 589 static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x); 590 /*! @abstract Do not call this function; instead use `exp10` in C and 591 * Objective-C, and `simd::exp10` in C++. */ 592 static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x); 593 /*! @abstract Do not call this function; instead use `exp10` in C and 594 * Objective-C, and `simd::exp10` in C++. */ 595 static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x); 596 /*! @abstract Do not call this function; instead use `exp10` in C and 597 * Objective-C, and `simd::exp10` in C++. */ 598 static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x); 599 /*! @abstract Do not call this function; instead use `exp10` in C and 600 * Objective-C, and `simd::exp10` in C++. */ 601 static inline SIMD_CFUNC simd_double3 __tg_exp10(simd_double3 x); 602 /*! @abstract Do not call this function; instead use `exp10` in C and 603 * Objective-C, and `simd::exp10` in C++. */ 604 static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x); 605 /*! @abstract Do not call this function; instead use `exp10` in C and 606 * Objective-C, and `simd::exp10` in C++. */ 607 static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x); 608 #endif 609 610 /*! @abstract Do not call this function; instead use `expm1` in C and 611 * Objective-C, and `simd::expm1` in C++. */ 612 static inline SIMD_CFUNC simd_float2 __tg_expm1(simd_float2 x); 613 /*! @abstract Do not call this function; instead use `expm1` in C and 614 * Objective-C, and `simd::expm1` in C++. */ 615 static inline SIMD_CFUNC simd_float3 __tg_expm1(simd_float3 x); 616 /*! @abstract Do not call this function; instead use `expm1` in C and 617 * Objective-C, and `simd::expm1` in C++. */ 618 static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x); 619 /*! @abstract Do not call this function; instead use `expm1` in C and 620 * Objective-C, and `simd::expm1` in C++. */ 621 static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x); 622 /*! @abstract Do not call this function; instead use `expm1` in C and 623 * Objective-C, and `simd::expm1` in C++. */ 624 static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x); 625 /*! @abstract Do not call this function; instead use `expm1` in C and 626 * Objective-C, and `simd::expm1` in C++. */ 627 static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x); 628 /*! @abstract Do not call this function; instead use `expm1` in C and 629 * Objective-C, and `simd::expm1` in C++. */ 630 static inline SIMD_CFUNC simd_double3 __tg_expm1(simd_double3 x); 631 /*! @abstract Do not call this function; instead use `expm1` in C and 632 * Objective-C, and `simd::expm1` in C++. */ 633 static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x); 634 /*! @abstract Do not call this function; instead use `expm1` in C and 635 * Objective-C, and `simd::expm1` in C++. */ 636 static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x); 637 638 /*! @abstract Do not call this function; instead use `log` in C and 639 * Objective-C, and `simd::log` in C++. */ 640 static inline SIMD_CFUNC simd_float2 __tg_log(simd_float2 x); 641 /*! @abstract Do not call this function; instead use `log` in C and 642 * Objective-C, and `simd::log` in C++. */ 643 static inline SIMD_CFUNC simd_float3 __tg_log(simd_float3 x); 644 /*! @abstract Do not call this function; instead use `log` in C and 645 * Objective-C, and `simd::log` in C++. */ 646 static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x); 647 /*! @abstract Do not call this function; instead use `log` in C and 648 * Objective-C, and `simd::log` in C++. */ 649 static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x); 650 /*! @abstract Do not call this function; instead use `log` in C and 651 * Objective-C, and `simd::log` in C++. */ 652 static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x); 653 /*! @abstract Do not call this function; instead use `log` in C and 654 * Objective-C, and `simd::log` in C++. */ 655 static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x); 656 /*! @abstract Do not call this function; instead use `log` in C and 657 * Objective-C, and `simd::log` in C++. */ 658 static inline SIMD_CFUNC simd_double3 __tg_log(simd_double3 x); 659 /*! @abstract Do not call this function; instead use `log` in C and 660 * Objective-C, and `simd::log` in C++. */ 661 static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x); 662 /*! @abstract Do not call this function; instead use `log` in C and 663 * Objective-C, and `simd::log` in C++. */ 664 static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x); 665 666 /*! @abstract Do not call this function; instead use `log2` in C and 667 * Objective-C, and `simd::log2` in C++. */ 668 static inline SIMD_CFUNC simd_float2 __tg_log2(simd_float2 x); 669 /*! @abstract Do not call this function; instead use `log2` in C and 670 * Objective-C, and `simd::log2` in C++. */ 671 static inline SIMD_CFUNC simd_float3 __tg_log2(simd_float3 x); 672 /*! @abstract Do not call this function; instead use `log2` in C and 673 * Objective-C, and `simd::log2` in C++. */ 674 static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x); 675 /*! @abstract Do not call this function; instead use `log2` in C and 676 * Objective-C, and `simd::log2` in C++. */ 677 static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x); 678 /*! @abstract Do not call this function; instead use `log2` in C and 679 * Objective-C, and `simd::log2` in C++. */ 680 static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x); 681 /*! @abstract Do not call this function; instead use `log2` in C and 682 * Objective-C, and `simd::log2` in C++. */ 683 static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x); 684 /*! @abstract Do not call this function; instead use `log2` in C and 685 * Objective-C, and `simd::log2` in C++. */ 686 static inline SIMD_CFUNC simd_double3 __tg_log2(simd_double3 x); 687 /*! @abstract Do not call this function; instead use `log2` in C and 688 * Objective-C, and `simd::log2` in C++. */ 689 static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x); 690 /*! @abstract Do not call this function; instead use `log2` in C and 691 * Objective-C, and `simd::log2` in C++. */ 692 static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x); 693 694 /*! @abstract Do not call this function; instead use `log10` in C and 695 * Objective-C, and `simd::log10` in C++. */ 696 static inline SIMD_CFUNC simd_float2 __tg_log10(simd_float2 x); 697 /*! @abstract Do not call this function; instead use `log10` in C and 698 * Objective-C, and `simd::log10` in C++. */ 699 static inline SIMD_CFUNC simd_float3 __tg_log10(simd_float3 x); 700 /*! @abstract Do not call this function; instead use `log10` in C and 701 * Objective-C, and `simd::log10` in C++. */ 702 static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x); 703 /*! @abstract Do not call this function; instead use `log10` in C and 704 * Objective-C, and `simd::log10` in C++. */ 705 static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x); 706 /*! @abstract Do not call this function; instead use `log10` in C and 707 * Objective-C, and `simd::log10` in C++. */ 708 static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x); 709 /*! @abstract Do not call this function; instead use `log10` in C and 710 * Objective-C, and `simd::log10` in C++. */ 711 static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x); 712 /*! @abstract Do not call this function; instead use `log10` in C and 713 * Objective-C, and `simd::log10` in C++. */ 714 static inline SIMD_CFUNC simd_double3 __tg_log10(simd_double3 x); 715 /*! @abstract Do not call this function; instead use `log10` in C and 716 * Objective-C, and `simd::log10` in C++. */ 717 static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x); 718 /*! @abstract Do not call this function; instead use `log10` in C and 719 * Objective-C, and `simd::log10` in C++. */ 720 static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x); 721 722 /*! @abstract Do not call this function; instead use `log1p` in C and 723 * Objective-C, and `simd::log1p` in C++. */ 724 static inline SIMD_CFUNC simd_float2 __tg_log1p(simd_float2 x); 725 /*! @abstract Do not call this function; instead use `log1p` in C and 726 * Objective-C, and `simd::log1p` in C++. */ 727 static inline SIMD_CFUNC simd_float3 __tg_log1p(simd_float3 x); 728 /*! @abstract Do not call this function; instead use `log1p` in C and 729 * Objective-C, and `simd::log1p` in C++. */ 730 static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x); 731 /*! @abstract Do not call this function; instead use `log1p` in C and 732 * Objective-C, and `simd::log1p` in C++. */ 733 static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x); 734 /*! @abstract Do not call this function; instead use `log1p` in C and 735 * Objective-C, and `simd::log1p` in C++. */ 736 static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x); 737 /*! @abstract Do not call this function; instead use `log1p` in C and 738 * Objective-C, and `simd::log1p` in C++. */ 739 static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x); 740 /*! @abstract Do not call this function; instead use `log1p` in C and 741 * Objective-C, and `simd::log1p` in C++. */ 742 static inline SIMD_CFUNC simd_double3 __tg_log1p(simd_double3 x); 743 /*! @abstract Do not call this function; instead use `log1p` in C and 744 * Objective-C, and `simd::log1p` in C++. */ 745 static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x); 746 /*! @abstract Do not call this function; instead use `log1p` in C and 747 * Objective-C, and `simd::log1p` in C++. */ 748 static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x); 749 750 /*! @abstract Do not call this function; instead use `fabs` in C and 751 * Objective-C, and `simd::fabs` in C++. */ 752 static inline SIMD_CFUNC simd_float2 __tg_fabs(simd_float2 x); 753 /*! @abstract Do not call this function; instead use `fabs` in C and 754 * Objective-C, and `simd::fabs` in C++. */ 755 static inline SIMD_CFUNC simd_float3 __tg_fabs(simd_float3 x); 756 /*! @abstract Do not call this function; instead use `fabs` in C and 757 * Objective-C, and `simd::fabs` in C++. */ 758 static inline SIMD_CFUNC simd_float4 __tg_fabs(simd_float4 x); 759 /*! @abstract Do not call this function; instead use `fabs` in C and 760 * Objective-C, and `simd::fabs` in C++. */ 761 static inline SIMD_CFUNC simd_float8 __tg_fabs(simd_float8 x); 762 /*! @abstract Do not call this function; instead use `fabs` in C and 763 * Objective-C, and `simd::fabs` in C++. */ 764 static inline SIMD_CFUNC simd_float16 __tg_fabs(simd_float16 x); 765 /*! @abstract Do not call this function; instead use `fabs` in C and 766 * Objective-C, and `simd::fabs` in C++. */ 767 static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x); 768 /*! @abstract Do not call this function; instead use `fabs` in C and 769 * Objective-C, and `simd::fabs` in C++. */ 770 static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x); 771 /*! @abstract Do not call this function; instead use `fabs` in C and 772 * Objective-C, and `simd::fabs` in C++. */ 773 static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x); 774 /*! @abstract Do not call this function; instead use `fabs` in C and 775 * Objective-C, and `simd::fabs` in C++. */ 776 static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x); 777 778 /*! @abstract Do not call this function; instead use `cbrt` in C and 779 * Objective-C, and `simd::cbrt` in C++. */ 780 static inline SIMD_CFUNC simd_float2 __tg_cbrt(simd_float2 x); 781 /*! @abstract Do not call this function; instead use `cbrt` in C and 782 * Objective-C, and `simd::cbrt` in C++. */ 783 static inline SIMD_CFUNC simd_float3 __tg_cbrt(simd_float3 x); 784 /*! @abstract Do not call this function; instead use `cbrt` in C and 785 * Objective-C, and `simd::cbrt` in C++. */ 786 static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x); 787 /*! @abstract Do not call this function; instead use `cbrt` in C and 788 * Objective-C, and `simd::cbrt` in C++. */ 789 static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x); 790 /*! @abstract Do not call this function; instead use `cbrt` in C and 791 * Objective-C, and `simd::cbrt` in C++. */ 792 static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x); 793 /*! @abstract Do not call this function; instead use `cbrt` in C and 794 * Objective-C, and `simd::cbrt` in C++. */ 795 static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x); 796 /*! @abstract Do not call this function; instead use `cbrt` in C and 797 * Objective-C, and `simd::cbrt` in C++. */ 798 static inline SIMD_CFUNC simd_double3 __tg_cbrt(simd_double3 x); 799 /*! @abstract Do not call this function; instead use `cbrt` in C and 800 * Objective-C, and `simd::cbrt` in C++. */ 801 static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x); 802 /*! @abstract Do not call this function; instead use `cbrt` in C and 803 * Objective-C, and `simd::cbrt` in C++. */ 804 static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x); 805 806 /*! @abstract Do not call this function; instead use `sqrt` in C and 807 * Objective-C, and `simd::sqrt` in C++. */ 808 static inline SIMD_CFUNC simd_float2 __tg_sqrt(simd_float2 x); 809 /*! @abstract Do not call this function; instead use `sqrt` in C and 810 * Objective-C, and `simd::sqrt` in C++. */ 811 static inline SIMD_CFUNC simd_float3 __tg_sqrt(simd_float3 x); 812 /*! @abstract Do not call this function; instead use `sqrt` in C and 813 * Objective-C, and `simd::sqrt` in C++. */ 814 static inline SIMD_CFUNC simd_float4 __tg_sqrt(simd_float4 x); 815 /*! @abstract Do not call this function; instead use `sqrt` in C and 816 * Objective-C, and `simd::sqrt` in C++. */ 817 static inline SIMD_CFUNC simd_float8 __tg_sqrt(simd_float8 x); 818 /*! @abstract Do not call this function; instead use `sqrt` in C and 819 * Objective-C, and `simd::sqrt` in C++. */ 820 static inline SIMD_CFUNC simd_float16 __tg_sqrt(simd_float16 x); 821 /*! @abstract Do not call this function; instead use `sqrt` in C and 822 * Objective-C, and `simd::sqrt` in C++. */ 823 static inline SIMD_CFUNC simd_double2 __tg_sqrt(simd_double2 x); 824 /*! @abstract Do not call this function; instead use `sqrt` in C and 825 * Objective-C, and `simd::sqrt` in C++. */ 826 static inline SIMD_CFUNC simd_double3 __tg_sqrt(simd_double3 x); 827 /*! @abstract Do not call this function; instead use `sqrt` in C and 828 * Objective-C, and `simd::sqrt` in C++. */ 829 static inline SIMD_CFUNC simd_double4 __tg_sqrt(simd_double4 x); 830 /*! @abstract Do not call this function; instead use `sqrt` in C and 831 * Objective-C, and `simd::sqrt` in C++. */ 832 static inline SIMD_CFUNC simd_double8 __tg_sqrt(simd_double8 x); 833 834 /*! @abstract Do not call this function; instead use `erf` in C and 835 * Objective-C, and `simd::erf` in C++. */ 836 static inline SIMD_CFUNC simd_float2 __tg_erf(simd_float2 x); 837 /*! @abstract Do not call this function; instead use `erf` in C and 838 * Objective-C, and `simd::erf` in C++. */ 839 static inline SIMD_CFUNC simd_float3 __tg_erf(simd_float3 x); 840 /*! @abstract Do not call this function; instead use `erf` in C and 841 * Objective-C, and `simd::erf` in C++. */ 842 static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x); 843 /*! @abstract Do not call this function; instead use `erf` in C and 844 * Objective-C, and `simd::erf` in C++. */ 845 static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x); 846 /*! @abstract Do not call this function; instead use `erf` in C and 847 * Objective-C, and `simd::erf` in C++. */ 848 static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x); 849 /*! @abstract Do not call this function; instead use `erf` in C and 850 * Objective-C, and `simd::erf` in C++. */ 851 static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x); 852 /*! @abstract Do not call this function; instead use `erf` in C and 853 * Objective-C, and `simd::erf` in C++. */ 854 static inline SIMD_CFUNC simd_double3 __tg_erf(simd_double3 x); 855 /*! @abstract Do not call this function; instead use `erf` in C and 856 * Objective-C, and `simd::erf` in C++. */ 857 static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x); 858 /*! @abstract Do not call this function; instead use `erf` in C and 859 * Objective-C, and `simd::erf` in C++. */ 860 static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x); 861 862 /*! @abstract Do not call this function; instead use `erfc` in C and 863 * Objective-C, and `simd::erfc` in C++. */ 864 static inline SIMD_CFUNC simd_float2 __tg_erfc(simd_float2 x); 865 /*! @abstract Do not call this function; instead use `erfc` in C and 866 * Objective-C, and `simd::erfc` in C++. */ 867 static inline SIMD_CFUNC simd_float3 __tg_erfc(simd_float3 x); 868 /*! @abstract Do not call this function; instead use `erfc` in C and 869 * Objective-C, and `simd::erfc` in C++. */ 870 static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x); 871 /*! @abstract Do not call this function; instead use `erfc` in C and 872 * Objective-C, and `simd::erfc` in C++. */ 873 static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x); 874 /*! @abstract Do not call this function; instead use `erfc` in C and 875 * Objective-C, and `simd::erfc` in C++. */ 876 static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x); 877 /*! @abstract Do not call this function; instead use `erfc` in C and 878 * Objective-C, and `simd::erfc` in C++. */ 879 static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x); 880 /*! @abstract Do not call this function; instead use `erfc` in C and 881 * Objective-C, and `simd::erfc` in C++. */ 882 static inline SIMD_CFUNC simd_double3 __tg_erfc(simd_double3 x); 883 /*! @abstract Do not call this function; instead use `erfc` in C and 884 * Objective-C, and `simd::erfc` in C++. */ 885 static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x); 886 /*! @abstract Do not call this function; instead use `erfc` in C and 887 * Objective-C, and `simd::erfc` in C++. */ 888 static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x); 889 890 /*! @abstract Do not call this function; instead use `tgamma` in C and 891 * Objective-C, and `simd::tgamma` in C++. */ 892 static inline SIMD_CFUNC simd_float2 __tg_tgamma(simd_float2 x); 893 /*! @abstract Do not call this function; instead use `tgamma` in C and 894 * Objective-C, and `simd::tgamma` in C++. */ 895 static inline SIMD_CFUNC simd_float3 __tg_tgamma(simd_float3 x); 896 /*! @abstract Do not call this function; instead use `tgamma` in C and 897 * Objective-C, and `simd::tgamma` in C++. */ 898 static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x); 899 /*! @abstract Do not call this function; instead use `tgamma` in C and 900 * Objective-C, and `simd::tgamma` in C++. */ 901 static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x); 902 /*! @abstract Do not call this function; instead use `tgamma` in C and 903 * Objective-C, and `simd::tgamma` in C++. */ 904 static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x); 905 /*! @abstract Do not call this function; instead use `tgamma` in C and 906 * Objective-C, and `simd::tgamma` in C++. */ 907 static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x); 908 /*! @abstract Do not call this function; instead use `tgamma` in C and 909 * Objective-C, and `simd::tgamma` in C++. */ 910 static inline SIMD_CFUNC simd_double3 __tg_tgamma(simd_double3 x); 911 /*! @abstract Do not call this function; instead use `tgamma` in C and 912 * Objective-C, and `simd::tgamma` in C++. */ 913 static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x); 914 /*! @abstract Do not call this function; instead use `tgamma` in C and 915 * Objective-C, and `simd::tgamma` in C++. */ 916 static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x); 917 918 /*! @abstract Do not call this function; instead use `lgamma` in C and 919 * Objective-C, and `simd::lgamma` in C++. */ 920 static inline SIMD_CFUNC simd_float2 __tg_lgamma(simd_float2 x); 921 /*! @abstract Do not call this function; instead use `lgamma` in C and 922 * Objective-C, and `simd::lgamma` in C++. */ 923 static inline SIMD_CFUNC simd_float3 __tg_lgamma(simd_float3 x); 924 /*! @abstract Do not call this function; instead use `lgamma` in C and 925 * Objective-C, and `simd::lgamma` in C++. */ 926 static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x); 927 /*! @abstract Do not call this function; instead use `lgamma` in C and 928 * Objective-C, and `simd::lgamma` in C++. */ 929 static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x); 930 /*! @abstract Do not call this function; instead use `lgamma` in C and 931 * Objective-C, and `simd::lgamma` in C++. */ 932 static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x); 933 /*! @abstract Do not call this function; instead use `lgamma` in C and 934 * Objective-C, and `simd::lgamma` in C++. */ 935 static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x); 936 /*! @abstract Do not call this function; instead use `lgamma` in C and 937 * Objective-C, and `simd::lgamma` in C++. */ 938 static inline SIMD_CFUNC simd_double3 __tg_lgamma(simd_double3 x); 939 /*! @abstract Do not call this function; instead use `lgamma` in C and 940 * Objective-C, and `simd::lgamma` in C++. */ 941 static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x); 942 /*! @abstract Do not call this function; instead use `lgamma` in C and 943 * Objective-C, and `simd::lgamma` in C++. */ 944 static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x); 945 946 /*! @abstract Do not call this function; instead use `ceil` in C and 947 * Objective-C, and `simd::ceil` in C++. */ 948 static inline SIMD_CFUNC simd_float2 __tg_ceil(simd_float2 x); 949 /*! @abstract Do not call this function; instead use `ceil` in C and 950 * Objective-C, and `simd::ceil` in C++. */ 951 static inline SIMD_CFUNC simd_float3 __tg_ceil(simd_float3 x); 952 /*! @abstract Do not call this function; instead use `ceil` in C and 953 * Objective-C, and `simd::ceil` in C++. */ 954 static inline SIMD_CFUNC simd_float4 __tg_ceil(simd_float4 x); 955 /*! @abstract Do not call this function; instead use `ceil` in C and 956 * Objective-C, and `simd::ceil` in C++. */ 957 static inline SIMD_CFUNC simd_float8 __tg_ceil(simd_float8 x); 958 /*! @abstract Do not call this function; instead use `ceil` in C and 959 * Objective-C, and `simd::ceil` in C++. */ 960 static inline SIMD_CFUNC simd_float16 __tg_ceil(simd_float16 x); 961 /*! @abstract Do not call this function; instead use `ceil` in C and 962 * Objective-C, and `simd::ceil` in C++. */ 963 static inline SIMD_CFUNC simd_double2 __tg_ceil(simd_double2 x); 964 /*! @abstract Do not call this function; instead use `ceil` in C and 965 * Objective-C, and `simd::ceil` in C++. */ 966 static inline SIMD_CFUNC simd_double3 __tg_ceil(simd_double3 x); 967 /*! @abstract Do not call this function; instead use `ceil` in C and 968 * Objective-C, and `simd::ceil` in C++. */ 969 static inline SIMD_CFUNC simd_double4 __tg_ceil(simd_double4 x); 970 /*! @abstract Do not call this function; instead use `ceil` in C and 971 * Objective-C, and `simd::ceil` in C++. */ 972 static inline SIMD_CFUNC simd_double8 __tg_ceil(simd_double8 x); 973 974 /*! @abstract Do not call this function; instead use `floor` in C and 975 * Objective-C, and `simd::floor` in C++. */ 976 static inline SIMD_CFUNC simd_float2 __tg_floor(simd_float2 x); 977 /*! @abstract Do not call this function; instead use `floor` in C and 978 * Objective-C, and `simd::floor` in C++. */ 979 static inline SIMD_CFUNC simd_float3 __tg_floor(simd_float3 x); 980 /*! @abstract Do not call this function; instead use `floor` in C and 981 * Objective-C, and `simd::floor` in C++. */ 982 static inline SIMD_CFUNC simd_float4 __tg_floor(simd_float4 x); 983 /*! @abstract Do not call this function; instead use `floor` in C and 984 * Objective-C, and `simd::floor` in C++. */ 985 static inline SIMD_CFUNC simd_float8 __tg_floor(simd_float8 x); 986 /*! @abstract Do not call this function; instead use `floor` in C and 987 * Objective-C, and `simd::floor` in C++. */ 988 static inline SIMD_CFUNC simd_float16 __tg_floor(simd_float16 x); 989 /*! @abstract Do not call this function; instead use `floor` in C and 990 * Objective-C, and `simd::floor` in C++. */ 991 static inline SIMD_CFUNC simd_double2 __tg_floor(simd_double2 x); 992 /*! @abstract Do not call this function; instead use `floor` in C and 993 * Objective-C, and `simd::floor` in C++. */ 994 static inline SIMD_CFUNC simd_double3 __tg_floor(simd_double3 x); 995 /*! @abstract Do not call this function; instead use `floor` in C and 996 * Objective-C, and `simd::floor` in C++. */ 997 static inline SIMD_CFUNC simd_double4 __tg_floor(simd_double4 x); 998 /*! @abstract Do not call this function; instead use `floor` in C and 999 * Objective-C, and `simd::floor` in C++. */ 1000 static inline SIMD_CFUNC simd_double8 __tg_floor(simd_double8 x); 1001 1002 /*! @abstract Do not call this function; instead use `rint` in C and 1003 * Objective-C, and `simd::rint` in C++. */ 1004 static inline SIMD_CFUNC simd_float2 __tg_rint(simd_float2 x); 1005 /*! @abstract Do not call this function; instead use `rint` in C and 1006 * Objective-C, and `simd::rint` in C++. */ 1007 static inline SIMD_CFUNC simd_float3 __tg_rint(simd_float3 x); 1008 /*! @abstract Do not call this function; instead use `rint` in C and 1009 * Objective-C, and `simd::rint` in C++. */ 1010 static inline SIMD_CFUNC simd_float4 __tg_rint(simd_float4 x); 1011 /*! @abstract Do not call this function; instead use `rint` in C and 1012 * Objective-C, and `simd::rint` in C++. */ 1013 static inline SIMD_CFUNC simd_float8 __tg_rint(simd_float8 x); 1014 /*! @abstract Do not call this function; instead use `rint` in C and 1015 * Objective-C, and `simd::rint` in C++. */ 1016 static inline SIMD_CFUNC simd_float16 __tg_rint(simd_float16 x); 1017 /*! @abstract Do not call this function; instead use `rint` in C and 1018 * Objective-C, and `simd::rint` in C++. */ 1019 static inline SIMD_CFUNC simd_double2 __tg_rint(simd_double2 x); 1020 /*! @abstract Do not call this function; instead use `rint` in C and 1021 * Objective-C, and `simd::rint` in C++. */ 1022 static inline SIMD_CFUNC simd_double3 __tg_rint(simd_double3 x); 1023 /*! @abstract Do not call this function; instead use `rint` in C and 1024 * Objective-C, and `simd::rint` in C++. */ 1025 static inline SIMD_CFUNC simd_double4 __tg_rint(simd_double4 x); 1026 /*! @abstract Do not call this function; instead use `rint` in C and 1027 * Objective-C, and `simd::rint` in C++. */ 1028 static inline SIMD_CFUNC simd_double8 __tg_rint(simd_double8 x); 1029 1030 /*! @abstract Do not call this function; instead use `round` in C and 1031 * Objective-C, and `simd::round` in C++. */ 1032 static inline SIMD_CFUNC simd_float2 __tg_round(simd_float2 x); 1033 /*! @abstract Do not call this function; instead use `round` in C and 1034 * Objective-C, and `simd::round` in C++. */ 1035 static inline SIMD_CFUNC simd_float3 __tg_round(simd_float3 x); 1036 /*! @abstract Do not call this function; instead use `round` in C and 1037 * Objective-C, and `simd::round` in C++. */ 1038 static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x); 1039 /*! @abstract Do not call this function; instead use `round` in C and 1040 * Objective-C, and `simd::round` in C++. */ 1041 static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x); 1042 /*! @abstract Do not call this function; instead use `round` in C and 1043 * Objective-C, and `simd::round` in C++. */ 1044 static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x); 1045 /*! @abstract Do not call this function; instead use `round` in C and 1046 * Objective-C, and `simd::round` in C++. */ 1047 static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x); 1048 /*! @abstract Do not call this function; instead use `round` in C and 1049 * Objective-C, and `simd::round` in C++. */ 1050 static inline SIMD_CFUNC simd_double3 __tg_round(simd_double3 x); 1051 /*! @abstract Do not call this function; instead use `round` in C and 1052 * Objective-C, and `simd::round` in C++. */ 1053 static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x); 1054 /*! @abstract Do not call this function; instead use `round` in C and 1055 * Objective-C, and `simd::round` in C++. */ 1056 static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x); 1057 1058 /*! @abstract Do not call this function; instead use `trunc` in C and 1059 * Objective-C, and `simd::trunc` in C++. */ 1060 static inline SIMD_CFUNC simd_float2 __tg_trunc(simd_float2 x); 1061 /*! @abstract Do not call this function; instead use `trunc` in C and 1062 * Objective-C, and `simd::trunc` in C++. */ 1063 static inline SIMD_CFUNC simd_float3 __tg_trunc(simd_float3 x); 1064 /*! @abstract Do not call this function; instead use `trunc` in C and 1065 * Objective-C, and `simd::trunc` in C++. */ 1066 static inline SIMD_CFUNC simd_float4 __tg_trunc(simd_float4 x); 1067 /*! @abstract Do not call this function; instead use `trunc` in C and 1068 * Objective-C, and `simd::trunc` in C++. */ 1069 static inline SIMD_CFUNC simd_float8 __tg_trunc(simd_float8 x); 1070 /*! @abstract Do not call this function; instead use `trunc` in C and 1071 * Objective-C, and `simd::trunc` in C++. */ 1072 static inline SIMD_CFUNC simd_float16 __tg_trunc(simd_float16 x); 1073 /*! @abstract Do not call this function; instead use `trunc` in C and 1074 * Objective-C, and `simd::trunc` in C++. */ 1075 static inline SIMD_CFUNC simd_double2 __tg_trunc(simd_double2 x); 1076 /*! @abstract Do not call this function; instead use `trunc` in C and 1077 * Objective-C, and `simd::trunc` in C++. */ 1078 static inline SIMD_CFUNC simd_double3 __tg_trunc(simd_double3 x); 1079 /*! @abstract Do not call this function; instead use `trunc` in C and 1080 * Objective-C, and `simd::trunc` in C++. */ 1081 static inline SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x); 1082 /*! @abstract Do not call this function; instead use `trunc` in C and 1083 * Objective-C, and `simd::trunc` in C++. */ 1084 static inline SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x); 1085 1086 #if SIMD_LIBRARY_VERSION >= 5 1087 /*! @abstract Do not call this function; instead use `sincos` in C and 1088 * Objective-C, and `simd::sincos` in C++. */ 1089 static inline SIMD_NONCONST void __tg_sincos(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp); 1090 /*! @abstract Do not call this function; instead use `sincos` in C and 1091 * Objective-C, and `simd::sincos` in C++. */ 1092 static inline SIMD_NONCONST void __tg_sincos(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp); 1093 /*! @abstract Do not call this function; instead use `sincos` in C and 1094 * Objective-C, and `simd::sincos` in C++. */ 1095 static inline SIMD_NONCONST void __tg_sincos(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp); 1096 /*! @abstract Do not call this function; instead use `sincos` in C and 1097 * Objective-C, and `simd::sincos` in C++. */ 1098 static inline SIMD_NONCONST void __tg_sincos(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp); 1099 /*! @abstract Do not call this function; instead use `sincos` in C and 1100 * Objective-C, and `simd::sincos` in C++. */ 1101 static inline SIMD_NONCONST void __tg_sincos(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp); 1102 /*! @abstract Do not call this function; instead use `sincos` in C and 1103 * Objective-C, and `simd::sincos` in C++. */ 1104 static inline SIMD_NONCONST void __tg_sincos(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp); 1105 /*! @abstract Do not call this function; instead use `sincos` in C and 1106 * Objective-C, and `simd::sincos` in C++. */ 1107 static inline SIMD_NONCONST void __tg_sincos(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp); 1108 /*! @abstract Do not call this function; instead use `sincos` in C and 1109 * Objective-C, and `simd::sincos` in C++. */ 1110 static inline SIMD_NONCONST void __tg_sincos(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp); 1111 /*! @abstract Do not call this function; instead use `sincos` in C and 1112 * Objective-C, and `simd::sincos` in C++. */ 1113 static inline SIMD_NONCONST void __tg_sincos(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp); 1114 1115 /*! @abstract Do not call this function; instead use `sincospi` in C and 1116 * Objective-C, and `simd::sincospi` in C++. */ 1117 static inline SIMD_NONCONST void __tg_sincospi(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp); 1118 /*! @abstract Do not call this function; instead use `sincospi` in C and 1119 * Objective-C, and `simd::sincospi` in C++. */ 1120 static inline SIMD_NONCONST void __tg_sincospi(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp); 1121 /*! @abstract Do not call this function; instead use `sincospi` in C and 1122 * Objective-C, and `simd::sincospi` in C++. */ 1123 static inline SIMD_NONCONST void __tg_sincospi(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp); 1124 /*! @abstract Do not call this function; instead use `sincospi` in C and 1125 * Objective-C, and `simd::sincospi` in C++. */ 1126 static inline SIMD_NONCONST void __tg_sincospi(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp); 1127 /*! @abstract Do not call this function; instead use `sincospi` in C and 1128 * Objective-C, and `simd::sincospi` in C++. */ 1129 static inline SIMD_NONCONST void __tg_sincospi(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp); 1130 /*! @abstract Do not call this function; instead use `sincospi` in C and 1131 * Objective-C, and `simd::sincospi` in C++. */ 1132 static inline SIMD_NONCONST void __tg_sincospi(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp); 1133 /*! @abstract Do not call this function; instead use `sincospi` in C and 1134 * Objective-C, and `simd::sincospi` in C++. */ 1135 static inline SIMD_NONCONST void __tg_sincospi(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp); 1136 /*! @abstract Do not call this function; instead use `sincospi` in C and 1137 * Objective-C, and `simd::sincospi` in C++. */ 1138 static inline SIMD_NONCONST void __tg_sincospi(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp); 1139 /*! @abstract Do not call this function; instead use `sincospi` in C and 1140 * Objective-C, and `simd::sincospi` in C++. */ 1141 static inline SIMD_NONCONST void __tg_sincospi(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp); 1142 1143 #endif 1144 /*! @abstract Do not call this function; instead use `isfinite` in C and 1145 * Objective-C, and `simd::isfinite` in C++. */ 1146 static inline SIMD_CFUNC simd_short2 __tg_isfinite(simd_half2 x); 1147 /*! @abstract Do not call this function; instead use `isfinite` in C and 1148 * Objective-C, and `simd::isfinite` in C++. */ 1149 static inline SIMD_CFUNC simd_short3 __tg_isfinite(simd_half3 x); 1150 /*! @abstract Do not call this function; instead use `isfinite` in C and 1151 * Objective-C, and `simd::isfinite` in C++. */ 1152 static inline SIMD_CFUNC simd_short4 __tg_isfinite(simd_half4 x); 1153 /*! @abstract Do not call this function; instead use `isfinite` in C and 1154 * Objective-C, and `simd::isfinite` in C++. */ 1155 static inline SIMD_CFUNC simd_short8 __tg_isfinite(simd_half8 x); 1156 /*! @abstract Do not call this function; instead use `isfinite` in C and 1157 * Objective-C, and `simd::isfinite` in C++. */ 1158 static inline SIMD_CFUNC simd_short16 __tg_isfinite(simd_half16 x); 1159 /*! @abstract Do not call this function; instead use `isfinite` in C and 1160 * Objective-C, and `simd::isfinite` in C++. */ 1161 static inline SIMD_CFUNC simd_short32 __tg_isfinite(simd_half32 x); 1162 /*! @abstract Do not call this function; instead use `isfinite` in C and 1163 * Objective-C, and `simd::isfinite` in C++. */ 1164 static inline SIMD_CFUNC simd_int2 __tg_isfinite(simd_float2 x); 1165 /*! @abstract Do not call this function; instead use `isfinite` in C and 1166 * Objective-C, and `simd::isfinite` in C++. */ 1167 static inline SIMD_CFUNC simd_int3 __tg_isfinite(simd_float3 x); 1168 /*! @abstract Do not call this function; instead use `isfinite` in C and 1169 * Objective-C, and `simd::isfinite` in C++. */ 1170 static inline SIMD_CFUNC simd_int4 __tg_isfinite(simd_float4 x); 1171 /*! @abstract Do not call this function; instead use `isfinite` in C and 1172 * Objective-C, and `simd::isfinite` in C++. */ 1173 static inline SIMD_CFUNC simd_int8 __tg_isfinite(simd_float8 x); 1174 /*! @abstract Do not call this function; instead use `isfinite` in C and 1175 * Objective-C, and `simd::isfinite` in C++. */ 1176 static inline SIMD_CFUNC simd_int16 __tg_isfinite(simd_float16 x); 1177 /*! @abstract Do not call this function; instead use `isfinite` in C and 1178 * Objective-C, and `simd::isfinite` in C++. */ 1179 static inline SIMD_CFUNC simd_long2 __tg_isfinite(simd_double2 x); 1180 /*! @abstract Do not call this function; instead use `isfinite` in C and 1181 * Objective-C, and `simd::isfinite` in C++. */ 1182 static inline SIMD_CFUNC simd_long3 __tg_isfinite(simd_double3 x); 1183 /*! @abstract Do not call this function; instead use `isfinite` in C and 1184 * Objective-C, and `simd::isfinite` in C++. */ 1185 static inline SIMD_CFUNC simd_long4 __tg_isfinite(simd_double4 x); 1186 /*! @abstract Do not call this function; instead use `isfinite` in C and 1187 * Objective-C, and `simd::isfinite` in C++. */ 1188 static inline SIMD_CFUNC simd_long8 __tg_isfinite(simd_double8 x); 1189 1190 /*! @abstract Do not call this function; instead use `isinf` in C and 1191 * Objective-C, and `simd::isinf` in C++. */ 1192 static inline SIMD_CFUNC simd_short2 __tg_isinf(simd_half2 x); 1193 /*! @abstract Do not call this function; instead use `isinf` in C and 1194 * Objective-C, and `simd::isinf` in C++. */ 1195 static inline SIMD_CFUNC simd_short3 __tg_isinf(simd_half3 x); 1196 /*! @abstract Do not call this function; instead use `isinf` in C and 1197 * Objective-C, and `simd::isinf` in C++. */ 1198 static inline SIMD_CFUNC simd_short4 __tg_isinf(simd_half4 x); 1199 /*! @abstract Do not call this function; instead use `isinf` in C and 1200 * Objective-C, and `simd::isinf` in C++. */ 1201 static inline SIMD_CFUNC simd_short8 __tg_isinf(simd_half8 x); 1202 /*! @abstract Do not call this function; instead use `isinf` in C and 1203 * Objective-C, and `simd::isinf` in C++. */ 1204 static inline SIMD_CFUNC simd_short16 __tg_isinf(simd_half16 x); 1205 /*! @abstract Do not call this function; instead use `isinf` in C and 1206 * Objective-C, and `simd::isinf` in C++. */ 1207 static inline SIMD_CFUNC simd_short32 __tg_isinf(simd_half32 x); 1208 /*! @abstract Do not call this function; instead use `isinf` in C and 1209 * Objective-C, and `simd::isinf` in C++. */ 1210 static inline SIMD_CFUNC simd_int2 __tg_isinf(simd_float2 x); 1211 /*! @abstract Do not call this function; instead use `isinf` in C and 1212 * Objective-C, and `simd::isinf` in C++. */ 1213 static inline SIMD_CFUNC simd_int3 __tg_isinf(simd_float3 x); 1214 /*! @abstract Do not call this function; instead use `isinf` in C and 1215 * Objective-C, and `simd::isinf` in C++. */ 1216 static inline SIMD_CFUNC simd_int4 __tg_isinf(simd_float4 x); 1217 /*! @abstract Do not call this function; instead use `isinf` in C and 1218 * Objective-C, and `simd::isinf` in C++. */ 1219 static inline SIMD_CFUNC simd_int8 __tg_isinf(simd_float8 x); 1220 /*! @abstract Do not call this function; instead use `isinf` in C and 1221 * Objective-C, and `simd::isinf` in C++. */ 1222 static inline SIMD_CFUNC simd_int16 __tg_isinf(simd_float16 x); 1223 /*! @abstract Do not call this function; instead use `isinf` in C and 1224 * Objective-C, and `simd::isinf` in C++. */ 1225 static inline SIMD_CFUNC simd_long2 __tg_isinf(simd_double2 x); 1226 /*! @abstract Do not call this function; instead use `isinf` in C and 1227 * Objective-C, and `simd::isinf` in C++. */ 1228 static inline SIMD_CFUNC simd_long3 __tg_isinf(simd_double3 x); 1229 /*! @abstract Do not call this function; instead use `isinf` in C and 1230 * Objective-C, and `simd::isinf` in C++. */ 1231 static inline SIMD_CFUNC simd_long4 __tg_isinf(simd_double4 x); 1232 /*! @abstract Do not call this function; instead use `isinf` in C and 1233 * Objective-C, and `simd::isinf` in C++. */ 1234 static inline SIMD_CFUNC simd_long8 __tg_isinf(simd_double8 x); 1235 1236 /*! @abstract Do not call this function; instead use `isnan` in C and 1237 * Objective-C, and `simd::isnan` in C++. */ 1238 static inline SIMD_CFUNC simd_short2 __tg_isnan(simd_half2 x); 1239 /*! @abstract Do not call this function; instead use `isnan` in C and 1240 * Objective-C, and `simd::isnan` in C++. */ 1241 static inline SIMD_CFUNC simd_short3 __tg_isnan(simd_half3 x); 1242 /*! @abstract Do not call this function; instead use `isnan` in C and 1243 * Objective-C, and `simd::isnan` in C++. */ 1244 static inline SIMD_CFUNC simd_short4 __tg_isnan(simd_half4 x); 1245 /*! @abstract Do not call this function; instead use `isnan` in C and 1246 * Objective-C, and `simd::isnan` in C++. */ 1247 static inline SIMD_CFUNC simd_short8 __tg_isnan(simd_half8 x); 1248 /*! @abstract Do not call this function; instead use `isnan` in C and 1249 * Objective-C, and `simd::isnan` in C++. */ 1250 static inline SIMD_CFUNC simd_short16 __tg_isnan(simd_half16 x); 1251 /*! @abstract Do not call this function; instead use `isnan` in C and 1252 * Objective-C, and `simd::isnan` in C++. */ 1253 static inline SIMD_CFUNC simd_short32 __tg_isnan(simd_half32 x); 1254 /*! @abstract Do not call this function; instead use `isnan` in C and 1255 * Objective-C, and `simd::isnan` in C++. */ 1256 static inline SIMD_CFUNC simd_int2 __tg_isnan(simd_float2 x); 1257 /*! @abstract Do not call this function; instead use `isnan` in C and 1258 * Objective-C, and `simd::isnan` in C++. */ 1259 static inline SIMD_CFUNC simd_int3 __tg_isnan(simd_float3 x); 1260 /*! @abstract Do not call this function; instead use `isnan` in C and 1261 * Objective-C, and `simd::isnan` in C++. */ 1262 static inline SIMD_CFUNC simd_int4 __tg_isnan(simd_float4 x); 1263 /*! @abstract Do not call this function; instead use `isnan` in C and 1264 * Objective-C, and `simd::isnan` in C++. */ 1265 static inline SIMD_CFUNC simd_int8 __tg_isnan(simd_float8 x); 1266 /*! @abstract Do not call this function; instead use `isnan` in C and 1267 * Objective-C, and `simd::isnan` in C++. */ 1268 static inline SIMD_CFUNC simd_int16 __tg_isnan(simd_float16 x); 1269 /*! @abstract Do not call this function; instead use `isnan` in C and 1270 * Objective-C, and `simd::isnan` in C++. */ 1271 static inline SIMD_CFUNC simd_long2 __tg_isnan(simd_double2 x); 1272 /*! @abstract Do not call this function; instead use `isnan` in C and 1273 * Objective-C, and `simd::isnan` in C++. */ 1274 static inline SIMD_CFUNC simd_long3 __tg_isnan(simd_double3 x); 1275 /*! @abstract Do not call this function; instead use `isnan` in C and 1276 * Objective-C, and `simd::isnan` in C++. */ 1277 static inline SIMD_CFUNC simd_long4 __tg_isnan(simd_double4 x); 1278 /*! @abstract Do not call this function; instead use `isnan` in C and 1279 * Objective-C, and `simd::isnan` in C++. */ 1280 static inline SIMD_CFUNC simd_long8 __tg_isnan(simd_double8 x); 1281 1282 /*! @abstract Do not call this function; instead use `isnormal` in C and 1283 * Objective-C, and `simd::isnormal` in C++. */ 1284 static inline SIMD_CFUNC simd_short2 __tg_isnormal(simd_half2 x); 1285 /*! @abstract Do not call this function; instead use `isnormal` in C and 1286 * Objective-C, and `simd::isnormal` in C++. */ 1287 static inline SIMD_CFUNC simd_short3 __tg_isnormal(simd_half3 x); 1288 /*! @abstract Do not call this function; instead use `isnormal` in C and 1289 * Objective-C, and `simd::isnormal` in C++. */ 1290 static inline SIMD_CFUNC simd_short4 __tg_isnormal(simd_half4 x); 1291 /*! @abstract Do not call this function; instead use `isnormal` in C and 1292 * Objective-C, and `simd::isnormal` in C++. */ 1293 static inline SIMD_CFUNC simd_short8 __tg_isnormal(simd_half8 x); 1294 /*! @abstract Do not call this function; instead use `isnormal` in C and 1295 * Objective-C, and `simd::isnormal` in C++. */ 1296 static inline SIMD_CFUNC simd_short16 __tg_isnormal(simd_half16 x); 1297 /*! @abstract Do not call this function; instead use `isnormal` in C and 1298 * Objective-C, and `simd::isnormal` in C++. */ 1299 static inline SIMD_CFUNC simd_short32 __tg_isnormal(simd_half32 x); 1300 /*! @abstract Do not call this function; instead use `isnormal` in C and 1301 * Objective-C, and `simd::isnormal` in C++. */ 1302 static inline SIMD_CFUNC simd_int2 __tg_isnormal(simd_float2 x); 1303 /*! @abstract Do not call this function; instead use `isnormal` in C and 1304 * Objective-C, and `simd::isnormal` in C++. */ 1305 static inline SIMD_CFUNC simd_int3 __tg_isnormal(simd_float3 x); 1306 /*! @abstract Do not call this function; instead use `isnormal` in C and 1307 * Objective-C, and `simd::isnormal` in C++. */ 1308 static inline SIMD_CFUNC simd_int4 __tg_isnormal(simd_float4 x); 1309 /*! @abstract Do not call this function; instead use `isnormal` in C and 1310 * Objective-C, and `simd::isnormal` in C++. */ 1311 static inline SIMD_CFUNC simd_int8 __tg_isnormal(simd_float8 x); 1312 /*! @abstract Do not call this function; instead use `isnormal` in C and 1313 * Objective-C, and `simd::isnormal` in C++. */ 1314 static inline SIMD_CFUNC simd_int16 __tg_isnormal(simd_float16 x); 1315 /*! @abstract Do not call this function; instead use `isnormal` in C and 1316 * Objective-C, and `simd::isnormal` in C++. */ 1317 static inline SIMD_CFUNC simd_long2 __tg_isnormal(simd_double2 x); 1318 /*! @abstract Do not call this function; instead use `isnormal` in C and 1319 * Objective-C, and `simd::isnormal` in C++. */ 1320 static inline SIMD_CFUNC simd_long3 __tg_isnormal(simd_double3 x); 1321 /*! @abstract Do not call this function; instead use `isnormal` in C and 1322 * Objective-C, and `simd::isnormal` in C++. */ 1323 static inline SIMD_CFUNC simd_long4 __tg_isnormal(simd_double4 x); 1324 /*! @abstract Do not call this function; instead use `isnormal` in C and 1325 * Objective-C, and `simd::isnormal` in C++. */ 1326 static inline SIMD_CFUNC simd_long8 __tg_isnormal(simd_double8 x); 1327 1328 /*! @abstract Do not call this function; instead use `fabs` in C and 1329 * Objective-C, and `simd::fabs` in C++. */ 1330 static inline SIMD_CFUNC simd_half2 __tg_fabs(simd_half2 x); 1331 /*! @abstract Do not call this function; instead use `fabs` in C and 1332 * Objective-C, and `simd::fabs` in C++. */ 1333 static inline SIMD_CFUNC simd_half3 __tg_fabs(simd_half3 x); 1334 /*! @abstract Do not call this function; instead use `fabs` in C and 1335 * Objective-C, and `simd::fabs` in C++. */ 1336 static inline SIMD_CFUNC simd_half4 __tg_fabs(simd_half4 x); 1337 /*! @abstract Do not call this function; instead use `fabs` in C and 1338 * Objective-C, and `simd::fabs` in C++. */ 1339 static inline SIMD_CFUNC simd_half8 __tg_fabs(simd_half8 x); 1340 /*! @abstract Do not call this function; instead use `fabs` in C and 1341 * Objective-C, and `simd::fabs` in C++. */ 1342 static inline SIMD_CFUNC simd_half16 __tg_fabs(simd_half16 x); 1343 /*! @abstract Do not call this function; instead use `fabs` in C and 1344 * Objective-C, and `simd::fabs` in C++. */ 1345 static inline SIMD_CFUNC simd_half32 __tg_fabs(simd_half32 x); 1346 1347 /*! @abstract Do not call this function; instead use `sqrt` in C and 1348 * Objective-C, and `simd::sqrt` in C++. */ 1349 static inline SIMD_CFUNC simd_half2 __tg_sqrt(simd_half2 x); 1350 /*! @abstract Do not call this function; instead use `sqrt` in C and 1351 * Objective-C, and `simd::sqrt` in C++. */ 1352 static inline SIMD_CFUNC simd_half3 __tg_sqrt(simd_half3 x); 1353 /*! @abstract Do not call this function; instead use `sqrt` in C and 1354 * Objective-C, and `simd::sqrt` in C++. */ 1355 static inline SIMD_CFUNC simd_half4 __tg_sqrt(simd_half4 x); 1356 /*! @abstract Do not call this function; instead use `sqrt` in C and 1357 * Objective-C, and `simd::sqrt` in C++. */ 1358 static inline SIMD_CFUNC simd_half8 __tg_sqrt(simd_half8 x); 1359 /*! @abstract Do not call this function; instead use `sqrt` in C and 1360 * Objective-C, and `simd::sqrt` in C++. */ 1361 static inline SIMD_CFUNC simd_half16 __tg_sqrt(simd_half16 x); 1362 /*! @abstract Do not call this function; instead use `sqrt` in C and 1363 * Objective-C, and `simd::sqrt` in C++. */ 1364 static inline SIMD_CFUNC simd_half32 __tg_sqrt(simd_half32 x); 1365 1366 /*! @abstract Do not call this function; instead use `ceil` in C and 1367 * Objective-C, and `simd::ceil` in C++. */ 1368 static inline SIMD_CFUNC simd_half2 __tg_ceil(simd_half2 x); 1369 /*! @abstract Do not call this function; instead use `ceil` in C and 1370 * Objective-C, and `simd::ceil` in C++. */ 1371 static inline SIMD_CFUNC simd_half3 __tg_ceil(simd_half3 x); 1372 /*! @abstract Do not call this function; instead use `ceil` in C and 1373 * Objective-C, and `simd::ceil` in C++. */ 1374 static inline SIMD_CFUNC simd_half4 __tg_ceil(simd_half4 x); 1375 /*! @abstract Do not call this function; instead use `ceil` in C and 1376 * Objective-C, and `simd::ceil` in C++. */ 1377 static inline SIMD_CFUNC simd_half8 __tg_ceil(simd_half8 x); 1378 /*! @abstract Do not call this function; instead use `ceil` in C and 1379 * Objective-C, and `simd::ceil` in C++. */ 1380 static inline SIMD_CFUNC simd_half16 __tg_ceil(simd_half16 x); 1381 /*! @abstract Do not call this function; instead use `ceil` in C and 1382 * Objective-C, and `simd::ceil` in C++. */ 1383 static inline SIMD_CFUNC simd_half32 __tg_ceil(simd_half32 x); 1384 1385 /*! @abstract Do not call this function; instead use `floor` in C and 1386 * Objective-C, and `simd::floor` in C++. */ 1387 static inline SIMD_CFUNC simd_half2 __tg_floor(simd_half2 x); 1388 /*! @abstract Do not call this function; instead use `floor` in C and 1389 * Objective-C, and `simd::floor` in C++. */ 1390 static inline SIMD_CFUNC simd_half3 __tg_floor(simd_half3 x); 1391 /*! @abstract Do not call this function; instead use `floor` in C and 1392 * Objective-C, and `simd::floor` in C++. */ 1393 static inline SIMD_CFUNC simd_half4 __tg_floor(simd_half4 x); 1394 /*! @abstract Do not call this function; instead use `floor` in C and 1395 * Objective-C, and `simd::floor` in C++. */ 1396 static inline SIMD_CFUNC simd_half8 __tg_floor(simd_half8 x); 1397 /*! @abstract Do not call this function; instead use `floor` in C and 1398 * Objective-C, and `simd::floor` in C++. */ 1399 static inline SIMD_CFUNC simd_half16 __tg_floor(simd_half16 x); 1400 /*! @abstract Do not call this function; instead use `floor` in C and 1401 * Objective-C, and `simd::floor` in C++. */ 1402 static inline SIMD_CFUNC simd_half32 __tg_floor(simd_half32 x); 1403 1404 /*! @abstract Do not call this function; instead use `rint` in C and 1405 * Objective-C, and `simd::rint` in C++. */ 1406 static inline SIMD_CFUNC simd_half2 __tg_rint(simd_half2 x); 1407 /*! @abstract Do not call this function; instead use `rint` in C and 1408 * Objective-C, and `simd::rint` in C++. */ 1409 static inline SIMD_CFUNC simd_half3 __tg_rint(simd_half3 x); 1410 /*! @abstract Do not call this function; instead use `rint` in C and 1411 * Objective-C, and `simd::rint` in C++. */ 1412 static inline SIMD_CFUNC simd_half4 __tg_rint(simd_half4 x); 1413 /*! @abstract Do not call this function; instead use `rint` in C and 1414 * Objective-C, and `simd::rint` in C++. */ 1415 static inline SIMD_CFUNC simd_half8 __tg_rint(simd_half8 x); 1416 /*! @abstract Do not call this function; instead use `rint` in C and 1417 * Objective-C, and `simd::rint` in C++. */ 1418 static inline SIMD_CFUNC simd_half16 __tg_rint(simd_half16 x); 1419 /*! @abstract Do not call this function; instead use `rint` in C and 1420 * Objective-C, and `simd::rint` in C++. */ 1421 static inline SIMD_CFUNC simd_half32 __tg_rint(simd_half32 x); 1422 1423 /*! @abstract Do not call this function; instead use `trunc` in C and 1424 * Objective-C, and `simd::trunc` in C++. */ 1425 static inline SIMD_CFUNC simd_half2 __tg_trunc(simd_half2 x); 1426 /*! @abstract Do not call this function; instead use `trunc` in C and 1427 * Objective-C, and `simd::trunc` in C++. */ 1428 static inline SIMD_CFUNC simd_half3 __tg_trunc(simd_half3 x); 1429 /*! @abstract Do not call this function; instead use `trunc` in C and 1430 * Objective-C, and `simd::trunc` in C++. */ 1431 static inline SIMD_CFUNC simd_half4 __tg_trunc(simd_half4 x); 1432 /*! @abstract Do not call this function; instead use `trunc` in C and 1433 * Objective-C, and `simd::trunc` in C++. */ 1434 static inline SIMD_CFUNC simd_half8 __tg_trunc(simd_half8 x); 1435 /*! @abstract Do not call this function; instead use `trunc` in C and 1436 * Objective-C, and `simd::trunc` in C++. */ 1437 static inline SIMD_CFUNC simd_half16 __tg_trunc(simd_half16 x); 1438 /*! @abstract Do not call this function; instead use `trunc` in C and 1439 * Objective-C, and `simd::trunc` in C++. */ 1440 static inline SIMD_CFUNC simd_half32 __tg_trunc(simd_half32 x); 1441 1442 1443 /*! @abstract Do not call this function; instead use `atan2` in C and 1444 * Objective-C, and `simd::atan2` in C++. */ 1445 static inline SIMD_CFUNC simd_float2 __tg_atan2(simd_float2 y, simd_float2 x); 1446 /*! @abstract Do not call this function; instead use `atan2` in C and 1447 * Objective-C, and `simd::atan2` in C++. */ 1448 static inline SIMD_CFUNC simd_float3 __tg_atan2(simd_float3 y, simd_float3 x); 1449 /*! @abstract Do not call this function; instead use `atan2` in C and 1450 * Objective-C, and `simd::atan2` in C++. */ 1451 static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x); 1452 /*! @abstract Do not call this function; instead use `atan2` in C and 1453 * Objective-C, and `simd::atan2` in C++. */ 1454 static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x); 1455 /*! @abstract Do not call this function; instead use `atan2` in C and 1456 * Objective-C, and `simd::atan2` in C++. */ 1457 static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x); 1458 /*! @abstract Do not call this function; instead use `atan2` in C and 1459 * Objective-C, and `simd::atan2` in C++. */ 1460 static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x); 1461 /*! @abstract Do not call this function; instead use `atan2` in C and 1462 * Objective-C, and `simd::atan2` in C++. */ 1463 static inline SIMD_CFUNC simd_double3 __tg_atan2(simd_double3 y, simd_double3 x); 1464 /*! @abstract Do not call this function; instead use `atan2` in C and 1465 * Objective-C, and `simd::atan2` in C++. */ 1466 static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x); 1467 /*! @abstract Do not call this function; instead use `atan2` in C and 1468 * Objective-C, and `simd::atan2` in C++. */ 1469 static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x); 1470 1471 /*! @abstract Do not call this function; instead use `hypot` in C and 1472 * Objective-C, and `simd::hypot` in C++. */ 1473 static inline SIMD_CFUNC simd_float2 __tg_hypot(simd_float2 x, simd_float2 y); 1474 /*! @abstract Do not call this function; instead use `hypot` in C and 1475 * Objective-C, and `simd::hypot` in C++. */ 1476 static inline SIMD_CFUNC simd_float3 __tg_hypot(simd_float3 x, simd_float3 y); 1477 /*! @abstract Do not call this function; instead use `hypot` in C and 1478 * Objective-C, and `simd::hypot` in C++. */ 1479 static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y); 1480 /*! @abstract Do not call this function; instead use `hypot` in C and 1481 * Objective-C, and `simd::hypot` in C++. */ 1482 static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y); 1483 /*! @abstract Do not call this function; instead use `hypot` in C and 1484 * Objective-C, and `simd::hypot` in C++. */ 1485 static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y); 1486 /*! @abstract Do not call this function; instead use `hypot` in C and 1487 * Objective-C, and `simd::hypot` in C++. */ 1488 static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y); 1489 /*! @abstract Do not call this function; instead use `hypot` in C and 1490 * Objective-C, and `simd::hypot` in C++. */ 1491 static inline SIMD_CFUNC simd_double3 __tg_hypot(simd_double3 x, simd_double3 y); 1492 /*! @abstract Do not call this function; instead use `hypot` in C and 1493 * Objective-C, and `simd::hypot` in C++. */ 1494 static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y); 1495 /*! @abstract Do not call this function; instead use `hypot` in C and 1496 * Objective-C, and `simd::hypot` in C++. */ 1497 static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y); 1498 1499 /*! @abstract Do not call this function; instead use `pow` in C and 1500 * Objective-C, and `simd::pow` in C++. */ 1501 static inline SIMD_CFUNC simd_float2 __tg_pow(simd_float2 x, simd_float2 y); 1502 /*! @abstract Do not call this function; instead use `pow` in C and 1503 * Objective-C, and `simd::pow` in C++. */ 1504 static inline SIMD_CFUNC simd_float3 __tg_pow(simd_float3 x, simd_float3 y); 1505 /*! @abstract Do not call this function; instead use `pow` in C and 1506 * Objective-C, and `simd::pow` in C++. */ 1507 static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y); 1508 /*! @abstract Do not call this function; instead use `pow` in C and 1509 * Objective-C, and `simd::pow` in C++. */ 1510 static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y); 1511 /*! @abstract Do not call this function; instead use `pow` in C and 1512 * Objective-C, and `simd::pow` in C++. */ 1513 static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y); 1514 /*! @abstract Do not call this function; instead use `pow` in C and 1515 * Objective-C, and `simd::pow` in C++. */ 1516 static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y); 1517 /*! @abstract Do not call this function; instead use `pow` in C and 1518 * Objective-C, and `simd::pow` in C++. */ 1519 static inline SIMD_CFUNC simd_double3 __tg_pow(simd_double3 x, simd_double3 y); 1520 /*! @abstract Do not call this function; instead use `pow` in C and 1521 * Objective-C, and `simd::pow` in C++. */ 1522 static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y); 1523 /*! @abstract Do not call this function; instead use `pow` in C and 1524 * Objective-C, and `simd::pow` in C++. */ 1525 static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y); 1526 1527 /*! @abstract Do not call this function; instead use `fmod` in C and 1528 * Objective-C, and `simd::fmod` in C++. */ 1529 static inline SIMD_CFUNC simd_float2 __tg_fmod(simd_float2 x, simd_float2 y); 1530 /*! @abstract Do not call this function; instead use `fmod` in C and 1531 * Objective-C, and `simd::fmod` in C++. */ 1532 static inline SIMD_CFUNC simd_float3 __tg_fmod(simd_float3 x, simd_float3 y); 1533 /*! @abstract Do not call this function; instead use `fmod` in C and 1534 * Objective-C, and `simd::fmod` in C++. */ 1535 static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y); 1536 /*! @abstract Do not call this function; instead use `fmod` in C and 1537 * Objective-C, and `simd::fmod` in C++. */ 1538 static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y); 1539 /*! @abstract Do not call this function; instead use `fmod` in C and 1540 * Objective-C, and `simd::fmod` in C++. */ 1541 static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y); 1542 /*! @abstract Do not call this function; instead use `fmod` in C and 1543 * Objective-C, and `simd::fmod` in C++. */ 1544 static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y); 1545 /*! @abstract Do not call this function; instead use `fmod` in C and 1546 * Objective-C, and `simd::fmod` in C++. */ 1547 static inline SIMD_CFUNC simd_double3 __tg_fmod(simd_double3 x, simd_double3 y); 1548 /*! @abstract Do not call this function; instead use `fmod` in C and 1549 * Objective-C, and `simd::fmod` in C++. */ 1550 static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y); 1551 /*! @abstract Do not call this function; instead use `fmod` in C and 1552 * Objective-C, and `simd::fmod` in C++. */ 1553 static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y); 1554 1555 /*! @abstract Do not call this function; instead use `remainder` in C and 1556 * Objective-C, and `simd::remainder` in C++. */ 1557 static inline SIMD_CFUNC simd_float2 __tg_remainder(simd_float2 x, simd_float2 y); 1558 /*! @abstract Do not call this function; instead use `remainder` in C and 1559 * Objective-C, and `simd::remainder` in C++. */ 1560 static inline SIMD_CFUNC simd_float3 __tg_remainder(simd_float3 x, simd_float3 y); 1561 /*! @abstract Do not call this function; instead use `remainder` in C and 1562 * Objective-C, and `simd::remainder` in C++. */ 1563 static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y); 1564 /*! @abstract Do not call this function; instead use `remainder` in C and 1565 * Objective-C, and `simd::remainder` in C++. */ 1566 static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y); 1567 /*! @abstract Do not call this function; instead use `remainder` in C and 1568 * Objective-C, and `simd::remainder` in C++. */ 1569 static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y); 1570 /*! @abstract Do not call this function; instead use `remainder` in C and 1571 * Objective-C, and `simd::remainder` in C++. */ 1572 static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y); 1573 /*! @abstract Do not call this function; instead use `remainder` in C and 1574 * Objective-C, and `simd::remainder` in C++. */ 1575 static inline SIMD_CFUNC simd_double3 __tg_remainder(simd_double3 x, simd_double3 y); 1576 /*! @abstract Do not call this function; instead use `remainder` in C and 1577 * Objective-C, and `simd::remainder` in C++. */ 1578 static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y); 1579 /*! @abstract Do not call this function; instead use `remainder` in C and 1580 * Objective-C, and `simd::remainder` in C++. */ 1581 static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y); 1582 1583 /*! @abstract Do not call this function; instead use `copysign` in C and 1584 * Objective-C, and `simd::copysign` in C++. */ 1585 static inline SIMD_CFUNC simd_float2 __tg_copysign(simd_float2 x, simd_float2 y); 1586 /*! @abstract Do not call this function; instead use `copysign` in C and 1587 * Objective-C, and `simd::copysign` in C++. */ 1588 static inline SIMD_CFUNC simd_float3 __tg_copysign(simd_float3 x, simd_float3 y); 1589 /*! @abstract Do not call this function; instead use `copysign` in C and 1590 * Objective-C, and `simd::copysign` in C++. */ 1591 static inline SIMD_CFUNC simd_float4 __tg_copysign(simd_float4 x, simd_float4 y); 1592 /*! @abstract Do not call this function; instead use `copysign` in C and 1593 * Objective-C, and `simd::copysign` in C++. */ 1594 static inline SIMD_CFUNC simd_float8 __tg_copysign(simd_float8 x, simd_float8 y); 1595 /*! @abstract Do not call this function; instead use `copysign` in C and 1596 * Objective-C, and `simd::copysign` in C++. */ 1597 static inline SIMD_CFUNC simd_float16 __tg_copysign(simd_float16 x, simd_float16 y); 1598 /*! @abstract Do not call this function; instead use `copysign` in C and 1599 * Objective-C, and `simd::copysign` in C++. */ 1600 static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y); 1601 /*! @abstract Do not call this function; instead use `copysign` in C and 1602 * Objective-C, and `simd::copysign` in C++. */ 1603 static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y); 1604 /*! @abstract Do not call this function; instead use `copysign` in C and 1605 * Objective-C, and `simd::copysign` in C++. */ 1606 static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y); 1607 /*! @abstract Do not call this function; instead use `copysign` in C and 1608 * Objective-C, and `simd::copysign` in C++. */ 1609 static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y); 1610 1611 /*! @abstract Do not call this function; instead use `nextafter` in C and 1612 * Objective-C, and `simd::nextafter` in C++. */ 1613 static inline SIMD_CFUNC simd_float2 __tg_nextafter(simd_float2 x, simd_float2 y); 1614 /*! @abstract Do not call this function; instead use `nextafter` in C and 1615 * Objective-C, and `simd::nextafter` in C++. */ 1616 static inline SIMD_CFUNC simd_float3 __tg_nextafter(simd_float3 x, simd_float3 y); 1617 /*! @abstract Do not call this function; instead use `nextafter` in C and 1618 * Objective-C, and `simd::nextafter` in C++. */ 1619 static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y); 1620 /*! @abstract Do not call this function; instead use `nextafter` in C and 1621 * Objective-C, and `simd::nextafter` in C++. */ 1622 static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y); 1623 /*! @abstract Do not call this function; instead use `nextafter` in C and 1624 * Objective-C, and `simd::nextafter` in C++. */ 1625 static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y); 1626 /*! @abstract Do not call this function; instead use `nextafter` in C and 1627 * Objective-C, and `simd::nextafter` in C++. */ 1628 static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y); 1629 /*! @abstract Do not call this function; instead use `nextafter` in C and 1630 * Objective-C, and `simd::nextafter` in C++. */ 1631 static inline SIMD_CFUNC simd_double3 __tg_nextafter(simd_double3 x, simd_double3 y); 1632 /*! @abstract Do not call this function; instead use `nextafter` in C and 1633 * Objective-C, and `simd::nextafter` in C++. */ 1634 static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y); 1635 /*! @abstract Do not call this function; instead use `nextafter` in C and 1636 * Objective-C, and `simd::nextafter` in C++. */ 1637 static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y); 1638 1639 /*! @abstract Do not call this function; instead use `fdim` in C and 1640 * Objective-C, and `simd::fdim` in C++. */ 1641 static inline SIMD_CFUNC simd_float2 __tg_fdim(simd_float2 x, simd_float2 y); 1642 /*! @abstract Do not call this function; instead use `fdim` in C and 1643 * Objective-C, and `simd::fdim` in C++. */ 1644 static inline SIMD_CFUNC simd_float3 __tg_fdim(simd_float3 x, simd_float3 y); 1645 /*! @abstract Do not call this function; instead use `fdim` in C and 1646 * Objective-C, and `simd::fdim` in C++. */ 1647 static inline SIMD_CFUNC simd_float4 __tg_fdim(simd_float4 x, simd_float4 y); 1648 /*! @abstract Do not call this function; instead use `fdim` in C and 1649 * Objective-C, and `simd::fdim` in C++. */ 1650 static inline SIMD_CFUNC simd_float8 __tg_fdim(simd_float8 x, simd_float8 y); 1651 /*! @abstract Do not call this function; instead use `fdim` in C and 1652 * Objective-C, and `simd::fdim` in C++. */ 1653 static inline SIMD_CFUNC simd_float16 __tg_fdim(simd_float16 x, simd_float16 y); 1654 /*! @abstract Do not call this function; instead use `fdim` in C and 1655 * Objective-C, and `simd::fdim` in C++. */ 1656 static inline SIMD_CFUNC simd_double2 __tg_fdim(simd_double2 x, simd_double2 y); 1657 /*! @abstract Do not call this function; instead use `fdim` in C and 1658 * Objective-C, and `simd::fdim` in C++. */ 1659 static inline SIMD_CFUNC simd_double3 __tg_fdim(simd_double3 x, simd_double3 y); 1660 /*! @abstract Do not call this function; instead use `fdim` in C and 1661 * Objective-C, and `simd::fdim` in C++. */ 1662 static inline SIMD_CFUNC simd_double4 __tg_fdim(simd_double4 x, simd_double4 y); 1663 /*! @abstract Do not call this function; instead use `fdim` in C and 1664 * Objective-C, and `simd::fdim` in C++. */ 1665 static inline SIMD_CFUNC simd_double8 __tg_fdim(simd_double8 x, simd_double8 y); 1666 1667 /*! @abstract Do not call this function; instead use `fmax` in C and 1668 * Objective-C, and `simd::fmax` in C++. */ 1669 static inline SIMD_CFUNC simd_float2 __tg_fmax(simd_float2 x, simd_float2 y); 1670 /*! @abstract Do not call this function; instead use `fmax` in C and 1671 * Objective-C, and `simd::fmax` in C++. */ 1672 static inline SIMD_CFUNC simd_float3 __tg_fmax(simd_float3 x, simd_float3 y); 1673 /*! @abstract Do not call this function; instead use `fmax` in C and 1674 * Objective-C, and `simd::fmax` in C++. */ 1675 static inline SIMD_CFUNC simd_float4 __tg_fmax(simd_float4 x, simd_float4 y); 1676 /*! @abstract Do not call this function; instead use `fmax` in C and 1677 * Objective-C, and `simd::fmax` in C++. */ 1678 static inline SIMD_CFUNC simd_float8 __tg_fmax(simd_float8 x, simd_float8 y); 1679 /*! @abstract Do not call this function; instead use `fmax` in C and 1680 * Objective-C, and `simd::fmax` in C++. */ 1681 static inline SIMD_CFUNC simd_float16 __tg_fmax(simd_float16 x, simd_float16 y); 1682 /*! @abstract Do not call this function; instead use `fmax` in C and 1683 * Objective-C, and `simd::fmax` in C++. */ 1684 static inline SIMD_CFUNC simd_double2 __tg_fmax(simd_double2 x, simd_double2 y); 1685 /*! @abstract Do not call this function; instead use `fmax` in C and 1686 * Objective-C, and `simd::fmax` in C++. */ 1687 static inline SIMD_CFUNC simd_double3 __tg_fmax(simd_double3 x, simd_double3 y); 1688 /*! @abstract Do not call this function; instead use `fmax` in C and 1689 * Objective-C, and `simd::fmax` in C++. */ 1690 static inline SIMD_CFUNC simd_double4 __tg_fmax(simd_double4 x, simd_double4 y); 1691 /*! @abstract Do not call this function; instead use `fmax` in C and 1692 * Objective-C, and `simd::fmax` in C++. */ 1693 static inline SIMD_CFUNC simd_double8 __tg_fmax(simd_double8 x, simd_double8 y); 1694 1695 /*! @abstract Do not call this function; instead use `fmin` in C and 1696 * Objective-C, and `simd::fmin` in C++. */ 1697 static inline SIMD_CFUNC simd_float2 __tg_fmin(simd_float2 x, simd_float2 y); 1698 /*! @abstract Do not call this function; instead use `fmin` in C and 1699 * Objective-C, and `simd::fmin` in C++. */ 1700 static inline SIMD_CFUNC simd_float3 __tg_fmin(simd_float3 x, simd_float3 y); 1701 /*! @abstract Do not call this function; instead use `fmin` in C and 1702 * Objective-C, and `simd::fmin` in C++. */ 1703 static inline SIMD_CFUNC simd_float4 __tg_fmin(simd_float4 x, simd_float4 y); 1704 /*! @abstract Do not call this function; instead use `fmin` in C and 1705 * Objective-C, and `simd::fmin` in C++. */ 1706 static inline SIMD_CFUNC simd_float8 __tg_fmin(simd_float8 x, simd_float8 y); 1707 /*! @abstract Do not call this function; instead use `fmin` in C and 1708 * Objective-C, and `simd::fmin` in C++. */ 1709 static inline SIMD_CFUNC simd_float16 __tg_fmin(simd_float16 x, simd_float16 y); 1710 /*! @abstract Do not call this function; instead use `fmin` in C and 1711 * Objective-C, and `simd::fmin` in C++. */ 1712 static inline SIMD_CFUNC simd_double2 __tg_fmin(simd_double2 x, simd_double2 y); 1713 /*! @abstract Do not call this function; instead use `fmin` in C and 1714 * Objective-C, and `simd::fmin` in C++. */ 1715 static inline SIMD_CFUNC simd_double3 __tg_fmin(simd_double3 x, simd_double3 y); 1716 /*! @abstract Do not call this function; instead use `fmin` in C and 1717 * Objective-C, and `simd::fmin` in C++. */ 1718 static inline SIMD_CFUNC simd_double4 __tg_fmin(simd_double4 x, simd_double4 y); 1719 /*! @abstract Do not call this function; instead use `fmin` in C and 1720 * Objective-C, and `simd::fmin` in C++. */ 1721 static inline SIMD_CFUNC simd_double8 __tg_fmin(simd_double8 x, simd_double8 y); 1722 1723 /*! @abstract Do not call this function; instead use `fmin` in C and 1724 * Objective-C, and `simd::fmin` in C++. */ 1725 static inline SIMD_CFUNC simd_half2 __tg_fmin(simd_half2 x, simd_half2 y); 1726 /*! @abstract Do not call this function; instead use `fmin` in C and 1727 * Objective-C, and `simd::fmin` in C++. */ 1728 static inline SIMD_CFUNC simd_half3 __tg_fmin(simd_half3 x, simd_half3 y); 1729 /*! @abstract Do not call this function; instead use `fmin` in C and 1730 * Objective-C, and `simd::fmin` in C++. */ 1731 static inline SIMD_CFUNC simd_half4 __tg_fmin(simd_half4 x, simd_half4 y); 1732 /*! @abstract Do not call this function; instead use `fmin` in C and 1733 * Objective-C, and `simd::fmin` in C++. */ 1734 static inline SIMD_CFUNC simd_half8 __tg_fmin(simd_half8 x, simd_half8 y); 1735 /*! @abstract Do not call this function; instead use `fmin` in C and 1736 * Objective-C, and `simd::fmin` in C++. */ 1737 static inline SIMD_CFUNC simd_half16 __tg_fmin(simd_half16 x, simd_half16 y); 1738 /*! @abstract Do not call this function; instead use `fmin` in C and 1739 * Objective-C, and `simd::fmin` in C++. */ 1740 static inline SIMD_CFUNC simd_half32 __tg_fmin(simd_half32 x, simd_half32 y); 1741 1742 /*! @abstract Do not call this function; instead use `fmax` in C and 1743 * Objective-C, and `simd::fmax` in C++. */ 1744 static inline SIMD_CFUNC simd_half2 __tg_fmax(simd_half2 x, simd_half2 y); 1745 /*! @abstract Do not call this function; instead use `fmax` in C and 1746 * Objective-C, and `simd::fmax` in C++. */ 1747 static inline SIMD_CFUNC simd_half3 __tg_fmax(simd_half3 x, simd_half3 y); 1748 /*! @abstract Do not call this function; instead use `fmax` in C and 1749 * Objective-C, and `simd::fmax` in C++. */ 1750 static inline SIMD_CFUNC simd_half4 __tg_fmax(simd_half4 x, simd_half4 y); 1751 /*! @abstract Do not call this function; instead use `fmax` in C and 1752 * Objective-C, and `simd::fmax` in C++. */ 1753 static inline SIMD_CFUNC simd_half8 __tg_fmax(simd_half8 x, simd_half8 y); 1754 /*! @abstract Do not call this function; instead use `fmax` in C and 1755 * Objective-C, and `simd::fmax` in C++. */ 1756 static inline SIMD_CFUNC simd_half16 __tg_fmax(simd_half16 x, simd_half16 y); 1757 /*! @abstract Do not call this function; instead use `fmax` in C and 1758 * Objective-C, and `simd::fmax` in C++. */ 1759 static inline SIMD_CFUNC simd_half32 __tg_fmax(simd_half32 x, simd_half32 y); 1760 1761 /*! @abstract Do not call this function; instead use `copysign` in C and 1762 * Objective-C, and `simd::copysign` in C++. */ 1763 static inline SIMD_CFUNC simd_half2 __tg_copysign(simd_half2 x, simd_half2 y); 1764 /*! @abstract Do not call this function; instead use `copysign` in C and 1765 * Objective-C, and `simd::copysign` in C++. */ 1766 static inline SIMD_CFUNC simd_half3 __tg_copysign(simd_half3 x, simd_half3 y); 1767 /*! @abstract Do not call this function; instead use `copysign` in C and 1768 * Objective-C, and `simd::copysign` in C++. */ 1769 static inline SIMD_CFUNC simd_half4 __tg_copysign(simd_half4 x, simd_half4 y); 1770 /*! @abstract Do not call this function; instead use `copysign` in C and 1771 * Objective-C, and `simd::copysign` in C++. */ 1772 static inline SIMD_CFUNC simd_half8 __tg_copysign(simd_half8 x, simd_half8 y); 1773 /*! @abstract Do not call this function; instead use `copysign` in C and 1774 * Objective-C, and `simd::copysign` in C++. */ 1775 static inline SIMD_CFUNC simd_half16 __tg_copysign(simd_half16 x, simd_half16 y); 1776 /*! @abstract Do not call this function; instead use `copysign` in C and 1777 * Objective-C, and `simd::copysign` in C++. */ 1778 static inline SIMD_CFUNC simd_half32 __tg_copysign(simd_half32 x, simd_half32 y); 1779 1780 1781 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1782 * and `simd::fma` in C++. */ 1783 static inline SIMD_CFUNC simd_float2 __tg_fma(simd_float2 x, simd_float2 y, simd_float2 z); 1784 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1785 * and `simd::fma` in C++. */ 1786 static inline SIMD_CFUNC simd_float3 __tg_fma(simd_float3 x, simd_float3 y, simd_float3 z); 1787 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1788 * and `simd::fma` in C++. */ 1789 static inline SIMD_CFUNC simd_float4 __tg_fma(simd_float4 x, simd_float4 y, simd_float4 z); 1790 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1791 * and `simd::fma` in C++. */ 1792 static inline SIMD_CFUNC simd_float8 __tg_fma(simd_float8 x, simd_float8 y, simd_float8 z); 1793 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1794 * and `simd::fma` in C++. */ 1795 static inline SIMD_CFUNC simd_float16 __tg_fma(simd_float16 x, simd_float16 y, simd_float16 z); 1796 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1797 * and `simd::fma` in C++. */ 1798 static inline SIMD_CFUNC simd_double2 __tg_fma(simd_double2 x, simd_double2 y, simd_double2 z); 1799 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1800 * and `simd::fma` in C++. */ 1801 static inline SIMD_CFUNC simd_double3 __tg_fma(simd_double3 x, simd_double3 y, simd_double3 z); 1802 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1803 * and `simd::fma` in C++. */ 1804 static inline SIMD_CFUNC simd_double4 __tg_fma(simd_double4 x, simd_double4 y, simd_double4 z); 1805 /*! @abstract Do not call this function; instead use `fma` in C and Objective-C, 1806 * and `simd::fma` in C++. */ 1807 static inline SIMD_CFUNC simd_double8 __tg_fma(simd_double8 x, simd_double8 y, simd_double8 z); 1808 1809 /*! @abstract Computes accum + x*y by the most efficient means available; 1810 * either a fused multiply add or separate multiply and add instructions. */ 1811 static inline SIMD_CFUNC _Float16 simd_muladd(_Float16 x, _Float16 y, _Float16 z); 1812 /*! @abstract Computes accum + x*y by the most efficient means available; 1813 * either a fused multiply add or separate multiply and add instructions. */ 1814 static inline SIMD_CFUNC simd_half2 simd_muladd(simd_half2 x, simd_half2 y, simd_half2 z); 1815 /*! @abstract Computes accum + x*y by the most efficient means available; 1816 * either a fused multiply add or separate multiply and add instructions. */ 1817 static inline SIMD_CFUNC simd_half3 simd_muladd(simd_half3 x, simd_half3 y, simd_half3 z); 1818 /*! @abstract Computes accum + x*y by the most efficient means available; 1819 * either a fused multiply add or separate multiply and add instructions. */ 1820 static inline SIMD_CFUNC simd_half4 simd_muladd(simd_half4 x, simd_half4 y, simd_half4 z); 1821 /*! @abstract Computes accum + x*y by the most efficient means available; 1822 * either a fused multiply add or separate multiply and add instructions. */ 1823 static inline SIMD_CFUNC simd_half8 simd_muladd(simd_half8 x, simd_half8 y, simd_half8 z); 1824 /*! @abstract Computes accum + x*y by the most efficient means available; 1825 * either a fused multiply add or separate multiply and add instructions. */ 1826 static inline SIMD_CFUNC simd_half16 simd_muladd(simd_half16 x, simd_half16 y, simd_half16 z); 1827 /*! @abstract Computes accum + x*y by the most efficient means available; 1828 * either a fused multiply add or separate multiply and add instructions. */ 1829 static inline SIMD_CFUNC simd_half32 simd_muladd(simd_half32 x, simd_half32 y, simd_half32 z); 1830 /*! @abstract Computes accum + x*y by the most efficient means available; 1831 * either a fused multiply add or separate multiply and add instructions. */ 1832 static inline SIMD_CFUNC float simd_muladd(float x, float y, float z); 1833 /*! @abstract Computes accum + x*y by the most efficient means available; 1834 * either a fused multiply add or separate multiply and add instructions. */ 1835 static inline SIMD_CFUNC simd_float2 simd_muladd(simd_float2 x, simd_float2 y, simd_float2 z); 1836 /*! @abstract Computes accum + x*y by the most efficient means available; 1837 * either a fused multiply add or separate multiply and add instructions. */ 1838 static inline SIMD_CFUNC simd_float3 simd_muladd(simd_float3 x, simd_float3 y, simd_float3 z); 1839 /*! @abstract Computes accum + x*y by the most efficient means available; 1840 * either a fused multiply add or separate multiply and add instructions. */ 1841 static inline SIMD_CFUNC simd_float4 simd_muladd(simd_float4 x, simd_float4 y, simd_float4 z); 1842 /*! @abstract Computes accum + x*y by the most efficient means available; 1843 * either a fused multiply add or separate multiply and add instructions. */ 1844 static inline SIMD_CFUNC simd_float8 simd_muladd(simd_float8 x, simd_float8 y, simd_float8 z); 1845 /*! @abstract Computes accum + x*y by the most efficient means available; 1846 * either a fused multiply add or separate multiply and add instructions. */ 1847 static inline SIMD_CFUNC simd_float16 simd_muladd(simd_float16 x, simd_float16 y, simd_float16 z); 1848 /*! @abstract Computes accum + x*y by the most efficient means available; 1849 * either a fused multiply add or separate multiply and add instructions. */ 1850 static inline SIMD_CFUNC double simd_muladd(double x, double y, double z); 1851 /*! @abstract Computes accum + x*y by the most efficient means available; 1852 * either a fused multiply add or separate multiply and add instructions. */ 1853 static inline SIMD_CFUNC simd_double2 simd_muladd(simd_double2 x, simd_double2 y, simd_double2 z); 1854 /*! @abstract Computes accum + x*y by the most efficient means available; 1855 * either a fused multiply add or separate multiply and add instructions. */ 1856 static inline SIMD_CFUNC simd_double3 simd_muladd(simd_double3 x, simd_double3 y, simd_double3 z); 1857 /*! @abstract Computes accum + x*y by the most efficient means available; 1858 * either a fused multiply add or separate multiply and add instructions. */ 1859 static inline SIMD_CFUNC simd_double4 simd_muladd(simd_double4 x, simd_double4 y, simd_double4 z); 1860 /*! @abstract Computes accum + x*y by the most efficient means available; 1861 * either a fused multiply add or separate multiply and add instructions. */ 1862 static inline SIMD_CFUNC simd_double8 simd_muladd(simd_double8 x, simd_double8 y, simd_double8 z); 1863 1864 #ifdef __cplusplus 1865 } /* extern "C" */ 1866 1867 #include <cmath> 1868 /*! @abstract Do not call this function directly; use simd::acos instead. */ 1869 static SIMD_CPPFUNC float __tg_acos(float x) { return ::acosf(x); } 1870 /*! @abstract Do not call this function directly; use simd::acos instead. */ 1871 static SIMD_CPPFUNC double __tg_acos(double x) { return ::acos(x); } 1872 /*! @abstract Do not call this function directly; use simd::asin instead. */ 1873 static SIMD_CPPFUNC float __tg_asin(float x) { return ::asinf(x); } 1874 /*! @abstract Do not call this function directly; use simd::asin instead. */ 1875 static SIMD_CPPFUNC double __tg_asin(double x) { return ::asin(x); } 1876 /*! @abstract Do not call this function directly; use simd::atan instead. */ 1877 static SIMD_CPPFUNC float __tg_atan(float x) { return ::atanf(x); } 1878 /*! @abstract Do not call this function directly; use simd::atan instead. */ 1879 static SIMD_CPPFUNC double __tg_atan(double x) { return ::atan(x); } 1880 /*! @abstract Do not call this function directly; use simd::cos instead. */ 1881 static SIMD_CPPFUNC float __tg_cos(float x) { return ::cosf(x); } 1882 /*! @abstract Do not call this function directly; use simd::cos instead. */ 1883 static SIMD_CPPFUNC double __tg_cos(double x) { return ::cos(x); } 1884 /*! @abstract Do not call this function directly; use simd::sin instead. */ 1885 static SIMD_CPPFUNC float __tg_sin(float x) { return ::sinf(x); } 1886 /*! @abstract Do not call this function directly; use simd::sin instead. */ 1887 static SIMD_CPPFUNC double __tg_sin(double x) { return ::sin(x); } 1888 /*! @abstract Do not call this function directly; use simd::tan instead. */ 1889 static SIMD_CPPFUNC float __tg_tan(float x) { return ::tanf(x); } 1890 /*! @abstract Do not call this function directly; use simd::tan instead. */ 1891 static SIMD_CPPFUNC double __tg_tan(double x) { return ::tan(x); } 1892 /*! @abstract Do not call this function directly; use simd::cospi instead. */ 1893 static SIMD_CPPFUNC float __tg_cospi(float x) { return ::__cospif(x); } 1894 /*! @abstract Do not call this function directly; use simd::cospi instead. */ 1895 static SIMD_CPPFUNC double __tg_cospi(double x) { return ::__cospi(x); } 1896 /*! @abstract Do not call this function directly; use simd::sinpi instead. */ 1897 static SIMD_CPPFUNC float __tg_sinpi(float x) { return ::__sinpif(x); } 1898 /*! @abstract Do not call this function directly; use simd::sinpi instead. */ 1899 static SIMD_CPPFUNC double __tg_sinpi(double x) { return ::__sinpi(x); } 1900 /*! @abstract Do not call this function directly; use simd::tanpi instead. */ 1901 static SIMD_CPPFUNC float __tg_tanpi(float x) { return ::__tanpif(x); } 1902 /*! @abstract Do not call this function directly; use simd::tanpi instead. */ 1903 static SIMD_CPPFUNC double __tg_tanpi(double x) { return ::__tanpi(x); } 1904 /*! @abstract Do not call this function directly; use simd::acosh instead. */ 1905 static SIMD_CPPFUNC float __tg_acosh(float x) { return ::acoshf(x); } 1906 /*! @abstract Do not call this function directly; use simd::acosh instead. */ 1907 static SIMD_CPPFUNC double __tg_acosh(double x) { return ::acosh(x); } 1908 /*! @abstract Do not call this function directly; use simd::asinh instead. */ 1909 static SIMD_CPPFUNC float __tg_asinh(float x) { return ::asinhf(x); } 1910 /*! @abstract Do not call this function directly; use simd::asinh instead. */ 1911 static SIMD_CPPFUNC double __tg_asinh(double x) { return ::asinh(x); } 1912 /*! @abstract Do not call this function directly; use simd::atanh instead. */ 1913 static SIMD_CPPFUNC float __tg_atanh(float x) { return ::atanhf(x); } 1914 /*! @abstract Do not call this function directly; use simd::atanh instead. */ 1915 static SIMD_CPPFUNC double __tg_atanh(double x) { return ::atanh(x); } 1916 /*! @abstract Do not call this function directly; use simd::cosh instead. */ 1917 static SIMD_CPPFUNC float __tg_cosh(float x) { return ::coshf(x); } 1918 /*! @abstract Do not call this function directly; use simd::cosh instead. */ 1919 static SIMD_CPPFUNC double __tg_cosh(double x) { return ::cosh(x); } 1920 /*! @abstract Do not call this function directly; use simd::sinh instead. */ 1921 static SIMD_CPPFUNC float __tg_sinh(float x) { return ::sinhf(x); } 1922 /*! @abstract Do not call this function directly; use simd::sinh instead. */ 1923 static SIMD_CPPFUNC double __tg_sinh(double x) { return ::sinh(x); } 1924 /*! @abstract Do not call this function directly; use simd::tanh instead. */ 1925 static SIMD_CPPFUNC float __tg_tanh(float x) { return ::tanhf(x); } 1926 /*! @abstract Do not call this function directly; use simd::tanh instead. */ 1927 static SIMD_CPPFUNC double __tg_tanh(double x) { return ::tanh(x); } 1928 /*! @abstract Do not call this function directly; use simd::exp instead. */ 1929 static SIMD_CPPFUNC float __tg_exp(float x) { return ::expf(x); } 1930 /*! @abstract Do not call this function directly; use simd::exp instead. */ 1931 static SIMD_CPPFUNC double __tg_exp(double x) { return ::exp(x); } 1932 /*! @abstract Do not call this function directly; use simd::exp2 instead. */ 1933 static SIMD_CPPFUNC float __tg_exp2(float x) { return ::exp2f(x); } 1934 /*! @abstract Do not call this function directly; use simd::exp2 instead. */ 1935 static SIMD_CPPFUNC double __tg_exp2(double x) { return ::exp2(x); } 1936 /*! @abstract Do not call this function directly; use simd::exp10 instead. */ 1937 static SIMD_CPPFUNC float __tg_exp10(float x) { return ::__exp10f(x); } 1938 /*! @abstract Do not call this function directly; use simd::exp10 instead. */ 1939 static SIMD_CPPFUNC double __tg_exp10(double x) { return ::__exp10(x); } 1940 /*! @abstract Do not call this function directly; use simd::expm1 instead. */ 1941 static SIMD_CPPFUNC float __tg_expm1(float x) { return ::expm1f(x); } 1942 /*! @abstract Do not call this function directly; use simd::expm1 instead. */ 1943 static SIMD_CPPFUNC double __tg_expm1(double x) { return ::expm1(x); } 1944 /*! @abstract Do not call this function directly; use simd::log instead. */ 1945 static SIMD_CPPFUNC float __tg_log(float x) { return ::logf(x); } 1946 /*! @abstract Do not call this function directly; use simd::log instead. */ 1947 static SIMD_CPPFUNC double __tg_log(double x) { return ::log(x); } 1948 /*! @abstract Do not call this function directly; use simd::log2 instead. */ 1949 static SIMD_CPPFUNC float __tg_log2(float x) { return ::log2f(x); } 1950 /*! @abstract Do not call this function directly; use simd::log2 instead. */ 1951 static SIMD_CPPFUNC double __tg_log2(double x) { return ::log2(x); } 1952 /*! @abstract Do not call this function directly; use simd::log10 instead. */ 1953 static SIMD_CPPFUNC float __tg_log10(float x) { return ::log10f(x); } 1954 /*! @abstract Do not call this function directly; use simd::log10 instead. */ 1955 static SIMD_CPPFUNC double __tg_log10(double x) { return ::log10(x); } 1956 /*! @abstract Do not call this function directly; use simd::log1p instead. */ 1957 static SIMD_CPPFUNC float __tg_log1p(float x) { return ::log1pf(x); } 1958 /*! @abstract Do not call this function directly; use simd::log1p instead. */ 1959 static SIMD_CPPFUNC double __tg_log1p(double x) { return ::log1p(x); } 1960 /*! @abstract Do not call this function directly; use simd::fabs instead. */ 1961 static SIMD_CPPFUNC float __tg_fabs(float x) { return ::fabsf(x); } 1962 /*! @abstract Do not call this function directly; use simd::fabs instead. */ 1963 static SIMD_CPPFUNC double __tg_fabs(double x) { return ::fabs(x); } 1964 /*! @abstract Do not call this function directly; use simd::cbrt instead. */ 1965 static SIMD_CPPFUNC float __tg_cbrt(float x) { return ::cbrtf(x); } 1966 /*! @abstract Do not call this function directly; use simd::cbrt instead. */ 1967 static SIMD_CPPFUNC double __tg_cbrt(double x) { return ::cbrt(x); } 1968 /*! @abstract Do not call this function directly; use simd::sqrt instead. */ 1969 static SIMD_CPPFUNC float __tg_sqrt(float x) { return ::sqrtf(x); } 1970 /*! @abstract Do not call this function directly; use simd::sqrt instead. */ 1971 static SIMD_CPPFUNC double __tg_sqrt(double x) { return ::sqrt(x); } 1972 /*! @abstract Do not call this function directly; use simd::erf instead. */ 1973 static SIMD_CPPFUNC float __tg_erf(float x) { return ::erff(x); } 1974 /*! @abstract Do not call this function directly; use simd::erf instead. */ 1975 static SIMD_CPPFUNC double __tg_erf(double x) { return ::erf(x); } 1976 /*! @abstract Do not call this function directly; use simd::erfc instead. */ 1977 static SIMD_CPPFUNC float __tg_erfc(float x) { return ::erfcf(x); } 1978 /*! @abstract Do not call this function directly; use simd::erfc instead. */ 1979 static SIMD_CPPFUNC double __tg_erfc(double x) { return ::erfc(x); } 1980 /*! @abstract Do not call this function directly; use simd::tgamma instead. */ 1981 static SIMD_CPPFUNC float __tg_tgamma(float x) { return ::tgammaf(x); } 1982 /*! @abstract Do not call this function directly; use simd::tgamma instead. */ 1983 static SIMD_CPPFUNC double __tg_tgamma(double x) { return ::tgamma(x); } 1984 /*! @abstract Do not call this function directly; use simd::lgamma instead. */ 1985 static SIMD_CPPFUNC float __tg_lgamma(float x) { return ::lgammaf(x); } 1986 /*! @abstract Do not call this function directly; use simd::lgamma instead. */ 1987 static SIMD_CPPFUNC double __tg_lgamma(double x) { return ::lgamma(x); } 1988 /*! @abstract Do not call this function directly; use simd::ceil instead. */ 1989 static SIMD_CPPFUNC float __tg_ceil(float x) { return ::ceilf(x); } 1990 /*! @abstract Do not call this function directly; use simd::ceil instead. */ 1991 static SIMD_CPPFUNC double __tg_ceil(double x) { return ::ceil(x); } 1992 /*! @abstract Do not call this function directly; use simd::floor instead. */ 1993 static SIMD_CPPFUNC float __tg_floor(float x) { return ::floorf(x); } 1994 /*! @abstract Do not call this function directly; use simd::floor instead. */ 1995 static SIMD_CPPFUNC double __tg_floor(double x) { return ::floor(x); } 1996 /*! @abstract Do not call this function directly; use simd::rint instead. */ 1997 static SIMD_CPPFUNC float __tg_rint(float x) { return ::rintf(x); } 1998 /*! @abstract Do not call this function directly; use simd::rint instead. */ 1999 static SIMD_CPPFUNC double __tg_rint(double x) { return ::rint(x); } 2000 /*! @abstract Do not call this function directly; use simd::round instead. */ 2001 static SIMD_CPPFUNC float __tg_round(float x) { return ::roundf(x); } 2002 /*! @abstract Do not call this function directly; use simd::round instead. */ 2003 static SIMD_CPPFUNC double __tg_round(double x) { return ::round(x); } 2004 /*! @abstract Do not call this function directly; use simd::trunc instead. */ 2005 static SIMD_CPPFUNC float __tg_trunc(float x) { return ::truncf(x); } 2006 /*! @abstract Do not call this function directly; use simd::trunc instead. */ 2007 static SIMD_CPPFUNC double __tg_trunc(double x) { return ::trunc(x); } 2008 #if SIMD_LIBRARY_VERSION >= 5 2009 /*! @abstract Do not call this function directly; use simd::sincos instead. */ 2010 static SIMD_INLINE SIMD_NODEBUG void __tg_sincos(float x, float *sinp, float *cosp) { ::__sincosf(x, sinp, cosp); } 2011 /*! @abstract Do not call this function directly; use simd::sincos instead. */ 2012 static SIMD_INLINE SIMD_NODEBUG void __tg_sincos(double x, double *sinp, double *cosp) { ::__sincos(x, sinp, cosp); } 2013 /*! @abstract Do not call this function directly; use simd::sincospi 2014 * instead. */ 2015 static SIMD_INLINE SIMD_NODEBUG void __tg_sincospi(float x, float *sinp, float *cosp) { ::__sincospif(x, sinp, cosp); } 2016 /*! @abstract Do not call this function directly; use simd::sincospi 2017 * instead. */ 2018 static SIMD_INLINE SIMD_NODEBUG void __tg_sincospi(double x, double *sinp, double *cosp) { ::__sincospi(x, sinp, cosp); } 2019 #endif 2020 #if SIMD_LIBRARY_VERSION >= 6 2021 /*! @abstract Do not call this function directly; use simd::fabs instead. */ 2022 static SIMD_CPPFUNC _Float16 __tg_fabs(_Float16 x) { return ::__fabsf16(x); } 2023 /*! @abstract Do not call this function directly; use simd::sqrt instead. */ 2024 static SIMD_CPPFUNC _Float16 __tg_sqrt(_Float16 x) { return ::__sqrtf16(x); } 2025 /*! @abstract Do not call this function directly; use simd::ceil instead. */ 2026 static SIMD_CPPFUNC _Float16 __tg_ceil(_Float16 x) { return ::__ceilf16(x); } 2027 /*! @abstract Do not call this function directly; use simd::floor instead. */ 2028 static SIMD_CPPFUNC _Float16 __tg_floor(_Float16 x) { return ::__floorf16(x); } 2029 /*! @abstract Do not call this function directly; use simd::rint instead. */ 2030 static SIMD_CPPFUNC _Float16 __tg_rint(_Float16 x) { return ::__rintf16(x); } 2031 /*! @abstract Do not call this function directly; use simd::trunc instead. */ 2032 static SIMD_CPPFUNC _Float16 __tg_trunc(_Float16 x) { return ::__truncf16(x); } 2033 #endif 2034 /*! @abstract Do not call this function directly; use simd::isfinite 2035 * instead. */ 2036 static SIMD_CPPFUNC float __tg_isfinite(float x) { return std::isfinite(x); } 2037 /*! @abstract Do not call this function directly; use simd::isfinite 2038 * instead. */ 2039 static SIMD_CPPFUNC double __tg_isfinite(double x) { return std::isfinite(x); } 2040 /*! @abstract Do not call this function directly; use simd::isinf instead. */ 2041 static SIMD_CPPFUNC float __tg_isinf(float x) { return std::isinf(x); } 2042 /*! @abstract Do not call this function directly; use simd::isinf instead. */ 2043 static SIMD_CPPFUNC double __tg_isinf(double x) { return std::isinf(x); } 2044 /*! @abstract Do not call this function directly; use simd::isnan instead. */ 2045 static SIMD_CPPFUNC float __tg_isnan(float x) { return std::isnan(x); } 2046 /*! @abstract Do not call this function directly; use simd::isnan instead. */ 2047 static SIMD_CPPFUNC double __tg_isnan(double x) { return std::isnan(x); } 2048 /*! @abstract Do not call this function directly; use simd::isnormal 2049 * instead. */ 2050 static SIMD_CPPFUNC float __tg_isnormal(float x) { return std::isnormal(x); } 2051 /*! @abstract Do not call this function directly; use simd::isnormal 2052 * instead. */ 2053 static SIMD_CPPFUNC double __tg_isnormal(double x) { return std::isnormal(x); } 2054 /*! @abstract Do not call this function directly; use simd::atan2 instead. */ 2055 static SIMD_CPPFUNC float __tg_atan2(float x, float y) { return ::atan2f(x, y); } 2056 /*! @abstract Do not call this function directly; use simd::atan2 instead. */ 2057 static SIMD_CPPFUNC double __tg_atan2(double x, double y) { return ::atan2(x, y); } 2058 /*! @abstract Do not call this function directly; use simd::hypot instead. */ 2059 static SIMD_CPPFUNC float __tg_hypot(float x, float y) { return ::hypotf(x, y); } 2060 /*! @abstract Do not call this function directly; use simd::hypot instead. */ 2061 static SIMD_CPPFUNC double __tg_hypot(double x, double y) { return ::hypot(x, y); } 2062 /*! @abstract Do not call this function directly; use simd::pow instead. */ 2063 static SIMD_CPPFUNC float __tg_pow(float x, float y) { return ::powf(x, y); } 2064 /*! @abstract Do not call this function directly; use simd::pow instead. */ 2065 static SIMD_CPPFUNC double __tg_pow(double x, double y) { return ::pow(x, y); } 2066 /*! @abstract Do not call this function directly; use simd::fmod instead. */ 2067 static SIMD_CPPFUNC float __tg_fmod(float x, float y) { return ::fmodf(x, y); } 2068 /*! @abstract Do not call this function directly; use simd::fmod instead. */ 2069 static SIMD_CPPFUNC double __tg_fmod(double x, double y) { return ::fmod(x, y); } 2070 /*! @abstract Do not call this function directly; use simd::remainder 2071 * instead. */ 2072 static SIMD_CPPFUNC float __tg_remainder(float x, float y) { return ::remainderf(x, y); } 2073 /*! @abstract Do not call this function directly; use simd::remainder 2074 * instead. */ 2075 static SIMD_CPPFUNC double __tg_remainder(double x, double y) { return ::remainder(x, y); } 2076 /*! @abstract Do not call this function directly; use simd::copysign 2077 * instead. */ 2078 static SIMD_CPPFUNC float __tg_copysign(float x, float y) { return ::copysignf(x, y); } 2079 /*! @abstract Do not call this function directly; use simd::copysign 2080 * instead. */ 2081 static SIMD_CPPFUNC double __tg_copysign(double x, double y) { return ::copysign(x, y); } 2082 /*! @abstract Do not call this function directly; use simd::nextafter 2083 * instead. */ 2084 static SIMD_CPPFUNC float __tg_nextafter(float x, float y) { return ::nextafterf(x, y); } 2085 /*! @abstract Do not call this function directly; use simd::nextafter 2086 * instead. */ 2087 static SIMD_CPPFUNC double __tg_nextafter(double x, double y) { return ::nextafter(x, y); } 2088 /*! @abstract Do not call this function directly; use simd::fdim instead. */ 2089 static SIMD_CPPFUNC float __tg_fdim(float x, float y) { return ::fdimf(x, y); } 2090 /*! @abstract Do not call this function directly; use simd::fdim instead. */ 2091 static SIMD_CPPFUNC double __tg_fdim(double x, double y) { return ::fdim(x, y); } 2092 /*! @abstract Do not call this function directly; use simd::fmax instead. */ 2093 static SIMD_CPPFUNC float __tg_fmax(float x, float y) { return ::fmaxf(x, y); } 2094 /*! @abstract Do not call this function directly; use simd::fmax instead. */ 2095 static SIMD_CPPFUNC double __tg_fmax(double x, double y) { return ::fmax(x, y); } 2096 /*! @abstract Do not call this function directly; use simd::fmin instead. */ 2097 static SIMD_CPPFUNC float __tg_fmin(float x, float y) { return ::fminf(x, y); } 2098 /*! @abstract Do not call this function directly; use simd::fmin instead. */ 2099 static SIMD_CPPFUNC double __tg_fmin(double x, double y) { return ::fmin(x, y); } 2100 #if SIMD_LIBRARY_VERSION >= 6 2101 /*! @abstract Do not call this function directly; use simd::fmin instead. */ 2102 static SIMD_CPPFUNC _Float16 __tg_fmin(_Float16 x, _Float16 y) { return ::__fminf16(x, y); } 2103 /*! @abstract Do not call this function directly; use simd::fmax instead. */ 2104 static SIMD_CPPFUNC _Float16 __tg_fmax(_Float16 x, _Float16 y) { return ::__fmaxf16(x, y); } 2105 /*! @abstract Do not call this function directly; use simd::copysign 2106 * instead. */ 2107 static SIMD_CPPFUNC _Float16 __tg_copysign(_Float16 x, _Float16 y) { return ::__copysignf16(x, y); } 2108 #endif 2109 /*! @abstract Do not call this function directly; use simd::fma instead. */ 2110 static SIMD_CPPFUNC float __tg_fma(float x, float y, float z) { return ::fmaf(x, y, z); } 2111 /*! @abstract Do not call this function directly; use simd::fma instead. */ 2112 static SIMD_CPPFUNC double __tg_fma(double x, double y, double z) { return ::fma(x, y, z); } 2113 2114 namespace simd { 2115 /*! @abstract Generalizes the <cmath> function acos to operate on vectors of 2116 * floats and doubles. */ 2117 template <typename fptypeN> 2118 static SIMD_CPPFUNC fptypeN acos(fptypeN x) { return ::__tg_acos(x); } 2119 2120 /*! @abstract Generalizes the <cmath> function asin to operate on vectors of 2121 * floats and doubles. */ 2122 template <typename fptypeN> 2123 static SIMD_CPPFUNC fptypeN asin(fptypeN x) { return ::__tg_asin(x); } 2124 2125 /*! @abstract Generalizes the <cmath> function atan to operate on vectors of 2126 * floats and doubles. */ 2127 template <typename fptypeN> 2128 static SIMD_CPPFUNC fptypeN atan(fptypeN x) { return ::__tg_atan(x); } 2129 2130 /*! @abstract Generalizes the <cmath> function cos to operate on vectors of 2131 * floats and doubles. */ 2132 template <typename fptypeN> 2133 static SIMD_CPPFUNC fptypeN cos(fptypeN x) { return ::__tg_cos(x); } 2134 2135 /*! @abstract Generalizes the <cmath> function sin to operate on vectors of 2136 * floats and doubles. */ 2137 template <typename fptypeN> 2138 static SIMD_CPPFUNC fptypeN sin(fptypeN x) { return ::__tg_sin(x); } 2139 2140 /*! @abstract Generalizes the <cmath> function tan to operate on vectors of 2141 * floats and doubles. */ 2142 template <typename fptypeN> 2143 static SIMD_CPPFUNC fptypeN tan(fptypeN x) { return ::__tg_tan(x); } 2144 2145 #if SIMD_LIBRARY_VERSION >= 1 2146 /*! @abstract Generalizes the <cmath> function cospi to operate on vectors 2147 * of floats and doubles. */ 2148 template <typename fptypeN> 2149 static SIMD_CPPFUNC fptypeN cospi(fptypeN x) { return ::__tg_cospi(x); } 2150 #endif 2151 2152 #if SIMD_LIBRARY_VERSION >= 1 2153 /*! @abstract Generalizes the <cmath> function sinpi to operate on vectors 2154 * of floats and doubles. */ 2155 template <typename fptypeN> 2156 static SIMD_CPPFUNC fptypeN sinpi(fptypeN x) { return ::__tg_sinpi(x); } 2157 #endif 2158 2159 #if SIMD_LIBRARY_VERSION >= 1 2160 /*! @abstract Generalizes the <cmath> function tanpi to operate on vectors 2161 * of floats and doubles. */ 2162 template <typename fptypeN> 2163 static SIMD_CPPFUNC fptypeN tanpi(fptypeN x) { return ::__tg_tanpi(x); } 2164 #endif 2165 2166 /*! @abstract Generalizes the <cmath> function acosh to operate on vectors 2167 * of floats and doubles. */ 2168 template <typename fptypeN> 2169 static SIMD_CPPFUNC fptypeN acosh(fptypeN x) { return ::__tg_acosh(x); } 2170 2171 /*! @abstract Generalizes the <cmath> function asinh to operate on vectors 2172 * of floats and doubles. */ 2173 template <typename fptypeN> 2174 static SIMD_CPPFUNC fptypeN asinh(fptypeN x) { return ::__tg_asinh(x); } 2175 2176 /*! @abstract Generalizes the <cmath> function atanh to operate on vectors 2177 * of floats and doubles. */ 2178 template <typename fptypeN> 2179 static SIMD_CPPFUNC fptypeN atanh(fptypeN x) { return ::__tg_atanh(x); } 2180 2181 /*! @abstract Generalizes the <cmath> function cosh to operate on vectors of 2182 * floats and doubles. */ 2183 template <typename fptypeN> 2184 static SIMD_CPPFUNC fptypeN cosh(fptypeN x) { return ::__tg_cosh(x); } 2185 2186 /*! @abstract Generalizes the <cmath> function sinh to operate on vectors of 2187 * floats and doubles. */ 2188 template <typename fptypeN> 2189 static SIMD_CPPFUNC fptypeN sinh(fptypeN x) { return ::__tg_sinh(x); } 2190 2191 /*! @abstract Generalizes the <cmath> function tanh to operate on vectors of 2192 * floats and doubles. */ 2193 template <typename fptypeN> 2194 static SIMD_CPPFUNC fptypeN tanh(fptypeN x) { return ::__tg_tanh(x); } 2195 2196 /*! @abstract Generalizes the <cmath> function exp to operate on vectors of 2197 * floats and doubles. */ 2198 template <typename fptypeN> 2199 static SIMD_CPPFUNC fptypeN exp(fptypeN x) { return ::__tg_exp(x); } 2200 2201 /*! @abstract Generalizes the <cmath> function exp2 to operate on vectors of 2202 * floats and doubles. */ 2203 template <typename fptypeN> 2204 static SIMD_CPPFUNC fptypeN exp2(fptypeN x) { return ::__tg_exp2(x); } 2205 2206 #if SIMD_LIBRARY_VERSION >= 1 2207 /*! @abstract Generalizes the <cmath> function exp10 to operate on vectors 2208 * of floats and doubles. */ 2209 template <typename fptypeN> 2210 static SIMD_CPPFUNC fptypeN exp10(fptypeN x) { return ::__tg_exp10(x); } 2211 #endif 2212 2213 /*! @abstract Generalizes the <cmath> function expm1 to operate on vectors 2214 * of floats and doubles. */ 2215 template <typename fptypeN> 2216 static SIMD_CPPFUNC fptypeN expm1(fptypeN x) { return ::__tg_expm1(x); } 2217 2218 /*! @abstract Generalizes the <cmath> function log to operate on vectors of 2219 * floats and doubles. */ 2220 template <typename fptypeN> 2221 static SIMD_CPPFUNC fptypeN log(fptypeN x) { return ::__tg_log(x); } 2222 2223 /*! @abstract Generalizes the <cmath> function log2 to operate on vectors of 2224 * floats and doubles. */ 2225 template <typename fptypeN> 2226 static SIMD_CPPFUNC fptypeN log2(fptypeN x) { return ::__tg_log2(x); } 2227 2228 /*! @abstract Generalizes the <cmath> function log10 to operate on vectors 2229 * of floats and doubles. */ 2230 template <typename fptypeN> 2231 static SIMD_CPPFUNC fptypeN log10(fptypeN x) { return ::__tg_log10(x); } 2232 2233 /*! @abstract Generalizes the <cmath> function log1p to operate on vectors 2234 * of floats and doubles. */ 2235 template <typename fptypeN> 2236 static SIMD_CPPFUNC fptypeN log1p(fptypeN x) { return ::__tg_log1p(x); } 2237 2238 /*! @abstract Generalizes the <cmath> function fabs to operate on vectors of 2239 * floats and doubles. */ 2240 template <typename fptypeN> 2241 static SIMD_CPPFUNC fptypeN fabs(fptypeN x) { return ::__tg_fabs(x); } 2242 2243 /*! @abstract Generalizes the <cmath> function cbrt to operate on vectors of 2244 * floats and doubles. */ 2245 template <typename fptypeN> 2246 static SIMD_CPPFUNC fptypeN cbrt(fptypeN x) { return ::__tg_cbrt(x); } 2247 2248 /*! @abstract Generalizes the <cmath> function sqrt to operate on vectors of 2249 * floats and doubles. */ 2250 template <typename fptypeN> 2251 static SIMD_CPPFUNC fptypeN sqrt(fptypeN x) { return ::__tg_sqrt(x); } 2252 2253 /*! @abstract Generalizes the <cmath> function erf to operate on vectors of 2254 * floats and doubles. */ 2255 template <typename fptypeN> 2256 static SIMD_CPPFUNC fptypeN erf(fptypeN x) { return ::__tg_erf(x); } 2257 2258 /*! @abstract Generalizes the <cmath> function erfc to operate on vectors of 2259 * floats and doubles. */ 2260 template <typename fptypeN> 2261 static SIMD_CPPFUNC fptypeN erfc(fptypeN x) { return ::__tg_erfc(x); } 2262 2263 /*! @abstract Generalizes the <cmath> function tgamma to operate on vectors 2264 * of floats and doubles. */ 2265 template <typename fptypeN> 2266 static SIMD_CPPFUNC fptypeN tgamma(fptypeN x) { return ::__tg_tgamma(x); } 2267 2268 /*! @abstract Generalizes the <cmath> function lgamma to operate on vectors 2269 * of floats and doubles. */ 2270 template <typename fptypeN> 2271 static SIMD_CPPFUNC fptypeN lgamma(fptypeN x) { return ::__tg_lgamma(x); } 2272 2273 /*! @abstract Generalizes the <cmath> function ceil to operate on vectors of 2274 * floats and doubles. */ 2275 template <typename fptypeN> 2276 static SIMD_CPPFUNC fptypeN ceil(fptypeN x) { return ::__tg_ceil(x); } 2277 2278 /*! @abstract Generalizes the <cmath> function floor to operate on vectors 2279 * of floats and doubles. */ 2280 template <typename fptypeN> 2281 static SIMD_CPPFUNC fptypeN floor(fptypeN x) { return ::__tg_floor(x); } 2282 2283 /*! @abstract Generalizes the <cmath> function rint to operate on vectors of 2284 * floats and doubles. */ 2285 template <typename fptypeN> 2286 static SIMD_CPPFUNC fptypeN rint(fptypeN x) { return ::__tg_rint(x); } 2287 2288 /*! @abstract Generalizes the <cmath> function round to operate on vectors 2289 * of floats and doubles. */ 2290 template <typename fptypeN> 2291 static SIMD_CPPFUNC fptypeN round(fptypeN x) { return ::__tg_round(x); } 2292 2293 /*! @abstract Generalizes the <cmath> function trunc to operate on vectors 2294 * of floats and doubles. */ 2295 template <typename fptypeN> 2296 static SIMD_CPPFUNC fptypeN trunc(fptypeN x) { return ::__tg_trunc(x); } 2297 2298 #if SIMD_LIBRARY_VERSION >= 5 2299 /*! @abstract Computes sincos more efficiently than separate computations. */ 2300 template <typename fptypeN> 2301 static SIMD_INLINE SIMD_NODEBUG void sincos(fptypeN x, fptypeN *sinp, fptypeN *cosp) { ::__tg_sincos(x, sinp, cosp); } 2302 2303 /*! @abstract Computes sincospi more efficiently than separate computations. */ 2304 template <typename fptypeN> 2305 static SIMD_INLINE SIMD_NODEBUG void sincospi(fptypeN x, fptypeN *sinp, fptypeN *cosp) { ::__tg_sincospi(x, sinp, cosp); } 2306 2307 #endif 2308 /*! @abstract Generalizes the <cmath> function isfinite to operate on 2309 * vectors of floats and doubles. */ 2310 template <typename fptypeN> 2311 static SIMD_CPPFUNC 2312 typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type 2313 isfinite(fptypeN x) { return ::__tg_isfinite(x); } 2314 2315 /*! @abstract Generalizes the <cmath> function isinf to operate on vectors 2316 * of floats and doubles. */ 2317 template <typename fptypeN> 2318 static SIMD_CPPFUNC 2319 typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type 2320 isinf(fptypeN x) { return ::__tg_isinf(x); } 2321 2322 /*! @abstract Generalizes the <cmath> function isnan to operate on vectors 2323 * of floats and doubles. */ 2324 template <typename fptypeN> 2325 static SIMD_CPPFUNC 2326 typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type 2327 isnan(fptypeN x) { return ::__tg_isnan(x); } 2328 2329 /*! @abstract Generalizes the <cmath> function isnormal to operate on 2330 * vectors of floats and doubles. */ 2331 template <typename fptypeN> 2332 static SIMD_CPPFUNC 2333 typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type 2334 isnormal(fptypeN x) { return ::__tg_isnormal(x); } 2335 2336 /*! @abstract Generalizes the <cmath> function atan2 to operate on vectors 2337 * of floats and doubles. */ 2338 template <typename fptypeN> 2339 static SIMD_CPPFUNC fptypeN atan2(fptypeN y, fptypeN x) { return ::__tg_atan2(y, x); } 2340 2341 /*! @abstract Generalizes the <cmath> function hypot to operate on vectors 2342 * of floats and doubles. */ 2343 template <typename fptypeN> 2344 static SIMD_CPPFUNC fptypeN hypot(fptypeN x, fptypeN y) { return ::__tg_hypot(x, y); } 2345 2346 /*! @abstract Generalizes the <cmath> function pow to operate on vectors of 2347 * floats and doubles. */ 2348 template <typename fptypeN> 2349 static SIMD_CPPFUNC fptypeN pow(fptypeN x, fptypeN y) { return ::__tg_pow(x, y); } 2350 2351 /*! @abstract Generalizes the <cmath> function fmod to operate on vectors of 2352 * floats and doubles. */ 2353 template <typename fptypeN> 2354 static SIMD_CPPFUNC fptypeN fmod(fptypeN x, fptypeN y) { return ::__tg_fmod(x, y); } 2355 2356 /*! @abstract Generalizes the <cmath> function remainder to operate on 2357 * vectors of floats and doubles. */ 2358 template <typename fptypeN> 2359 static SIMD_CPPFUNC fptypeN remainder(fptypeN x, fptypeN y) { return ::__tg_remainder(x, y); } 2360 2361 /*! @abstract Generalizes the <cmath> function copysign to operate on 2362 * vectors of floats and doubles. */ 2363 template <typename fptypeN> 2364 static SIMD_CPPFUNC fptypeN copysign(fptypeN x, fptypeN y) { return ::__tg_copysign(x, y); } 2365 2366 /*! @abstract Generalizes the <cmath> function nextafter to operate on 2367 * vectors of floats and doubles. */ 2368 template <typename fptypeN> 2369 static SIMD_CPPFUNC fptypeN nextafter(fptypeN x, fptypeN y) { return ::__tg_nextafter(x, y); } 2370 2371 /*! @abstract Generalizes the <cmath> function fdim to operate on vectors of 2372 * floats and doubles. */ 2373 template <typename fptypeN> 2374 static SIMD_CPPFUNC fptypeN fdim(fptypeN x, fptypeN y) { return ::__tg_fdim(x, y); } 2375 2376 /*! @abstract Generalizes the <cmath> function fmax to operate on vectors of 2377 * floats and doubles. */ 2378 template <typename fptypeN> 2379 static SIMD_CPPFUNC fptypeN fmax(fptypeN x, fptypeN y) { return ::__tg_fmax(x, y); } 2380 2381 /*! @abstract Generalizes the <cmath> function fmin to operate on vectors of 2382 * floats and doubles. */ 2383 template <typename fptypeN> 2384 static SIMD_CPPFUNC fptypeN fmin(fptypeN x, fptypeN y) { return ::__tg_fmin(x, y); } 2385 2386 /*! @abstract Generalizes the <cmath> function fma to operate on vectors of 2387 * floats and doubles. */ 2388 template <typename fptypeN> 2389 static SIMD_CPPFUNC fptypeN fma(fptypeN x, fptypeN y, fptypeN z) { return ::__tg_fma(x, y, z); } 2390 2391 /*! @abstract Computes x*y + z by the most efficient means available; either 2392 * a fused multiply add or separate multiply and add. */ 2393 template <typename fptypeN> 2394 static SIMD_CPPFUNC fptypeN muladd(fptypeN x, fptypeN y, fptypeN z) { return ::simd_muladd(x, y, z); } 2395 }; 2396 2397 extern "C" { 2398 #else 2399 #include <tgmath.h> 2400 /* C and Objective-C, we need some infrastructure to piggyback on tgmath.h */ 2401 static SIMD_OVERLOAD simd_half2 __tg_promote(simd_half2); 2402 static SIMD_OVERLOAD simd_half3 __tg_promote(simd_half3); 2403 static SIMD_OVERLOAD simd_half4 __tg_promote(simd_half4); 2404 static SIMD_OVERLOAD simd_half8 __tg_promote(simd_half8); 2405 static SIMD_OVERLOAD simd_half16 __tg_promote(simd_half16); 2406 static SIMD_OVERLOAD simd_half32 __tg_promote(simd_half32); 2407 static SIMD_OVERLOAD simd_float2 __tg_promote(simd_float2); 2408 static SIMD_OVERLOAD simd_float3 __tg_promote(simd_float3); 2409 static SIMD_OVERLOAD simd_float4 __tg_promote(simd_float4); 2410 static SIMD_OVERLOAD simd_float8 __tg_promote(simd_float8); 2411 static SIMD_OVERLOAD simd_float16 __tg_promote(simd_float16); 2412 static SIMD_OVERLOAD simd_double2 __tg_promote(simd_double2); 2413 static SIMD_OVERLOAD simd_double3 __tg_promote(simd_double3); 2414 static SIMD_OVERLOAD simd_double4 __tg_promote(simd_double4); 2415 static SIMD_OVERLOAD simd_double8 __tg_promote(simd_double8); 2416 2417 /* Apple extensions to <math.h>, added in macOS 10.9 and iOS 7.0 */ 2418 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_9 || \ 2419 __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_0 || \ 2420 __DRIVERKIT_VERSION_MIN_REQUIRED >= __DRIVERKIT_19_0 2421 static inline SIMD_CFUNC float __tg_cospi(float x) { return __cospif(x); } 2422 static inline SIMD_CFUNC double __tg_cospi(double x) { return __cospi(x); } 2423 #undef cospi 2424 /*! @abstract `cospi(x)` computes `cos(pi * x)` without intermediate rounding. 2425 * 2426 * @discussion Both faster and more accurate than multiplying by `pi` and then 2427 * calling `cos`. Defined for `float` and `double` as well as vectors of 2428 * floats and doubles as provided by `<simd/simd.h>`. */ 2429 #define cospi(__x) __tg_cospi(__tg_promote1((__x))(__x)) 2430 2431 static inline SIMD_CFUNC float __tg_sinpi(float x) { return __sinpif(x); } 2432 static inline SIMD_CFUNC double __tg_sinpi(double x) { return __sinpi(x); } 2433 #undef sinpi 2434 /*! @abstract `sinpi(x)` computes `sin(pi * x)` without intermediate rounding. 2435 * 2436 * @discussion Both faster and more accurate than multiplying by `pi` and then 2437 * calling `sin`. Defined for `float` and `double` as well as vectors 2438 * of floats and doubles as provided by `<simd/simd.h>`. */ 2439 #define sinpi(__x) __tg_sinpi(__tg_promote1((__x))(__x)) 2440 2441 static inline SIMD_CFUNC float __tg_tanpi(float x) { return __tanpif(x); } 2442 static inline SIMD_CFUNC double __tg_tanpi(double x) { return __tanpi(x); } 2443 #undef tanpi 2444 /*! @abstract `tanpi(x)` computes `tan(pi * x)` without intermediate rounding. 2445 * 2446 * @discussion Both faster and more accurate than multiplying by `pi` and then 2447 * calling `tan`. Defined for `float` and `double` as well as vectors of 2448 * floats and doubles as provided by `<simd/simd.h>`. */ 2449 #define tanpi(__x) __tg_tanpi(__tg_promote1((__x))(__x)) 2450 2451 #if SIMD_LIBRARY_VERSION >= 5 2452 static inline SIMD_NONCONST void __tg_sincos(float x, float *sinp, float *cosp) { __sincosf(x, sinp, cosp); } 2453 static inline SIMD_NONCONST void __tg_sincos(double x, double *sinp, double *cosp) { __sincos(x, sinp, cosp); } 2454 #undef sincos 2455 /*! @abstract `sincos(x)` computes `sin(x)` and `cos(x)` more efficiently. 2456 * 2457 * @discussion Defined for `float` and `double` as well as vectors of 2458 * floats and doubles as provided by `<simd/simd.h>`. */ 2459 #define sincos(__x, __sinp, __cosp) __tg_sincos(__tg_promote1((__x))(__x), __sinp, __cosp) 2460 2461 static inline SIMD_NONCONST void __tg_sincospi(float x, float *sinp, float *cosp) { __sincospif(x, sinp, cosp); } 2462 static inline SIMD_NONCONST void __tg_sincospi(double x, double *sinp, double *cosp) { __sincospi(x, sinp, cosp); } 2463 #undef sincospi 2464 /*! @abstract `sincospi(x)` computes `sin(pi * x)` and `cos(pi * x)` more efficiently. 2465 * 2466 * @discussion Defined for `float` and `double` as well as vectors of 2467 * floats and doubles as provided by `<simd/simd.h>`. */ 2468 #define sincospi(__x, __sinp, __cosp) __tg_sincospi(__tg_promote1((__x))(__x), __sinp, __cosp) 2469 #endif // SIMD_LIBRARY_VERSION >= 5 2470 2471 static inline SIMD_CFUNC float __tg_exp10(float x) { return __exp10f(x); } 2472 static inline SIMD_CFUNC double __tg_exp10(double x) { return __exp10(x); } 2473 #undef exp10 2474 /*! @abstract `exp10(x)` computes `10**x` more efficiently and accurately 2475 * than `pow(10, x)`. 2476 * 2477 * @discussion Defined for `float` and `double` as well as vectors of floats 2478 * and doubles as provided by `<simd/simd.h>`. */ 2479 #define exp10(__x) __tg_exp10(__tg_promote1((__x))(__x)) 2480 #endif 2481 2482 2483 #if (defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__) 2484 static inline SIMD_CFUNC int __tg_isfinite(float x) { return __inline_isfinitef(x); } 2485 static inline SIMD_CFUNC int __tg_isfinite(double x) { return __inline_isfinited(x); } 2486 static inline SIMD_CFUNC int __tg_isfinite(long double x) { return __inline_isfinitel(x); } 2487 #undef isfinite 2488 /*! @abstract `__tg_isfinite(x)` determines if x is a finite value. 2489 * 2490 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2491 * and doubles as provided by `<simd/simd.h>`. */ 2492 #define isfinite(__x) __tg_isfinite(__tg_promote1((__x))(__x)) 2493 2494 static inline SIMD_CFUNC int __tg_isinf(float x) { return __inline_isinff(x); } 2495 static inline SIMD_CFUNC int __tg_isinf(double x) { return __inline_isinfd(x); } 2496 static inline SIMD_CFUNC int __tg_isinf(long double x) { return __inline_isinfl(x); } 2497 #undef isinf 2498 /*! @abstract `__tg_isinf(x)` determines if x is positive or negative infinity. 2499 * 2500 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2501 * and doubles as provided by `<simd/simd.h>`. */ 2502 #define isinf(__x) __tg_isinf(__tg_promote1((__x))(__x)) 2503 2504 static inline SIMD_CFUNC int __tg_isnan(float x) { return __inline_isnanf(x); } 2505 static inline SIMD_CFUNC int __tg_isnan(double x) { return __inline_isnand(x); } 2506 static inline SIMD_CFUNC int __tg_isnan(long double x) { return __inline_isnanl(x); } 2507 #undef isnan 2508 /*! @abstract `__tg_isnan(x)` determines if x is a not-a-number (NaN) value. 2509 * 2510 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2511 * and doubles as provided by `<simd/simd.h>`. */ 2512 #define isnan(__x) __tg_isnan(__tg_promote1((__x))(__x)) 2513 2514 static inline SIMD_CFUNC int __tg_isnormal(float x) { return __inline_isnormalf(x); } 2515 static inline SIMD_CFUNC int __tg_isnormal(double x) { return __inline_isnormald(x); } 2516 static inline SIMD_CFUNC int __tg_isnormal(long double x) { return __inline_isnormall(x); } 2517 #undef isnormal 2518 /*! @abstract `__tg_isnormal(x)` determines if x is a normal value. 2519 * 2520 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2521 * and doubles as provided by `<simd/simd.h>`. */ 2522 #define isnormal(__x) __tg_isnormal(__tg_promote1((__x))(__x)) 2523 2524 #else /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */ 2525 2526 static inline SIMD_CFUNC int __tg_isfinite(float x) { return __isfinitef(x); } 2527 static inline SIMD_CFUNC int __tg_isfinite(double x) { return __isfinited(x); } 2528 static inline SIMD_CFUNC int __tg_isfinite(long double x) { return __isfinitel(x); } 2529 #undef isfinite 2530 /*! @abstract `__tg_isfinite(x)` determines if x is a finite value. 2531 * 2532 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2533 * and doubles as provided by `<simd/simd.h>`. */ 2534 #define isfinite(__x) __tg_isfinite(__tg_promote1((__x))(__x)) 2535 2536 static inline SIMD_CFUNC int __tg_isinf(float x) { return __isinff(x); } 2537 static inline SIMD_CFUNC int __tg_isinf(double x) { return __isinfd(x); } 2538 static inline SIMD_CFUNC int __tg_isinf(long double x) { return __isinfl(x); } 2539 #undef isinf 2540 /*! @abstract `__tg_isinf(x)` determines if x is positive or negative infinity. 2541 * 2542 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2543 * and doubles as provided by `<simd/simd.h>`. */ 2544 #define isinf(__x) __tg_isinf(__tg_promote1((__x))(__x)) 2545 2546 static inline SIMD_CFUNC int __tg_isnan(float x) { return __isnanf(x); } 2547 static inline SIMD_CFUNC int __tg_isnan(double x) { return __isnand(x); } 2548 static inline SIMD_CFUNC int __tg_isnan(long double x) { return __isnanl(x); } 2549 #undef isnan 2550 /*! @abstract `__tg_isnan(x)` determines if x is a not-a-number (NaN) value. 2551 * 2552 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2553 * and doubles as provided by `<simd/simd.h>`. */ 2554 #define isnan(__x) __tg_isnan(__tg_promote1((__x))(__x)) 2555 2556 static inline SIMD_CFUNC int __tg_isnormal(float x) { return __isnormalf(x); } 2557 static inline SIMD_CFUNC int __tg_isnormal(double x) { return __isnormald(x); } 2558 static inline SIMD_CFUNC int __tg_isnormal(long double x) { return __isnormall(x); } 2559 #undef isnormal 2560 /*! @abstract `__tg_isnormal(x)` determines if x is a normal value. 2561 * 2562 * @discussion Defined for `float`, `double` and `long double` as well as vectors of floats 2563 * and doubles as provided by `<simd/simd.h>`. */ 2564 #define isnormal(__x) __tg_isnormal(__tg_promote1((__x))(__x)) 2565 #endif /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */ 2566 #endif /* !__cplusplus */ 2567 2568 #pragma mark - fabs implementation 2569 static inline SIMD_CFUNC simd_half2 __tg_fabs(simd_half2 x) { return simd_bitselect(0.0, x, 0x7fff); } 2570 static inline SIMD_CFUNC simd_half3 __tg_fabs(simd_half3 x) { return simd_bitselect(0.0, x, 0x7fff); } 2571 static inline SIMD_CFUNC simd_half4 __tg_fabs(simd_half4 x) { return simd_bitselect(0.0, x, 0x7fff); } 2572 static inline SIMD_CFUNC simd_half8 __tg_fabs(simd_half8 x) { return simd_bitselect(0.0, x, 0x7fff); } 2573 static inline SIMD_CFUNC simd_half16 __tg_fabs(simd_half16 x) { return simd_bitselect(0.0, x, 0x7fff); } 2574 static inline SIMD_CFUNC simd_half32 __tg_fabs(simd_half32 x) { return simd_bitselect(0.0, x, 0x7fff); } 2575 static inline SIMD_CFUNC simd_float2 __tg_fabs(simd_float2 x) { return simd_bitselect(0.0, x, 0x7fffffff); } 2576 static inline SIMD_CFUNC simd_float3 __tg_fabs(simd_float3 x) { return simd_bitselect(0.0, x, 0x7fffffff); } 2577 static inline SIMD_CFUNC simd_float4 __tg_fabs(simd_float4 x) { return simd_bitselect(0.0, x, 0x7fffffff); } 2578 static inline SIMD_CFUNC simd_float8 __tg_fabs(simd_float8 x) { return simd_bitselect(0.0, x, 0x7fffffff); } 2579 static inline SIMD_CFUNC simd_float16 __tg_fabs(simd_float16 x) { return simd_bitselect(0.0, x, 0x7fffffff); } 2580 static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); } 2581 static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); } 2582 static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); } 2583 static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); } 2584 2585 #pragma mark - isfinite implementation 2586 static inline SIMD_CFUNC simd_short2 __tg_isfinite(simd_half2 x) { return x == x && __tg_fabs(x) != (simd_half2)INFINITY; } 2587 static inline SIMD_CFUNC simd_short3 __tg_isfinite(simd_half3 x) { return x == x && __tg_fabs(x) != (simd_half3)INFINITY; } 2588 static inline SIMD_CFUNC simd_short4 __tg_isfinite(simd_half4 x) { return x == x && __tg_fabs(x) != (simd_half4)INFINITY; } 2589 static inline SIMD_CFUNC simd_short8 __tg_isfinite(simd_half8 x) { return x == x && __tg_fabs(x) != (simd_half8)INFINITY; } 2590 static inline SIMD_CFUNC simd_short16 __tg_isfinite(simd_half16 x) { return x == x && __tg_fabs(x) != (simd_half16)INFINITY; } 2591 static inline SIMD_CFUNC simd_short32 __tg_isfinite(simd_half32 x) { return x == x && __tg_fabs(x) != (simd_half32)INFINITY; } 2592 static inline SIMD_CFUNC simd_int2 __tg_isfinite(simd_float2 x) { return x == x && __tg_fabs(x) != (simd_float2)INFINITY; } 2593 static inline SIMD_CFUNC simd_int3 __tg_isfinite(simd_float3 x) { return x == x && __tg_fabs(x) != (simd_float3)INFINITY; } 2594 static inline SIMD_CFUNC simd_int4 __tg_isfinite(simd_float4 x) { return x == x && __tg_fabs(x) != (simd_float4)INFINITY; } 2595 static inline SIMD_CFUNC simd_int8 __tg_isfinite(simd_float8 x) { return x == x && __tg_fabs(x) != (simd_float8)INFINITY; } 2596 static inline SIMD_CFUNC simd_int16 __tg_isfinite(simd_float16 x) { return x == x && __tg_fabs(x) != (simd_float16)INFINITY; } 2597 static inline SIMD_CFUNC simd_long2 __tg_isfinite(simd_double2 x) { return x == x && __tg_fabs(x) != (simd_double2)INFINITY; } 2598 static inline SIMD_CFUNC simd_long3 __tg_isfinite(simd_double3 x) { return x == x && __tg_fabs(x) != (simd_double3)INFINITY; } 2599 static inline SIMD_CFUNC simd_long4 __tg_isfinite(simd_double4 x) { return x == x && __tg_fabs(x) != (simd_double4)INFINITY; } 2600 static inline SIMD_CFUNC simd_long8 __tg_isfinite(simd_double8 x) { return x == x && __tg_fabs(x) != (simd_double8)INFINITY; } 2601 2602 #pragma mark - isinf implementation 2603 static inline SIMD_CFUNC simd_short2 __tg_isinf(simd_half2 x) { return __tg_fabs(x) == (simd_half2)INFINITY; } 2604 static inline SIMD_CFUNC simd_short3 __tg_isinf(simd_half3 x) { return __tg_fabs(x) == (simd_half3)INFINITY; } 2605 static inline SIMD_CFUNC simd_short4 __tg_isinf(simd_half4 x) { return __tg_fabs(x) == (simd_half4)INFINITY; } 2606 static inline SIMD_CFUNC simd_short8 __tg_isinf(simd_half8 x) { return __tg_fabs(x) == (simd_half8)INFINITY; } 2607 static inline SIMD_CFUNC simd_short16 __tg_isinf(simd_half16 x) { return __tg_fabs(x) == (simd_half16)INFINITY; } 2608 static inline SIMD_CFUNC simd_short32 __tg_isinf(simd_half32 x) { return __tg_fabs(x) == (simd_half32)INFINITY; } 2609 static inline SIMD_CFUNC simd_int2 __tg_isinf(simd_float2 x) { return __tg_fabs(x) == (simd_float2)INFINITY; } 2610 static inline SIMD_CFUNC simd_int3 __tg_isinf(simd_float3 x) { return __tg_fabs(x) == (simd_float3)INFINITY; } 2611 static inline SIMD_CFUNC simd_int4 __tg_isinf(simd_float4 x) { return __tg_fabs(x) == (simd_float4)INFINITY; } 2612 static inline SIMD_CFUNC simd_int8 __tg_isinf(simd_float8 x) { return __tg_fabs(x) == (simd_float8)INFINITY; } 2613 static inline SIMD_CFUNC simd_int16 __tg_isinf(simd_float16 x) { return __tg_fabs(x) == (simd_float16)INFINITY; } 2614 static inline SIMD_CFUNC simd_long2 __tg_isinf(simd_double2 x) { return __tg_fabs(x) == (simd_double2)INFINITY; } 2615 static inline SIMD_CFUNC simd_long3 __tg_isinf(simd_double3 x) { return __tg_fabs(x) == (simd_double3)INFINITY; } 2616 static inline SIMD_CFUNC simd_long4 __tg_isinf(simd_double4 x) { return __tg_fabs(x) == (simd_double4)INFINITY; } 2617 static inline SIMD_CFUNC simd_long8 __tg_isinf(simd_double8 x) { return __tg_fabs(x) == (simd_double8)INFINITY; } 2618 2619 #pragma mark - isnan implementation 2620 static inline SIMD_CFUNC simd_short2 __tg_isnan(simd_half2 x) { return x != x; } 2621 static inline SIMD_CFUNC simd_short3 __tg_isnan(simd_half3 x) { return x != x; } 2622 static inline SIMD_CFUNC simd_short4 __tg_isnan(simd_half4 x) { return x != x; } 2623 static inline SIMD_CFUNC simd_short8 __tg_isnan(simd_half8 x) { return x != x; } 2624 static inline SIMD_CFUNC simd_short16 __tg_isnan(simd_half16 x) { return x != x; } 2625 static inline SIMD_CFUNC simd_short32 __tg_isnan(simd_half32 x) { return x != x; } 2626 static inline SIMD_CFUNC simd_int2 __tg_isnan(simd_float2 x) { return x != x; } 2627 static inline SIMD_CFUNC simd_int3 __tg_isnan(simd_float3 x) { return x != x; } 2628 static inline SIMD_CFUNC simd_int4 __tg_isnan(simd_float4 x) { return x != x; } 2629 static inline SIMD_CFUNC simd_int8 __tg_isnan(simd_float8 x) { return x != x; } 2630 static inline SIMD_CFUNC simd_int16 __tg_isnan(simd_float16 x) { return x != x; } 2631 static inline SIMD_CFUNC simd_long2 __tg_isnan(simd_double2 x) { return x != x; } 2632 static inline SIMD_CFUNC simd_long3 __tg_isnan(simd_double3 x) { return x != x; } 2633 static inline SIMD_CFUNC simd_long4 __tg_isnan(simd_double4 x) { return x != x; } 2634 static inline SIMD_CFUNC simd_long8 __tg_isnan(simd_double8 x) { return x != x; } 2635 2636 #pragma mark - isnormal implementation 2637 static inline SIMD_CFUNC simd_short2 __tg_isnormal(simd_half2 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half2)__DBL_MIN__; } 2638 static inline SIMD_CFUNC simd_short3 __tg_isnormal(simd_half3 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half3)__DBL_MIN__; } 2639 static inline SIMD_CFUNC simd_short4 __tg_isnormal(simd_half4 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half4)__DBL_MIN__; } 2640 static inline SIMD_CFUNC simd_short8 __tg_isnormal(simd_half8 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half8)__DBL_MIN__; } 2641 static inline SIMD_CFUNC simd_short16 __tg_isnormal(simd_half16 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half16)__DBL_MIN__; } 2642 static inline SIMD_CFUNC simd_short32 __tg_isnormal(simd_half32 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_half32)__DBL_MIN__; } 2643 static inline SIMD_CFUNC simd_int2 __tg_isnormal(simd_float2 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float2)__FLT_MIN__; } 2644 static inline SIMD_CFUNC simd_int3 __tg_isnormal(simd_float3 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float3)__FLT_MIN__; } 2645 static inline SIMD_CFUNC simd_int4 __tg_isnormal(simd_float4 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float4)__FLT_MIN__; } 2646 static inline SIMD_CFUNC simd_int8 __tg_isnormal(simd_float8 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float8)__FLT_MIN__; } 2647 static inline SIMD_CFUNC simd_int16 __tg_isnormal(simd_float16 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float16)__FLT_MIN__; } 2648 static inline SIMD_CFUNC simd_long2 __tg_isnormal(simd_double2 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double2)__DBL_MIN__; } 2649 static inline SIMD_CFUNC simd_long3 __tg_isnormal(simd_double3 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double3)__DBL_MIN__; } 2650 static inline SIMD_CFUNC simd_long4 __tg_isnormal(simd_double4 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double4)__DBL_MIN__; } 2651 static inline SIMD_CFUNC simd_long8 __tg_isnormal(simd_double8 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double8)__DBL_MIN__; } 2652 2653 #pragma mark - fmin, fmax implementation 2654 static SIMD_CFUNC simd_half2 __tg_fmin(simd_half2 x, simd_half2 y) { 2655 return __tg_fmin(simd_make_half4_undef(x), simd_make_half4_undef(y)).lo; 2656 } 2657 2658 static SIMD_CFUNC simd_half3 __tg_fmin(simd_half3 x, simd_half3 y) { 2659 return simd_make_half3(__tg_fmin(simd_make_half4_undef(x), simd_make_half4_undef(y))); 2660 } 2661 2662 static SIMD_CFUNC simd_half4 __tg_fmin(simd_half4 x, simd_half4 y) { 2663 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2664 return vminnm_f16(x, y); 2665 #else 2666 return simd_bitselect(y, x, (x <= y) | (y != y)); 2667 #endif 2668 } 2669 2670 static SIMD_CFUNC simd_half8 __tg_fmin(simd_half8 x, simd_half8 y) { 2671 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2672 return vminnmq_f16(x, y); 2673 #else 2674 return simd_make_half8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2675 #endif 2676 } 2677 2678 static SIMD_CFUNC simd_half16 __tg_fmin(simd_half16 x, simd_half16 y) { 2679 return simd_make_half16(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2680 } 2681 2682 static SIMD_CFUNC simd_half32 __tg_fmin(simd_half32 x, simd_half32 y) { 2683 return simd_make_half32(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2684 } 2685 2686 static SIMD_CFUNC simd_float2 __tg_fmin(simd_float2 x, simd_float2 y) { 2687 #if defined __SSE2__ 2688 return simd_make_float2(__tg_fmin(simd_make_float4_undef(x), simd_make_float4_undef(y))); 2689 #elif defined __arm64__ || defined __aarch64__ 2690 return vminnm_f32(x, y); 2691 #elif defined __arm__ && __FINITE_MATH_ONLY__ 2692 return vmin_f32(x, y); 2693 #else 2694 return simd_bitselect(y, x, (x <= y) | (y != y)); 2695 #endif 2696 } 2697 2698 static SIMD_CFUNC simd_float3 __tg_fmin(simd_float3 x, simd_float3 y) { 2699 return simd_make_float3(__tg_fmin(simd_make_float4_undef(x), simd_make_float4_undef(y))); 2700 } 2701 2702 static SIMD_CFUNC simd_float4 __tg_fmin(simd_float4 x, simd_float4 y) { 2703 #if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__ 2704 return _mm_range_ps(x, y, 4); 2705 #elif defined __SSE2__ && __FINITE_MATH_ONLY__ 2706 return _mm_min_ps(x, y); 2707 #elif defined __SSE2__ 2708 return simd_bitselect(_mm_min_ps(x, y), x, y != y); 2709 #elif defined __arm64__ || defined __aarch64__ 2710 return vminnmq_f32(x, y); 2711 #elif defined __arm__ && __FINITE_MATH_ONLY__ 2712 return vminq_f32(x, y); 2713 #else 2714 return simd_bitselect(y, x, (x <= y) | (y != y)); 2715 #endif 2716 } 2717 2718 static SIMD_CFUNC simd_float8 __tg_fmin(simd_float8 x, simd_float8 y) { 2719 #if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__ 2720 return _mm256_range_ps(x, y, 4); 2721 #elif defined __AVX__ && __FINITE_MATH_ONLY__ 2722 return _mm256_min_ps(x, y); 2723 #elif defined __AVX__ 2724 return simd_bitselect(_mm256_min_ps(x, y), x, y != y); 2725 #else 2726 return simd_make_float8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2727 #endif 2728 } 2729 2730 static SIMD_CFUNC simd_float16 __tg_fmin(simd_float16 x, simd_float16 y) { 2731 #if defined __x86_64__ && defined __AVX512DQ__ && !__FINITE_MATH_ONLY__ 2732 return _mm512_range_ps(x, y, 4); 2733 #elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__ 2734 return _mm512_min_ps(x, y); 2735 #elif defined __x86_64__ && defined __AVX512F__ 2736 return simd_bitselect(_mm512_min_ps(x, y), x, y != y); 2737 #else 2738 return simd_make_float16(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2739 #endif 2740 } 2741 2742 static SIMD_CFUNC simd_double2 __tg_fmin(simd_double2 x, simd_double2 y) { 2743 #if defined __AVX512DQ__ && defined __AVX512VL__ 2744 return _mm_range_pd(x, y, 4); 2745 #elif defined __SSE2__ && __FINITE_MATH_ONLY__ 2746 return _mm_min_pd(x, y); 2747 #elif defined __SSE2__ 2748 return simd_bitselect(_mm_min_pd(x, y), x, y != y); 2749 #elif defined __arm64__ || defined __aarch64__ 2750 return vminnmq_f64(x, y); 2751 #else 2752 return simd_bitselect(y, x, (x <= y) | (y != y)); 2753 #endif 2754 } 2755 2756 static SIMD_CFUNC simd_double3 __tg_fmin(simd_double3 x, simd_double3 y) { 2757 return simd_make_double3(__tg_fmin(simd_make_double4_undef(x), simd_make_double4_undef(y))); 2758 } 2759 2760 static SIMD_CFUNC simd_double4 __tg_fmin(simd_double4 x, simd_double4 y) { 2761 #if defined __AVX512DQ__ && defined __AVX512VL__ 2762 return _mm256_range_pd(x, y, 4); 2763 #elif defined __AVX__ && __FINITE_MATH_ONLY__ 2764 return _mm256_min_pd(x, y); 2765 #elif defined __AVX__ 2766 return simd_bitselect(_mm256_min_pd(x, y), x, y != y); 2767 #else 2768 return simd_make_double4(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2769 #endif 2770 } 2771 2772 static SIMD_CFUNC simd_double8 __tg_fmin(simd_double8 x, simd_double8 y) { 2773 #if defined __x86_64__ && defined __AVX512DQ__ 2774 return _mm512_range_pd(x, y, 4); 2775 #elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__ 2776 return _mm512_min_pd(x, y); 2777 #elif defined __x86_64__ && defined __AVX512F__ 2778 return simd_bitselect(_mm512_min_pd(x, y), x, y != y); 2779 #else 2780 return simd_make_double8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi)); 2781 #endif 2782 } 2783 2784 static SIMD_CFUNC simd_half2 __tg_fmax(simd_half2 x, simd_half2 y) { 2785 return __tg_fmax(simd_make_half4_undef(x), simd_make_half4_undef(y)).lo; 2786 } 2787 2788 static SIMD_CFUNC simd_half3 __tg_fmax(simd_half3 x, simd_half3 y) { 2789 return simd_make_half3(__tg_fmax(simd_make_half4_undef(x), simd_make_half4_undef(y))); 2790 } 2791 2792 static SIMD_CFUNC simd_half4 __tg_fmax(simd_half4 x, simd_half4 y) { 2793 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2794 return vmaxnm_f16(x, y); 2795 #else 2796 return simd_bitselect(y, x, (x >= y) | (y != y)); 2797 #endif 2798 } 2799 2800 static SIMD_CFUNC simd_half8 __tg_fmax(simd_half8 x, simd_half8 y) { 2801 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2802 return vmaxnmq_f16(x, y); 2803 #else 2804 return simd_make_half8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2805 #endif 2806 } 2807 2808 static SIMD_CFUNC simd_half16 __tg_fmax(simd_half16 x, simd_half16 y) { 2809 return simd_make_half16(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2810 } 2811 2812 static SIMD_CFUNC simd_half32 __tg_fmax(simd_half32 x, simd_half32 y) { 2813 return simd_make_half32(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2814 } 2815 2816 static SIMD_CFUNC simd_float2 __tg_fmax(simd_float2 x, simd_float2 y) { 2817 #if defined __SSE2__ 2818 return simd_make_float2(__tg_fmax(simd_make_float4_undef(x), simd_make_float4_undef(y))); 2819 #elif defined __arm64__ || defined __aarch64__ 2820 return vmaxnm_f32(x, y); 2821 #elif defined __arm__ && __FINITE_MATH_ONLY__ 2822 return vmax_f32(x, y); 2823 #else 2824 return simd_bitselect(y, x, (x >= y) | (y != y)); 2825 #endif 2826 } 2827 2828 static SIMD_CFUNC simd_float3 __tg_fmax(simd_float3 x, simd_float3 y) { 2829 return simd_make_float3(__tg_fmax(simd_make_float4_undef(x), simd_make_float4_undef(y))); 2830 } 2831 2832 static SIMD_CFUNC simd_float4 __tg_fmax(simd_float4 x, simd_float4 y) { 2833 #if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__ 2834 return _mm_range_ps(x, y, 5); 2835 #elif defined __SSE2__ && __FINITE_MATH_ONLY__ 2836 return _mm_max_ps(x, y); 2837 #elif defined __SSE2__ 2838 return simd_bitselect(_mm_max_ps(x, y), x, y != y); 2839 #elif defined __arm64__ || defined __aarch64__ 2840 return vmaxnmq_f32(x, y); 2841 #elif defined __arm__ && __FINITE_MATH_ONLY__ 2842 return vmaxq_f32(x, y); 2843 #else 2844 return simd_bitselect(y, x, (x >= y) | (y != y)); 2845 #endif 2846 } 2847 2848 static SIMD_CFUNC simd_float8 __tg_fmax(simd_float8 x, simd_float8 y) { 2849 #if defined __AVX512DQ__ && defined __AVX512VL__ && !__FINITE_MATH_ONLY__ 2850 return _mm256_range_ps(x, y, 5); 2851 #elif defined __AVX__ && __FINITE_MATH_ONLY__ 2852 return _mm256_max_ps(x, y); 2853 #elif defined __AVX__ 2854 return simd_bitselect(_mm256_max_ps(x, y), x, y != y); 2855 #else 2856 return simd_make_float8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2857 #endif 2858 } 2859 2860 static SIMD_CFUNC simd_float16 __tg_fmax(simd_float16 x, simd_float16 y) { 2861 #if defined __x86_64__ && defined __AVX512DQ__ && !__FINITE_MATH_ONLY__ 2862 return _mm512_range_ps(x, y, 5); 2863 #elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__ 2864 return _mm512_max_ps(x, y); 2865 #elif defined __x86_64__ && defined __AVX512F__ 2866 return simd_bitselect(_mm512_max_ps(x, y), x, y != y); 2867 #else 2868 return simd_make_float16(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2869 #endif 2870 } 2871 2872 static SIMD_CFUNC simd_double2 __tg_fmax(simd_double2 x, simd_double2 y) { 2873 #if defined __AVX512DQ__ && defined __AVX512VL__ 2874 return _mm_range_pd(x, y, 5); 2875 #elif defined __SSE2__ && __FINITE_MATH_ONLY__ 2876 return _mm_max_pd(x, y); 2877 #elif defined __SSE2__ 2878 return simd_bitselect(_mm_max_pd(x, y), x, y != y); 2879 #elif defined __arm64__ || defined __aarch64__ 2880 return vmaxnmq_f64(x, y); 2881 #else 2882 return simd_bitselect(y, x, (x >= y) | (y != y)); 2883 #endif 2884 } 2885 2886 static SIMD_CFUNC simd_double3 __tg_fmax(simd_double3 x, simd_double3 y) { 2887 return simd_make_double3(__tg_fmax(simd_make_double4_undef(x), simd_make_double4_undef(y))); 2888 } 2889 2890 static SIMD_CFUNC simd_double4 __tg_fmax(simd_double4 x, simd_double4 y) { 2891 #if defined __AVX512DQ__ && defined __AVX512VL__ 2892 return _mm256_range_pd(x, y, 5); 2893 #elif defined __AVX__ && __FINITE_MATH_ONLY__ 2894 return _mm256_max_pd(x, y); 2895 #elif defined __AVX__ 2896 return simd_bitselect(_mm256_max_pd(x, y), x, y != y); 2897 #else 2898 return simd_make_double4(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2899 #endif 2900 } 2901 2902 static SIMD_CFUNC simd_double8 __tg_fmax(simd_double8 x, simd_double8 y) { 2903 #if defined __x86_64__ && defined __AVX512DQ__ 2904 return _mm512_range_pd(x, y, 5); 2905 #elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__ 2906 return _mm512_max_pd(x, y); 2907 #elif defined __x86_64__ && defined __AVX512F__ 2908 return simd_bitselect(_mm512_max_pd(x, y), x, y != y); 2909 #else 2910 return simd_make_double8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi)); 2911 #endif 2912 } 2913 2914 #pragma mark - copysign implementation 2915 static inline SIMD_CFUNC simd_half2 __tg_copysign(simd_half2 x, simd_half2 y) { return simd_bitselect(y, x, 0x7fff); } 2916 static inline SIMD_CFUNC simd_half3 __tg_copysign(simd_half3 x, simd_half3 y) { return simd_bitselect(y, x, 0x7fff); } 2917 static inline SIMD_CFUNC simd_half4 __tg_copysign(simd_half4 x, simd_half4 y) { return simd_bitselect(y, x, 0x7fff); } 2918 static inline SIMD_CFUNC simd_half8 __tg_copysign(simd_half8 x, simd_half8 y) { return simd_bitselect(y, x, 0x7fff); } 2919 static inline SIMD_CFUNC simd_half16 __tg_copysign(simd_half16 x, simd_half16 y) { return simd_bitselect(y, x, 0x7fff); } 2920 static inline SIMD_CFUNC simd_half32 __tg_copysign(simd_half32 x, simd_half32 y) { return simd_bitselect(y, x, 0x7fff); } 2921 static inline SIMD_CFUNC simd_float2 __tg_copysign(simd_float2 x, simd_float2 y) { return simd_bitselect(y, x, 0x7fffffff); } 2922 static inline SIMD_CFUNC simd_float3 __tg_copysign(simd_float3 x, simd_float3 y) { return simd_bitselect(y, x, 0x7fffffff); } 2923 static inline SIMD_CFUNC simd_float4 __tg_copysign(simd_float4 x, simd_float4 y) { return simd_bitselect(y, x, 0x7fffffff); } 2924 static inline SIMD_CFUNC simd_float8 __tg_copysign(simd_float8 x, simd_float8 y) { return simd_bitselect(y, x, 0x7fffffff); } 2925 static inline SIMD_CFUNC simd_float16 __tg_copysign(simd_float16 x, simd_float16 y) { return simd_bitselect(y, x, 0x7fffffff); } 2926 static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); } 2927 static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); } 2928 static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); } 2929 static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); } 2930 2931 #pragma mark - sqrt implementation 2932 static SIMD_CFUNC simd_half2 __tg_sqrt(simd_half2 x) { 2933 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2934 return __tg_sqrt(simd_make_half4_undef(x)).lo; 2935 #else 2936 return simd_make_half2(__sqrtf16(x.x), __sqrtf16(x.y)); 2937 #endif 2938 } 2939 2940 static SIMD_CFUNC simd_half3 __tg_sqrt(simd_half3 x) { 2941 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2942 return simd_make_half3(__tg_sqrt(simd_make_half4_undef(x))); 2943 #else 2944 return simd_make_half3(__sqrtf16(x.x), __sqrtf16(x.y), __sqrtf16(x.z)); 2945 #endif 2946 } 2947 2948 static SIMD_CFUNC simd_half4 __tg_sqrt(simd_half4 x) { 2949 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2950 return vsqrt_f16(x); 2951 #else 2952 return simd_make_half4(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 2953 #endif 2954 } 2955 2956 static SIMD_CFUNC simd_half8 __tg_sqrt(simd_half8 x) { 2957 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 2958 return vsqrtq_f16(x); 2959 #else 2960 return simd_make_half8(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 2961 #endif 2962 } 2963 2964 static SIMD_CFUNC simd_half16 __tg_sqrt(simd_half16 x) { 2965 return simd_make_half16(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 2966 } 2967 2968 static SIMD_CFUNC simd_half32 __tg_sqrt(simd_half32 x) { 2969 return simd_make_half32(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 2970 } 2971 2972 static SIMD_CFUNC simd_float2 __tg_sqrt(simd_float2 x) { 2973 #if defined __SSE2__ 2974 return simd_make_float2(__tg_sqrt(simd_make_float4_undef(x))); 2975 #elif defined __arm64__ || defined __aarch64__ 2976 return vsqrt_f32(x); 2977 #else 2978 return simd_make_float2(sqrt(x.x), sqrt(x.y)); 2979 #endif 2980 } 2981 2982 static SIMD_CFUNC simd_float3 __tg_sqrt(simd_float3 x) { 2983 return simd_make_float3(__tg_sqrt(simd_make_float4_undef(x))); 2984 } 2985 2986 static SIMD_CFUNC simd_float4 __tg_sqrt(simd_float4 x) { 2987 #if defined __SSE2__ 2988 return _mm_sqrt_ps(x); 2989 #elif defined __arm64__ || defined __aarch64__ 2990 return vsqrtq_f32(x); 2991 #else 2992 return simd_make_float4(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 2993 #endif 2994 } 2995 2996 static SIMD_CFUNC simd_float8 __tg_sqrt(simd_float8 x) { 2997 #if defined __AVX__ 2998 return _mm256_sqrt_ps(x); 2999 #else 3000 return simd_make_float8(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 3001 #endif 3002 } 3003 3004 static SIMD_CFUNC simd_float16 __tg_sqrt(simd_float16 x) { 3005 #if defined __x86_64__ && defined __AVX512F__ 3006 return _mm512_sqrt_ps(x); 3007 #else 3008 return simd_make_float16(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 3009 #endif 3010 } 3011 3012 static SIMD_CFUNC simd_double2 __tg_sqrt(simd_double2 x) { 3013 #if defined __SSE2__ 3014 return _mm_sqrt_pd(x); 3015 #elif defined __arm64__ || defined __aarch64__ 3016 return vsqrtq_f64(x); 3017 #else 3018 return simd_make_double2(sqrt(x.x), sqrt(x.y)); 3019 #endif 3020 } 3021 3022 static SIMD_CFUNC simd_double3 __tg_sqrt(simd_double3 x) { 3023 return simd_make_double3(__tg_sqrt(simd_make_double4_undef(x))); 3024 } 3025 3026 static SIMD_CFUNC simd_double4 __tg_sqrt(simd_double4 x) { 3027 #if defined __AVX__ 3028 return _mm256_sqrt_pd(x); 3029 #else 3030 return simd_make_double4(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 3031 #endif 3032 } 3033 3034 static SIMD_CFUNC simd_double8 __tg_sqrt(simd_double8 x) { 3035 #if defined __x86_64__ && defined __AVX512F__ 3036 return _mm512_sqrt_pd(x); 3037 #else 3038 return simd_make_double8(__tg_sqrt(x.lo), __tg_sqrt(x.hi)); 3039 #endif 3040 } 3041 3042 #pragma mark - ceil, floor, rint, trunc implementation 3043 static SIMD_CFUNC simd_half2 __tg_ceil(simd_half2 x) { 3044 return simd_make_half2(__tg_ceil(simd_make_half8_undef(x))); 3045 } 3046 3047 static SIMD_CFUNC simd_half3 __tg_ceil(simd_half3 x) { 3048 return simd_make_half3(__tg_ceil(simd_make_half4_undef(x))); 3049 } 3050 3051 static SIMD_CFUNC simd_half4 __tg_ceil(simd_half4 x) { 3052 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3053 return vrndp_f16(x); 3054 #else 3055 return simd_make_half4(__tg_ceil(simd_make_half8_undef(x))); 3056 #endif 3057 } 3058 3059 static SIMD_CFUNC simd_half8 __tg_ceil(simd_half8 x) { 3060 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3061 return vrndpq_f16(x); 3062 #else 3063 simd_half8 truncated = __tg_trunc(x); 3064 simd_half8 adjust = simd_bitselect((simd_half8)0, 1, truncated < x); 3065 return __tg_copysign(truncated + adjust, x); 3066 #endif 3067 } 3068 3069 static SIMD_CFUNC simd_half16 __tg_ceil(simd_half16 x) { 3070 return simd_make_half16(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3071 } 3072 3073 static SIMD_CFUNC simd_half32 __tg_ceil(simd_half32 x) { 3074 return simd_make_half32(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3075 } 3076 3077 static SIMD_CFUNC simd_half2 __tg_floor(simd_half2 x) { 3078 return simd_make_half2(__tg_floor(simd_make_half8_undef(x))); 3079 } 3080 3081 static SIMD_CFUNC simd_half3 __tg_floor(simd_half3 x) { 3082 return simd_make_half3(__tg_floor(simd_make_half4_undef(x))); 3083 } 3084 3085 static SIMD_CFUNC simd_half4 __tg_floor(simd_half4 x) { 3086 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3087 return vrndm_f16(x); 3088 #else 3089 return simd_make_half4(__tg_floor(simd_make_half8_undef(x))); 3090 #endif 3091 } 3092 3093 static SIMD_CFUNC simd_half8 __tg_floor(simd_half8 x) { 3094 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3095 return vrndmq_f16(x); 3096 #else 3097 simd_half8 truncated = __tg_trunc(x); 3098 simd_half8 adjust = simd_bitselect((simd_half8)0, 1, truncated > x); 3099 return truncated - adjust; 3100 #endif 3101 } 3102 3103 static SIMD_CFUNC simd_half16 __tg_floor(simd_half16 x) { 3104 return simd_make_half16(__tg_floor(x.lo), __tg_floor(x.hi)); 3105 } 3106 3107 static SIMD_CFUNC simd_half32 __tg_floor(simd_half32 x) { 3108 return simd_make_half32(__tg_floor(x.lo), __tg_floor(x.hi)); 3109 } 3110 3111 static SIMD_CFUNC simd_half2 __tg_rint(simd_half2 x) { 3112 return simd_make_half2(__tg_rint(simd_make_half8_undef(x))); 3113 } 3114 3115 static SIMD_CFUNC simd_half3 __tg_rint(simd_half3 x) { 3116 return simd_make_half3(__tg_rint(simd_make_half4_undef(x))); 3117 } 3118 3119 static SIMD_CFUNC simd_half4 __tg_rint(simd_half4 x) { 3120 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3121 return vrndx_f16(x); 3122 #else 3123 return simd_make_half4(__tg_rint(simd_make_half8_undef(x))); 3124 #endif 3125 } 3126 3127 static SIMD_CFUNC simd_half8 __tg_rint(simd_half8 x) { 3128 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3129 return vrndxq_f16(x); 3130 #else 3131 simd_half8 magic = __tg_copysign(0x1.0p10, x); 3132 simd_short8 x_is_small = __tg_fabs(x) < 0x1.0p10; 3133 return simd_bitselect(x, (x + magic) - magic, x_is_small & 0x7fff); 3134 #endif 3135 } 3136 3137 static SIMD_CFUNC simd_half16 __tg_rint(simd_half16 x) { 3138 return simd_make_half16(__tg_rint(x.lo), __tg_rint(x.hi)); 3139 } 3140 3141 static SIMD_CFUNC simd_half32 __tg_rint(simd_half32 x) { 3142 return simd_make_half32(__tg_rint(x.lo), __tg_rint(x.hi)); 3143 } 3144 3145 static SIMD_CFUNC simd_half2 __tg_trunc(simd_half2 x) { 3146 return simd_make_half2(__tg_trunc(simd_make_half8_undef(x))); 3147 } 3148 3149 static SIMD_CFUNC simd_half3 __tg_trunc(simd_half3 x) { 3150 return simd_make_half3(__tg_trunc(simd_make_half4_undef(x))); 3151 } 3152 3153 static SIMD_CFUNC simd_half4 __tg_trunc(simd_half4 x) { 3154 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3155 return vrnd_f16(x); 3156 #else 3157 return simd_make_half4(__tg_trunc(simd_make_half8_undef(x))); 3158 #endif 3159 } 3160 3161 static SIMD_CFUNC simd_half8 __tg_trunc(simd_half8 x) { 3162 #if defined __ARM_FEATURE_FP16_VECTOR_ARITHMETIC 3163 return vrndq_f16(x); 3164 #else 3165 simd_half8 binade = simd_bitselect(0, x, 0x3c00); 3166 simd_short8 mask = (simd_short8)__tg_fmin(-2*binade + 1, -0); 3167 simd_half8 result = simd_bitselect(0, x, mask); 3168 return simd_bitselect(x, result, binade < 0x1.0p10); 3169 #endif 3170 } 3171 3172 static SIMD_CFUNC simd_half16 __tg_trunc(simd_half16 x) { 3173 return simd_make_half16(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3174 } 3175 3176 static SIMD_CFUNC simd_half32 __tg_trunc(simd_half32 x) { 3177 return simd_make_half32(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3178 } 3179 3180 static SIMD_CFUNC simd_float2 __tg_ceil(simd_float2 x) { 3181 #if defined __arm64__ || defined __aarch64__ 3182 return vrndp_f32(x); 3183 #else 3184 return simd_make_float2(__tg_ceil(simd_make_float4_undef(x))); 3185 #endif 3186 } 3187 3188 static SIMD_CFUNC simd_float3 __tg_ceil(simd_float3 x) { 3189 return simd_make_float3(__tg_ceil(simd_make_float4_undef(x))); 3190 } 3191 3192 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3193 extern simd_float4 _simd_ceil_f4(simd_float4 x); 3194 #endif 3195 3196 static SIMD_CFUNC simd_float4 __tg_ceil(simd_float4 x) { 3197 #if defined __SSE4_1__ 3198 return _mm_round_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3199 #elif defined __arm64__ || defined __aarch64__ 3200 return vrndpq_f32(x); 3201 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3202 return _simd_ceil_f4(x); 3203 #else 3204 simd_float4 truncated = __tg_trunc(x); 3205 simd_float4 adjust = simd_bitselect((simd_float4)0, 1, truncated < x); 3206 return __tg_copysign(truncated + adjust, x); 3207 #endif 3208 } 3209 3210 static SIMD_CFUNC simd_float8 __tg_ceil(simd_float8 x) { 3211 #if defined __AVX__ 3212 return _mm256_round_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3213 #else 3214 return simd_make_float8(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3215 #endif 3216 } 3217 3218 static SIMD_CFUNC simd_float16 __tg_ceil(simd_float16 x) { 3219 #if defined __x86_64__ && defined __AVX512F__ 3220 return _mm512_roundscale_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3221 #else 3222 return simd_make_float16(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3223 #endif 3224 } 3225 3226 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3227 extern simd_double2 _simd_ceil_d2(simd_double2 x); 3228 #endif 3229 3230 static SIMD_CFUNC simd_double2 __tg_ceil(simd_double2 x) { 3231 #if defined __SSE4_1__ 3232 return _mm_round_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3233 #elif defined __arm64__ || defined __aarch64__ 3234 return vrndpq_f64(x); 3235 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3236 return _simd_ceil_d2(x); 3237 #else 3238 simd_double2 truncated = __tg_trunc(x); 3239 simd_double2 adjust = simd_bitselect((simd_double2)0, 1, truncated < x); 3240 return __tg_copysign(truncated + adjust, x); 3241 #endif 3242 } 3243 3244 static SIMD_CFUNC simd_double3 __tg_ceil(simd_double3 x) { 3245 return simd_make_double3(__tg_ceil(simd_make_double4_undef(x))); 3246 } 3247 3248 static SIMD_CFUNC simd_double4 __tg_ceil(simd_double4 x) { 3249 #if defined __AVX__ 3250 return _mm256_round_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3251 #else 3252 return simd_make_double4(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3253 #endif 3254 } 3255 3256 static SIMD_CFUNC simd_double8 __tg_ceil(simd_double8 x) { 3257 #if defined __x86_64__ && defined __AVX512F__ 3258 return _mm512_roundscale_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); 3259 #else 3260 return simd_make_double8(__tg_ceil(x.lo), __tg_ceil(x.hi)); 3261 #endif 3262 } 3263 3264 static SIMD_CFUNC simd_float2 __tg_floor(simd_float2 x) { 3265 #if defined __arm64__ || defined __aarch64__ 3266 return vrndm_f32(x); 3267 #else 3268 return simd_make_float2(__tg_floor(simd_make_float4_undef(x))); 3269 #endif 3270 } 3271 3272 static SIMD_CFUNC simd_float3 __tg_floor(simd_float3 x) { 3273 return simd_make_float3(__tg_floor(simd_make_float4_undef(x))); 3274 } 3275 3276 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3277 extern simd_float4 _simd_floor_f4(simd_float4 x); 3278 #endif 3279 3280 static SIMD_CFUNC simd_float4 __tg_floor(simd_float4 x) { 3281 #if defined __SSE4_1__ 3282 return _mm_round_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3283 #elif defined __arm64__ || defined __aarch64__ 3284 return vrndmq_f32(x); 3285 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3286 return _simd_floor_f4(x); 3287 #else 3288 simd_float4 truncated = __tg_trunc(x); 3289 simd_float4 adjust = simd_bitselect((simd_float4)0, 1, truncated > x); 3290 return truncated - adjust; 3291 #endif 3292 } 3293 3294 static SIMD_CFUNC simd_float8 __tg_floor(simd_float8 x) { 3295 #if defined __AVX__ 3296 return _mm256_round_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3297 #else 3298 return simd_make_float8(__tg_floor(x.lo), __tg_floor(x.hi)); 3299 #endif 3300 } 3301 3302 static SIMD_CFUNC simd_float16 __tg_floor(simd_float16 x) { 3303 #if defined __x86_64__ && defined __AVX512F__ 3304 return _mm512_roundscale_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3305 #else 3306 return simd_make_float16(__tg_floor(x.lo), __tg_floor(x.hi)); 3307 #endif 3308 } 3309 3310 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3311 extern simd_double2 _simd_floor_d2(simd_double2 x); 3312 #endif 3313 3314 static SIMD_CFUNC simd_double2 __tg_floor(simd_double2 x) { 3315 #if defined __SSE4_1__ 3316 return _mm_round_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3317 #elif defined __arm64__ || defined __aarch64__ 3318 return vrndmq_f64(x); 3319 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3320 return _simd_floor_d2(x); 3321 #else 3322 simd_double2 truncated = __tg_trunc(x); 3323 simd_double2 adjust = simd_bitselect((simd_double2)0, 1, truncated > x); 3324 return truncated - adjust; 3325 #endif 3326 } 3327 3328 static SIMD_CFUNC simd_double3 __tg_floor(simd_double3 x) { 3329 return simd_make_double3(__tg_floor(simd_make_double4_undef(x))); 3330 } 3331 3332 static SIMD_CFUNC simd_double4 __tg_floor(simd_double4 x) { 3333 #if defined __AVX__ 3334 return _mm256_round_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3335 #else 3336 return simd_make_double4(__tg_floor(x.lo), __tg_floor(x.hi)); 3337 #endif 3338 } 3339 3340 static SIMD_CFUNC simd_double8 __tg_floor(simd_double8 x) { 3341 #if defined __x86_64__ && defined __AVX512F__ 3342 return _mm512_roundscale_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); 3343 #else 3344 return simd_make_double8(__tg_floor(x.lo), __tg_floor(x.hi)); 3345 #endif 3346 } 3347 3348 static SIMD_CFUNC simd_float2 __tg_rint(simd_float2 x) { 3349 #if defined __arm64__ || defined __aarch64__ 3350 return vrndx_f32(x); 3351 #else 3352 return simd_make_float2(__tg_rint(simd_make_float4_undef(x))); 3353 #endif 3354 } 3355 3356 static SIMD_CFUNC simd_float3 __tg_rint(simd_float3 x) { 3357 return simd_make_float3(__tg_rint(simd_make_float4_undef(x))); 3358 } 3359 3360 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3361 extern simd_float4 _simd_rint_f4(simd_float4 x); 3362 #endif 3363 3364 static SIMD_CFUNC simd_float4 __tg_rint(simd_float4 x) { 3365 #if defined __SSE4_1__ 3366 return _mm_round_ps(x, _MM_FROUND_RINT); 3367 #elif defined __arm64__ || defined __aarch64__ 3368 return vrndxq_f32(x); 3369 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3370 return _simd_rint_f4(x); 3371 #else 3372 simd_float4 magic = __tg_copysign(0x1.0p23, x); 3373 simd_int4 x_is_small = __tg_fabs(x) < 0x1.0p23; 3374 return simd_bitselect(x, (x + magic) - magic, x_is_small & 0x7fffffff); 3375 #endif 3376 } 3377 3378 static SIMD_CFUNC simd_float8 __tg_rint(simd_float8 x) { 3379 #if defined __AVX__ 3380 return _mm256_round_ps(x, _MM_FROUND_RINT); 3381 #else 3382 return simd_make_float8(__tg_rint(x.lo), __tg_rint(x.hi)); 3383 #endif 3384 } 3385 3386 static SIMD_CFUNC simd_float16 __tg_rint(simd_float16 x) { 3387 #if defined __x86_64__ && defined __AVX512F__ 3388 return _mm512_roundscale_ps(x, _MM_FROUND_RINT); 3389 #else 3390 return simd_make_float16(__tg_rint(x.lo), __tg_rint(x.hi)); 3391 #endif 3392 } 3393 3394 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3395 extern simd_double2 _simd_rint_d2(simd_double2 x); 3396 #endif 3397 3398 static SIMD_CFUNC simd_double2 __tg_rint(simd_double2 x) { 3399 #if defined __SSE4_1__ 3400 return _mm_round_pd(x, _MM_FROUND_RINT); 3401 #elif defined __arm64__ || defined __aarch64__ 3402 return vrndxq_f64(x); 3403 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3404 return _simd_rint_d2(x); 3405 #else 3406 simd_double2 magic = __tg_copysign(0x1.0p52, x); 3407 simd_long2 x_is_small = __tg_fabs(x) < 0x1.0p52; 3408 return simd_bitselect(x, (x + magic) - magic, x_is_small & 0x7fffffffffffffff); 3409 #endif 3410 } 3411 3412 static SIMD_CFUNC simd_double3 __tg_rint(simd_double3 x) { 3413 return simd_make_double3(__tg_rint(simd_make_double4_undef(x))); 3414 } 3415 3416 static SIMD_CFUNC simd_double4 __tg_rint(simd_double4 x) { 3417 #if defined __AVX__ 3418 return _mm256_round_pd(x, _MM_FROUND_RINT); 3419 #else 3420 return simd_make_double4(__tg_rint(x.lo), __tg_rint(x.hi)); 3421 #endif 3422 } 3423 3424 static SIMD_CFUNC simd_double8 __tg_rint(simd_double8 x) { 3425 #if defined __x86_64__ && defined __AVX512F__ 3426 return _mm512_roundscale_pd(x, _MM_FROUND_RINT); 3427 #else 3428 return simd_make_double8(__tg_rint(x.lo), __tg_rint(x.hi)); 3429 #endif 3430 } 3431 3432 static SIMD_CFUNC simd_float2 __tg_trunc(simd_float2 x) { 3433 #if defined __arm64__ || defined __aarch64__ 3434 return vrnd_f32(x); 3435 #else 3436 return simd_make_float2(__tg_trunc(simd_make_float4_undef(x))); 3437 #endif 3438 } 3439 3440 static SIMD_CFUNC simd_float3 __tg_trunc(simd_float3 x) { 3441 return simd_make_float3(__tg_trunc(simd_make_float4_undef(x))); 3442 } 3443 3444 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3445 extern simd_float4 _simd_trunc_f4(simd_float4 x); 3446 #endif 3447 3448 static SIMD_CFUNC simd_float4 __tg_trunc(simd_float4 x) { 3449 #if defined __SSE4_1__ 3450 return _mm_round_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3451 #elif defined __arm64__ || defined __aarch64__ 3452 return vrndq_f32(x); 3453 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3454 return _simd_trunc_f4(x); 3455 #else 3456 simd_float4 binade = simd_bitselect(0, x, 0x7f800000); 3457 simd_int4 mask = (simd_int4)__tg_fmin(-2*binade + 1, -0); 3458 simd_float4 result = simd_bitselect(0, x, mask); 3459 return simd_bitselect(x, result, binade < 0x1.0p23); 3460 #endif 3461 } 3462 3463 static SIMD_CFUNC simd_float8 __tg_trunc(simd_float8 x) { 3464 #if defined __AVX__ 3465 return _mm256_round_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3466 #else 3467 return simd_make_float8(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3468 #endif 3469 } 3470 3471 static SIMD_CFUNC simd_float16 __tg_trunc(simd_float16 x) { 3472 #if defined __x86_64__ && defined __AVX512F__ 3473 return _mm512_roundscale_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3474 #else 3475 return simd_make_float16(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3476 #endif 3477 } 3478 3479 #if defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3480 extern simd_double2 _simd_trunc_d2(simd_double2 x); 3481 #endif 3482 3483 static SIMD_CFUNC simd_double2 __tg_trunc(simd_double2 x) { 3484 #if defined __SSE4_1__ 3485 return _mm_round_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3486 #elif defined __arm64__ || defined __aarch64__ 3487 return vrndq_f64(x); 3488 #elif defined __arm__ && SIMD_LIBRARY_VERSION >= 3 3489 return _simd_trunc_d2(x); 3490 #else 3491 simd_double2 binade = simd_bitselect(0, x, 0x7ff0000000000000); 3492 simd_long2 mask = (simd_long2)__tg_fmin(-2*binade + 1, -0); 3493 simd_double2 result = simd_bitselect(0, x, mask); 3494 return simd_bitselect(x, result, binade < 0x1.0p52); 3495 #endif 3496 } 3497 3498 static SIMD_CFUNC simd_double3 __tg_trunc(simd_double3 x) { 3499 return simd_make_double3(__tg_trunc(simd_make_double4_undef(x))); 3500 } 3501 3502 static SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x) { 3503 #if defined __AVX__ 3504 return _mm256_round_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3505 #else 3506 return simd_make_double4(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3507 #endif 3508 } 3509 3510 static SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x) { 3511 #if defined __x86_64__ && defined __AVX512F__ 3512 return _mm512_roundscale_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3513 #else 3514 return simd_make_double8(__tg_trunc(x.lo), __tg_trunc(x.hi)); 3515 #endif 3516 } 3517 3518 #pragma mark - sine, cosine implementation 3519 static inline SIMD_CFUNC simd_float2 __tg_sin(simd_float2 x) { 3520 return simd_make_float2(__tg_sin(simd_make_float4(x))); 3521 } 3522 3523 static inline SIMD_CFUNC simd_float3 __tg_sin(simd_float3 x) { 3524 return simd_make_float3(__tg_sin(simd_make_float4(x))); 3525 } 3526 3527 #if SIMD_LIBRARY_VERSION >= 3 3528 extern simd_float4 _simd_sin_f4(simd_float4 x); 3529 static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) { 3530 return _simd_sin_f4(x); 3531 } 3532 #elif SIMD_LIBRARY_VERSION == 1 3533 extern simd_float4 __sin_f4(simd_float4 x); 3534 static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) { 3535 return __sin_f4(x); 3536 } 3537 #else 3538 static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) { 3539 return simd_make_float4(sin(x.x), sin(x.y), sin(x.z), sin(x.w)); 3540 } 3541 #endif 3542 3543 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3544 extern simd_float8 _simd_sin_f8(simd_float8 x); 3545 static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) { 3546 return _simd_sin_f8(x); 3547 } 3548 #else 3549 static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) { 3550 return simd_make_float8(__tg_sin(x.lo), __tg_sin(x.hi)); 3551 } 3552 #endif 3553 3554 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3555 extern simd_float16 _simd_sin_f16(simd_float16 x); 3556 static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x) { 3557 return _simd_sin_f16(x); 3558 } 3559 #else 3560 static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x) { 3561 return simd_make_float16(__tg_sin(x.lo), __tg_sin(x.hi)); 3562 } 3563 #endif 3564 3565 #if SIMD_LIBRARY_VERSION >= 3 3566 extern simd_double2 _simd_sin_d2(simd_double2 x); 3567 static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) { 3568 return _simd_sin_d2(x); 3569 } 3570 #elif SIMD_LIBRARY_VERSION == 1 3571 extern simd_double2 __sin_d2(simd_double2 x); 3572 static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) { 3573 return __sin_d2(x); 3574 } 3575 #else 3576 static inline SIMD_CFUNC simd_double2 __tg_sin(simd_double2 x) { 3577 return simd_make_double2(sin(x.x), sin(x.y)); 3578 } 3579 #endif 3580 3581 static inline SIMD_CFUNC simd_double3 __tg_sin(simd_double3 x) { 3582 return simd_make_double3(__tg_sin(simd_make_double4(x))); 3583 } 3584 3585 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3586 extern simd_double4 _simd_sin_d4(simd_double4 x); 3587 static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) { 3588 return _simd_sin_d4(x); 3589 } 3590 #else 3591 static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) { 3592 return simd_make_double4(__tg_sin(x.lo), __tg_sin(x.hi)); 3593 } 3594 #endif 3595 3596 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3597 extern simd_double8 _simd_sin_d8(simd_double8 x); 3598 static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x) { 3599 return _simd_sin_d8(x); 3600 } 3601 #else 3602 static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x) { 3603 return simd_make_double8(__tg_sin(x.lo), __tg_sin(x.hi)); 3604 } 3605 #endif 3606 3607 static inline SIMD_CFUNC simd_float2 __tg_cos(simd_float2 x) { 3608 return simd_make_float2(__tg_cos(simd_make_float4(x))); 3609 } 3610 3611 static inline SIMD_CFUNC simd_float3 __tg_cos(simd_float3 x) { 3612 return simd_make_float3(__tg_cos(simd_make_float4(x))); 3613 } 3614 3615 #if SIMD_LIBRARY_VERSION >= 3 3616 extern simd_float4 _simd_cos_f4(simd_float4 x); 3617 static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) { 3618 return _simd_cos_f4(x); 3619 } 3620 #elif SIMD_LIBRARY_VERSION == 1 3621 extern simd_float4 __cos_f4(simd_float4 x); 3622 static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) { 3623 return __cos_f4(x); 3624 } 3625 #else 3626 static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) { 3627 return simd_make_float4(cos(x.x), cos(x.y), cos(x.z), cos(x.w)); 3628 } 3629 #endif 3630 3631 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3632 extern simd_float8 _simd_cos_f8(simd_float8 x); 3633 static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) { 3634 return _simd_cos_f8(x); 3635 } 3636 #else 3637 static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) { 3638 return simd_make_float8(__tg_cos(x.lo), __tg_cos(x.hi)); 3639 } 3640 #endif 3641 3642 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3643 extern simd_float16 _simd_cos_f16(simd_float16 x); 3644 static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x) { 3645 return _simd_cos_f16(x); 3646 } 3647 #else 3648 static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x) { 3649 return simd_make_float16(__tg_cos(x.lo), __tg_cos(x.hi)); 3650 } 3651 #endif 3652 3653 #if SIMD_LIBRARY_VERSION >= 3 3654 extern simd_double2 _simd_cos_d2(simd_double2 x); 3655 static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) { 3656 return _simd_cos_d2(x); 3657 } 3658 #elif SIMD_LIBRARY_VERSION == 1 3659 extern simd_double2 __cos_d2(simd_double2 x); 3660 static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) { 3661 return __cos_d2(x); 3662 } 3663 #else 3664 static inline SIMD_CFUNC simd_double2 __tg_cos(simd_double2 x) { 3665 return simd_make_double2(cos(x.x), cos(x.y)); 3666 } 3667 #endif 3668 3669 static inline SIMD_CFUNC simd_double3 __tg_cos(simd_double3 x) { 3670 return simd_make_double3(__tg_cos(simd_make_double4(x))); 3671 } 3672 3673 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3674 extern simd_double4 _simd_cos_d4(simd_double4 x); 3675 static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) { 3676 return _simd_cos_d4(x); 3677 } 3678 #else 3679 static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) { 3680 return simd_make_double4(__tg_cos(x.lo), __tg_cos(x.hi)); 3681 } 3682 #endif 3683 3684 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3685 extern simd_double8 _simd_cos_d8(simd_double8 x); 3686 static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x) { 3687 return _simd_cos_d8(x); 3688 } 3689 #else 3690 static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x) { 3691 return simd_make_double8(__tg_cos(x.lo), __tg_cos(x.hi)); 3692 } 3693 #endif 3694 3695 3696 #pragma mark - acos implementation 3697 static inline SIMD_CFUNC simd_float2 __tg_acos(simd_float2 x) { 3698 return simd_make_float2(__tg_acos(simd_make_float4(x))); 3699 } 3700 3701 static inline SIMD_CFUNC simd_float3 __tg_acos(simd_float3 x) { 3702 return simd_make_float3(__tg_acos(simd_make_float4(x))); 3703 } 3704 3705 #if SIMD_LIBRARY_VERSION >= 3 3706 extern simd_float4 _simd_acos_f4(simd_float4 x); 3707 static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x) { 3708 return _simd_acos_f4(x); 3709 } 3710 #else 3711 static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x) { 3712 return simd_make_float4(acos(x.x), acos(x.y), acos(x.z), acos(x.w)); 3713 } 3714 #endif 3715 3716 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3717 extern simd_float8 _simd_acos_f8(simd_float8 x); 3718 static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) { 3719 return _simd_acos_f8(x); 3720 } 3721 #else 3722 static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) { 3723 return simd_make_float8(__tg_acos(x.lo), __tg_acos(x.hi)); 3724 } 3725 #endif 3726 3727 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3728 extern simd_float16 _simd_acos_f16(simd_float16 x); 3729 static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x) { 3730 return _simd_acos_f16(x); 3731 } 3732 #else 3733 static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x) { 3734 return simd_make_float16(__tg_acos(x.lo), __tg_acos(x.hi)); 3735 } 3736 #endif 3737 3738 #if SIMD_LIBRARY_VERSION >= 3 3739 extern simd_double2 _simd_acos_d2(simd_double2 x); 3740 static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x) { 3741 return _simd_acos_d2(x); 3742 } 3743 #else 3744 static inline SIMD_CFUNC simd_double2 __tg_acos(simd_double2 x) { 3745 return simd_make_double2(acos(x.x), acos(x.y)); 3746 } 3747 #endif 3748 3749 static inline SIMD_CFUNC simd_double3 __tg_acos(simd_double3 x) { 3750 return simd_make_double3(__tg_acos(simd_make_double4(x))); 3751 } 3752 3753 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3754 extern simd_double4 _simd_acos_d4(simd_double4 x); 3755 static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) { 3756 return _simd_acos_d4(x); 3757 } 3758 #else 3759 static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) { 3760 return simd_make_double4(__tg_acos(x.lo), __tg_acos(x.hi)); 3761 } 3762 #endif 3763 3764 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3765 extern simd_double8 _simd_acos_d8(simd_double8 x); 3766 static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x) { 3767 return _simd_acos_d8(x); 3768 } 3769 #else 3770 static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x) { 3771 return simd_make_double8(__tg_acos(x.lo), __tg_acos(x.hi)); 3772 } 3773 #endif 3774 3775 #pragma mark - asin implementation 3776 static inline SIMD_CFUNC simd_float2 __tg_asin(simd_float2 x) { 3777 return simd_make_float2(__tg_asin(simd_make_float4(x))); 3778 } 3779 3780 static inline SIMD_CFUNC simd_float3 __tg_asin(simd_float3 x) { 3781 return simd_make_float3(__tg_asin(simd_make_float4(x))); 3782 } 3783 3784 #if SIMD_LIBRARY_VERSION >= 3 3785 extern simd_float4 _simd_asin_f4(simd_float4 x); 3786 static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x) { 3787 return _simd_asin_f4(x); 3788 } 3789 #else 3790 static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x) { 3791 return simd_make_float4(asin(x.x), asin(x.y), asin(x.z), asin(x.w)); 3792 } 3793 #endif 3794 3795 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3796 extern simd_float8 _simd_asin_f8(simd_float8 x); 3797 static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) { 3798 return _simd_asin_f8(x); 3799 } 3800 #else 3801 static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) { 3802 return simd_make_float8(__tg_asin(x.lo), __tg_asin(x.hi)); 3803 } 3804 #endif 3805 3806 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3807 extern simd_float16 _simd_asin_f16(simd_float16 x); 3808 static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x) { 3809 return _simd_asin_f16(x); 3810 } 3811 #else 3812 static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x) { 3813 return simd_make_float16(__tg_asin(x.lo), __tg_asin(x.hi)); 3814 } 3815 #endif 3816 3817 #if SIMD_LIBRARY_VERSION >= 3 3818 extern simd_double2 _simd_asin_d2(simd_double2 x); 3819 static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x) { 3820 return _simd_asin_d2(x); 3821 } 3822 #else 3823 static inline SIMD_CFUNC simd_double2 __tg_asin(simd_double2 x) { 3824 return simd_make_double2(asin(x.x), asin(x.y)); 3825 } 3826 #endif 3827 3828 static inline SIMD_CFUNC simd_double3 __tg_asin(simd_double3 x) { 3829 return simd_make_double3(__tg_asin(simd_make_double4(x))); 3830 } 3831 3832 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3833 extern simd_double4 _simd_asin_d4(simd_double4 x); 3834 static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) { 3835 return _simd_asin_d4(x); 3836 } 3837 #else 3838 static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) { 3839 return simd_make_double4(__tg_asin(x.lo), __tg_asin(x.hi)); 3840 } 3841 #endif 3842 3843 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3844 extern simd_double8 _simd_asin_d8(simd_double8 x); 3845 static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x) { 3846 return _simd_asin_d8(x); 3847 } 3848 #else 3849 static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x) { 3850 return simd_make_double8(__tg_asin(x.lo), __tg_asin(x.hi)); 3851 } 3852 #endif 3853 3854 #pragma mark - atan implementation 3855 static inline SIMD_CFUNC simd_float2 __tg_atan(simd_float2 x) { 3856 return simd_make_float2(__tg_atan(simd_make_float4(x))); 3857 } 3858 3859 static inline SIMD_CFUNC simd_float3 __tg_atan(simd_float3 x) { 3860 return simd_make_float3(__tg_atan(simd_make_float4(x))); 3861 } 3862 3863 #if SIMD_LIBRARY_VERSION >= 3 3864 extern simd_float4 _simd_atan_f4(simd_float4 x); 3865 static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x) { 3866 return _simd_atan_f4(x); 3867 } 3868 #else 3869 static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x) { 3870 return simd_make_float4(atan(x.x), atan(x.y), atan(x.z), atan(x.w)); 3871 } 3872 #endif 3873 3874 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3875 extern simd_float8 _simd_atan_f8(simd_float8 x); 3876 static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) { 3877 return _simd_atan_f8(x); 3878 } 3879 #else 3880 static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) { 3881 return simd_make_float8(__tg_atan(x.lo), __tg_atan(x.hi)); 3882 } 3883 #endif 3884 3885 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3886 extern simd_float16 _simd_atan_f16(simd_float16 x); 3887 static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x) { 3888 return _simd_atan_f16(x); 3889 } 3890 #else 3891 static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x) { 3892 return simd_make_float16(__tg_atan(x.lo), __tg_atan(x.hi)); 3893 } 3894 #endif 3895 3896 #if SIMD_LIBRARY_VERSION >= 3 3897 extern simd_double2 _simd_atan_d2(simd_double2 x); 3898 static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x) { 3899 return _simd_atan_d2(x); 3900 } 3901 #else 3902 static inline SIMD_CFUNC simd_double2 __tg_atan(simd_double2 x) { 3903 return simd_make_double2(atan(x.x), atan(x.y)); 3904 } 3905 #endif 3906 3907 static inline SIMD_CFUNC simd_double3 __tg_atan(simd_double3 x) { 3908 return simd_make_double3(__tg_atan(simd_make_double4(x))); 3909 } 3910 3911 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3912 extern simd_double4 _simd_atan_d4(simd_double4 x); 3913 static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) { 3914 return _simd_atan_d4(x); 3915 } 3916 #else 3917 static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) { 3918 return simd_make_double4(__tg_atan(x.lo), __tg_atan(x.hi)); 3919 } 3920 #endif 3921 3922 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3923 extern simd_double8 _simd_atan_d8(simd_double8 x); 3924 static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x) { 3925 return _simd_atan_d8(x); 3926 } 3927 #else 3928 static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x) { 3929 return simd_make_double8(__tg_atan(x.lo), __tg_atan(x.hi)); 3930 } 3931 #endif 3932 3933 #pragma mark - tan implementation 3934 static inline SIMD_CFUNC simd_float2 __tg_tan(simd_float2 x) { 3935 return simd_make_float2(__tg_tan(simd_make_float4(x))); 3936 } 3937 3938 static inline SIMD_CFUNC simd_float3 __tg_tan(simd_float3 x) { 3939 return simd_make_float3(__tg_tan(simd_make_float4(x))); 3940 } 3941 3942 #if SIMD_LIBRARY_VERSION >= 3 3943 extern simd_float4 _simd_tan_f4(simd_float4 x); 3944 static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x) { 3945 return _simd_tan_f4(x); 3946 } 3947 #else 3948 static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x) { 3949 return simd_make_float4(tan(x.x), tan(x.y), tan(x.z), tan(x.w)); 3950 } 3951 #endif 3952 3953 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3954 extern simd_float8 _simd_tan_f8(simd_float8 x); 3955 static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) { 3956 return _simd_tan_f8(x); 3957 } 3958 #else 3959 static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) { 3960 return simd_make_float8(__tg_tan(x.lo), __tg_tan(x.hi)); 3961 } 3962 #endif 3963 3964 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 3965 extern simd_float16 _simd_tan_f16(simd_float16 x); 3966 static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x) { 3967 return _simd_tan_f16(x); 3968 } 3969 #else 3970 static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x) { 3971 return simd_make_float16(__tg_tan(x.lo), __tg_tan(x.hi)); 3972 } 3973 #endif 3974 3975 #if SIMD_LIBRARY_VERSION >= 3 3976 extern simd_double2 _simd_tan_d2(simd_double2 x); 3977 static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x) { 3978 return _simd_tan_d2(x); 3979 } 3980 #else 3981 static inline SIMD_CFUNC simd_double2 __tg_tan(simd_double2 x) { 3982 return simd_make_double2(tan(x.x), tan(x.y)); 3983 } 3984 #endif 3985 3986 static inline SIMD_CFUNC simd_double3 __tg_tan(simd_double3 x) { 3987 return simd_make_double3(__tg_tan(simd_make_double4(x))); 3988 } 3989 3990 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 3991 extern simd_double4 _simd_tan_d4(simd_double4 x); 3992 static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) { 3993 return _simd_tan_d4(x); 3994 } 3995 #else 3996 static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) { 3997 return simd_make_double4(__tg_tan(x.lo), __tg_tan(x.hi)); 3998 } 3999 #endif 4000 4001 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4002 extern simd_double8 _simd_tan_d8(simd_double8 x); 4003 static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x) { 4004 return _simd_tan_d8(x); 4005 } 4006 #else 4007 static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x) { 4008 return simd_make_double8(__tg_tan(x.lo), __tg_tan(x.hi)); 4009 } 4010 #endif 4011 4012 #pragma mark - cospi implementation 4013 #if SIMD_LIBRARY_VERSION >= 1 4014 static inline SIMD_CFUNC simd_float2 __tg_cospi(simd_float2 x) { 4015 return simd_make_float2(__tg_cospi(simd_make_float4(x))); 4016 } 4017 4018 static inline SIMD_CFUNC simd_float3 __tg_cospi(simd_float3 x) { 4019 return simd_make_float3(__tg_cospi(simd_make_float4(x))); 4020 } 4021 4022 #if SIMD_LIBRARY_VERSION >= 3 4023 extern simd_float4 _simd_cospi_f4(simd_float4 x); 4024 static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x) { 4025 return _simd_cospi_f4(x); 4026 } 4027 #else 4028 static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x) { 4029 return simd_make_float4(__cospi(x.x), __cospi(x.y), __cospi(x.z), __cospi(x.w)); 4030 } 4031 #endif 4032 4033 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4034 extern simd_float8 _simd_cospi_f8(simd_float8 x); 4035 static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) { 4036 return _simd_cospi_f8(x); 4037 } 4038 #else 4039 static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) { 4040 return simd_make_float8(__tg_cospi(x.lo), __tg_cospi(x.hi)); 4041 } 4042 #endif 4043 4044 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4045 extern simd_float16 _simd_cospi_f16(simd_float16 x); 4046 static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x) { 4047 return _simd_cospi_f16(x); 4048 } 4049 #else 4050 static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x) { 4051 return simd_make_float16(__tg_cospi(x.lo), __tg_cospi(x.hi)); 4052 } 4053 #endif 4054 4055 #if SIMD_LIBRARY_VERSION >= 3 4056 extern simd_double2 _simd_cospi_d2(simd_double2 x); 4057 static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x) { 4058 return _simd_cospi_d2(x); 4059 } 4060 #else 4061 static inline SIMD_CFUNC simd_double2 __tg_cospi(simd_double2 x) { 4062 return simd_make_double2(__cospi(x.x), __cospi(x.y)); 4063 } 4064 #endif 4065 4066 static inline SIMD_CFUNC simd_double3 __tg_cospi(simd_double3 x) { 4067 return simd_make_double3(__tg_cospi(simd_make_double4(x))); 4068 } 4069 4070 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4071 extern simd_double4 _simd_cospi_d4(simd_double4 x); 4072 static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) { 4073 return _simd_cospi_d4(x); 4074 } 4075 #else 4076 static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) { 4077 return simd_make_double4(__tg_cospi(x.lo), __tg_cospi(x.hi)); 4078 } 4079 #endif 4080 4081 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4082 extern simd_double8 _simd_cospi_d8(simd_double8 x); 4083 static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x) { 4084 return _simd_cospi_d8(x); 4085 } 4086 #else 4087 static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x) { 4088 return simd_make_double8(__tg_cospi(x.lo), __tg_cospi(x.hi)); 4089 } 4090 #endif 4091 4092 #endif /* SIMD_LIBRARY_VERSION */ 4093 #pragma mark - sinpi implementation 4094 #if SIMD_LIBRARY_VERSION >= 1 4095 static inline SIMD_CFUNC simd_float2 __tg_sinpi(simd_float2 x) { 4096 return simd_make_float2(__tg_sinpi(simd_make_float4(x))); 4097 } 4098 4099 static inline SIMD_CFUNC simd_float3 __tg_sinpi(simd_float3 x) { 4100 return simd_make_float3(__tg_sinpi(simd_make_float4(x))); 4101 } 4102 4103 #if SIMD_LIBRARY_VERSION >= 3 4104 extern simd_float4 _simd_sinpi_f4(simd_float4 x); 4105 static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x) { 4106 return _simd_sinpi_f4(x); 4107 } 4108 #else 4109 static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x) { 4110 return simd_make_float4(__sinpi(x.x), __sinpi(x.y), __sinpi(x.z), __sinpi(x.w)); 4111 } 4112 #endif 4113 4114 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4115 extern simd_float8 _simd_sinpi_f8(simd_float8 x); 4116 static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) { 4117 return _simd_sinpi_f8(x); 4118 } 4119 #else 4120 static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) { 4121 return simd_make_float8(__tg_sinpi(x.lo), __tg_sinpi(x.hi)); 4122 } 4123 #endif 4124 4125 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4126 extern simd_float16 _simd_sinpi_f16(simd_float16 x); 4127 static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x) { 4128 return _simd_sinpi_f16(x); 4129 } 4130 #else 4131 static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x) { 4132 return simd_make_float16(__tg_sinpi(x.lo), __tg_sinpi(x.hi)); 4133 } 4134 #endif 4135 4136 #if SIMD_LIBRARY_VERSION >= 3 4137 extern simd_double2 _simd_sinpi_d2(simd_double2 x); 4138 static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x) { 4139 return _simd_sinpi_d2(x); 4140 } 4141 #else 4142 static inline SIMD_CFUNC simd_double2 __tg_sinpi(simd_double2 x) { 4143 return simd_make_double2(__sinpi(x.x), __sinpi(x.y)); 4144 } 4145 #endif 4146 4147 static inline SIMD_CFUNC simd_double3 __tg_sinpi(simd_double3 x) { 4148 return simd_make_double3(__tg_sinpi(simd_make_double4(x))); 4149 } 4150 4151 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4152 extern simd_double4 _simd_sinpi_d4(simd_double4 x); 4153 static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) { 4154 return _simd_sinpi_d4(x); 4155 } 4156 #else 4157 static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) { 4158 return simd_make_double4(__tg_sinpi(x.lo), __tg_sinpi(x.hi)); 4159 } 4160 #endif 4161 4162 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4163 extern simd_double8 _simd_sinpi_d8(simd_double8 x); 4164 static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x) { 4165 return _simd_sinpi_d8(x); 4166 } 4167 #else 4168 static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x) { 4169 return simd_make_double8(__tg_sinpi(x.lo), __tg_sinpi(x.hi)); 4170 } 4171 #endif 4172 4173 #endif /* SIMD_LIBRARY_VERSION */ 4174 #pragma mark - tanpi implementation 4175 #if SIMD_LIBRARY_VERSION >= 1 4176 static inline SIMD_CFUNC simd_float2 __tg_tanpi(simd_float2 x) { 4177 return simd_make_float2(__tg_tanpi(simd_make_float4(x))); 4178 } 4179 4180 static inline SIMD_CFUNC simd_float3 __tg_tanpi(simd_float3 x) { 4181 return simd_make_float3(__tg_tanpi(simd_make_float4(x))); 4182 } 4183 4184 #if SIMD_LIBRARY_VERSION >= 3 4185 extern simd_float4 _simd_tanpi_f4(simd_float4 x); 4186 static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x) { 4187 return _simd_tanpi_f4(x); 4188 } 4189 #else 4190 static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x) { 4191 return simd_make_float4(__tanpi(x.x), __tanpi(x.y), __tanpi(x.z), __tanpi(x.w)); 4192 } 4193 #endif 4194 4195 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4196 extern simd_float8 _simd_tanpi_f8(simd_float8 x); 4197 static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) { 4198 return _simd_tanpi_f8(x); 4199 } 4200 #else 4201 static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) { 4202 return simd_make_float8(__tg_tanpi(x.lo), __tg_tanpi(x.hi)); 4203 } 4204 #endif 4205 4206 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4207 extern simd_float16 _simd_tanpi_f16(simd_float16 x); 4208 static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x) { 4209 return _simd_tanpi_f16(x); 4210 } 4211 #else 4212 static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x) { 4213 return simd_make_float16(__tg_tanpi(x.lo), __tg_tanpi(x.hi)); 4214 } 4215 #endif 4216 4217 #if SIMD_LIBRARY_VERSION >= 3 4218 extern simd_double2 _simd_tanpi_d2(simd_double2 x); 4219 static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x) { 4220 return _simd_tanpi_d2(x); 4221 } 4222 #else 4223 static inline SIMD_CFUNC simd_double2 __tg_tanpi(simd_double2 x) { 4224 return simd_make_double2(__tanpi(x.x), __tanpi(x.y)); 4225 } 4226 #endif 4227 4228 static inline SIMD_CFUNC simd_double3 __tg_tanpi(simd_double3 x) { 4229 return simd_make_double3(__tg_tanpi(simd_make_double4(x))); 4230 } 4231 4232 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4233 extern simd_double4 _simd_tanpi_d4(simd_double4 x); 4234 static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) { 4235 return _simd_tanpi_d4(x); 4236 } 4237 #else 4238 static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) { 4239 return simd_make_double4(__tg_tanpi(x.lo), __tg_tanpi(x.hi)); 4240 } 4241 #endif 4242 4243 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4244 extern simd_double8 _simd_tanpi_d8(simd_double8 x); 4245 static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x) { 4246 return _simd_tanpi_d8(x); 4247 } 4248 #else 4249 static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x) { 4250 return simd_make_double8(__tg_tanpi(x.lo), __tg_tanpi(x.hi)); 4251 } 4252 #endif 4253 4254 #endif /* SIMD_LIBRARY_VERSION */ 4255 #pragma mark - acosh implementation 4256 static inline SIMD_CFUNC simd_float2 __tg_acosh(simd_float2 x) { 4257 return simd_make_float2(__tg_acosh(simd_make_float4(x))); 4258 } 4259 4260 static inline SIMD_CFUNC simd_float3 __tg_acosh(simd_float3 x) { 4261 return simd_make_float3(__tg_acosh(simd_make_float4(x))); 4262 } 4263 4264 #if SIMD_LIBRARY_VERSION >= 3 4265 extern simd_float4 _simd_acosh_f4(simd_float4 x); 4266 static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x) { 4267 return _simd_acosh_f4(x); 4268 } 4269 #else 4270 static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x) { 4271 return simd_make_float4(acosh(x.x), acosh(x.y), acosh(x.z), acosh(x.w)); 4272 } 4273 #endif 4274 4275 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4276 extern simd_float8 _simd_acosh_f8(simd_float8 x); 4277 static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) { 4278 return _simd_acosh_f8(x); 4279 } 4280 #else 4281 static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) { 4282 return simd_make_float8(__tg_acosh(x.lo), __tg_acosh(x.hi)); 4283 } 4284 #endif 4285 4286 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4287 extern simd_float16 _simd_acosh_f16(simd_float16 x); 4288 static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x) { 4289 return _simd_acosh_f16(x); 4290 } 4291 #else 4292 static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x) { 4293 return simd_make_float16(__tg_acosh(x.lo), __tg_acosh(x.hi)); 4294 } 4295 #endif 4296 4297 #if SIMD_LIBRARY_VERSION >= 3 4298 extern simd_double2 _simd_acosh_d2(simd_double2 x); 4299 static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x) { 4300 return _simd_acosh_d2(x); 4301 } 4302 #else 4303 static inline SIMD_CFUNC simd_double2 __tg_acosh(simd_double2 x) { 4304 return simd_make_double2(acosh(x.x), acosh(x.y)); 4305 } 4306 #endif 4307 4308 static inline SIMD_CFUNC simd_double3 __tg_acosh(simd_double3 x) { 4309 return simd_make_double3(__tg_acosh(simd_make_double4(x))); 4310 } 4311 4312 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4313 extern simd_double4 _simd_acosh_d4(simd_double4 x); 4314 static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) { 4315 return _simd_acosh_d4(x); 4316 } 4317 #else 4318 static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) { 4319 return simd_make_double4(__tg_acosh(x.lo), __tg_acosh(x.hi)); 4320 } 4321 #endif 4322 4323 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4324 extern simd_double8 _simd_acosh_d8(simd_double8 x); 4325 static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x) { 4326 return _simd_acosh_d8(x); 4327 } 4328 #else 4329 static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x) { 4330 return simd_make_double8(__tg_acosh(x.lo), __tg_acosh(x.hi)); 4331 } 4332 #endif 4333 4334 #pragma mark - asinh implementation 4335 static inline SIMD_CFUNC simd_float2 __tg_asinh(simd_float2 x) { 4336 return simd_make_float2(__tg_asinh(simd_make_float4(x))); 4337 } 4338 4339 static inline SIMD_CFUNC simd_float3 __tg_asinh(simd_float3 x) { 4340 return simd_make_float3(__tg_asinh(simd_make_float4(x))); 4341 } 4342 4343 #if SIMD_LIBRARY_VERSION >= 3 4344 extern simd_float4 _simd_asinh_f4(simd_float4 x); 4345 static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x) { 4346 return _simd_asinh_f4(x); 4347 } 4348 #else 4349 static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x) { 4350 return simd_make_float4(asinh(x.x), asinh(x.y), asinh(x.z), asinh(x.w)); 4351 } 4352 #endif 4353 4354 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4355 extern simd_float8 _simd_asinh_f8(simd_float8 x); 4356 static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) { 4357 return _simd_asinh_f8(x); 4358 } 4359 #else 4360 static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) { 4361 return simd_make_float8(__tg_asinh(x.lo), __tg_asinh(x.hi)); 4362 } 4363 #endif 4364 4365 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4366 extern simd_float16 _simd_asinh_f16(simd_float16 x); 4367 static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x) { 4368 return _simd_asinh_f16(x); 4369 } 4370 #else 4371 static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x) { 4372 return simd_make_float16(__tg_asinh(x.lo), __tg_asinh(x.hi)); 4373 } 4374 #endif 4375 4376 #if SIMD_LIBRARY_VERSION >= 3 4377 extern simd_double2 _simd_asinh_d2(simd_double2 x); 4378 static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x) { 4379 return _simd_asinh_d2(x); 4380 } 4381 #else 4382 static inline SIMD_CFUNC simd_double2 __tg_asinh(simd_double2 x) { 4383 return simd_make_double2(asinh(x.x), asinh(x.y)); 4384 } 4385 #endif 4386 4387 static inline SIMD_CFUNC simd_double3 __tg_asinh(simd_double3 x) { 4388 return simd_make_double3(__tg_asinh(simd_make_double4(x))); 4389 } 4390 4391 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4392 extern simd_double4 _simd_asinh_d4(simd_double4 x); 4393 static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) { 4394 return _simd_asinh_d4(x); 4395 } 4396 #else 4397 static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) { 4398 return simd_make_double4(__tg_asinh(x.lo), __tg_asinh(x.hi)); 4399 } 4400 #endif 4401 4402 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4403 extern simd_double8 _simd_asinh_d8(simd_double8 x); 4404 static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x) { 4405 return _simd_asinh_d8(x); 4406 } 4407 #else 4408 static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x) { 4409 return simd_make_double8(__tg_asinh(x.lo), __tg_asinh(x.hi)); 4410 } 4411 #endif 4412 4413 #pragma mark - atanh implementation 4414 static inline SIMD_CFUNC simd_float2 __tg_atanh(simd_float2 x) { 4415 return simd_make_float2(__tg_atanh(simd_make_float4(x))); 4416 } 4417 4418 static inline SIMD_CFUNC simd_float3 __tg_atanh(simd_float3 x) { 4419 return simd_make_float3(__tg_atanh(simd_make_float4(x))); 4420 } 4421 4422 #if SIMD_LIBRARY_VERSION >= 3 4423 extern simd_float4 _simd_atanh_f4(simd_float4 x); 4424 static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x) { 4425 return _simd_atanh_f4(x); 4426 } 4427 #else 4428 static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x) { 4429 return simd_make_float4(atanh(x.x), atanh(x.y), atanh(x.z), atanh(x.w)); 4430 } 4431 #endif 4432 4433 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4434 extern simd_float8 _simd_atanh_f8(simd_float8 x); 4435 static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) { 4436 return _simd_atanh_f8(x); 4437 } 4438 #else 4439 static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) { 4440 return simd_make_float8(__tg_atanh(x.lo), __tg_atanh(x.hi)); 4441 } 4442 #endif 4443 4444 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4445 extern simd_float16 _simd_atanh_f16(simd_float16 x); 4446 static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x) { 4447 return _simd_atanh_f16(x); 4448 } 4449 #else 4450 static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x) { 4451 return simd_make_float16(__tg_atanh(x.lo), __tg_atanh(x.hi)); 4452 } 4453 #endif 4454 4455 #if SIMD_LIBRARY_VERSION >= 3 4456 extern simd_double2 _simd_atanh_d2(simd_double2 x); 4457 static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x) { 4458 return _simd_atanh_d2(x); 4459 } 4460 #else 4461 static inline SIMD_CFUNC simd_double2 __tg_atanh(simd_double2 x) { 4462 return simd_make_double2(atanh(x.x), atanh(x.y)); 4463 } 4464 #endif 4465 4466 static inline SIMD_CFUNC simd_double3 __tg_atanh(simd_double3 x) { 4467 return simd_make_double3(__tg_atanh(simd_make_double4(x))); 4468 } 4469 4470 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4471 extern simd_double4 _simd_atanh_d4(simd_double4 x); 4472 static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) { 4473 return _simd_atanh_d4(x); 4474 } 4475 #else 4476 static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) { 4477 return simd_make_double4(__tg_atanh(x.lo), __tg_atanh(x.hi)); 4478 } 4479 #endif 4480 4481 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4482 extern simd_double8 _simd_atanh_d8(simd_double8 x); 4483 static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x) { 4484 return _simd_atanh_d8(x); 4485 } 4486 #else 4487 static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x) { 4488 return simd_make_double8(__tg_atanh(x.lo), __tg_atanh(x.hi)); 4489 } 4490 #endif 4491 4492 #pragma mark - cosh implementation 4493 static inline SIMD_CFUNC simd_float2 __tg_cosh(simd_float2 x) { 4494 return simd_make_float2(__tg_cosh(simd_make_float4(x))); 4495 } 4496 4497 static inline SIMD_CFUNC simd_float3 __tg_cosh(simd_float3 x) { 4498 return simd_make_float3(__tg_cosh(simd_make_float4(x))); 4499 } 4500 4501 #if SIMD_LIBRARY_VERSION >= 3 4502 extern simd_float4 _simd_cosh_f4(simd_float4 x); 4503 static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x) { 4504 return _simd_cosh_f4(x); 4505 } 4506 #else 4507 static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x) { 4508 return simd_make_float4(cosh(x.x), cosh(x.y), cosh(x.z), cosh(x.w)); 4509 } 4510 #endif 4511 4512 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4513 extern simd_float8 _simd_cosh_f8(simd_float8 x); 4514 static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) { 4515 return _simd_cosh_f8(x); 4516 } 4517 #else 4518 static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) { 4519 return simd_make_float8(__tg_cosh(x.lo), __tg_cosh(x.hi)); 4520 } 4521 #endif 4522 4523 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4524 extern simd_float16 _simd_cosh_f16(simd_float16 x); 4525 static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x) { 4526 return _simd_cosh_f16(x); 4527 } 4528 #else 4529 static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x) { 4530 return simd_make_float16(__tg_cosh(x.lo), __tg_cosh(x.hi)); 4531 } 4532 #endif 4533 4534 #if SIMD_LIBRARY_VERSION >= 3 4535 extern simd_double2 _simd_cosh_d2(simd_double2 x); 4536 static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x) { 4537 return _simd_cosh_d2(x); 4538 } 4539 #else 4540 static inline SIMD_CFUNC simd_double2 __tg_cosh(simd_double2 x) { 4541 return simd_make_double2(cosh(x.x), cosh(x.y)); 4542 } 4543 #endif 4544 4545 static inline SIMD_CFUNC simd_double3 __tg_cosh(simd_double3 x) { 4546 return simd_make_double3(__tg_cosh(simd_make_double4(x))); 4547 } 4548 4549 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4550 extern simd_double4 _simd_cosh_d4(simd_double4 x); 4551 static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) { 4552 return _simd_cosh_d4(x); 4553 } 4554 #else 4555 static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) { 4556 return simd_make_double4(__tg_cosh(x.lo), __tg_cosh(x.hi)); 4557 } 4558 #endif 4559 4560 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4561 extern simd_double8 _simd_cosh_d8(simd_double8 x); 4562 static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x) { 4563 return _simd_cosh_d8(x); 4564 } 4565 #else 4566 static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x) { 4567 return simd_make_double8(__tg_cosh(x.lo), __tg_cosh(x.hi)); 4568 } 4569 #endif 4570 4571 #pragma mark - sinh implementation 4572 static inline SIMD_CFUNC simd_float2 __tg_sinh(simd_float2 x) { 4573 return simd_make_float2(__tg_sinh(simd_make_float4(x))); 4574 } 4575 4576 static inline SIMD_CFUNC simd_float3 __tg_sinh(simd_float3 x) { 4577 return simd_make_float3(__tg_sinh(simd_make_float4(x))); 4578 } 4579 4580 #if SIMD_LIBRARY_VERSION >= 3 4581 extern simd_float4 _simd_sinh_f4(simd_float4 x); 4582 static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x) { 4583 return _simd_sinh_f4(x); 4584 } 4585 #else 4586 static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x) { 4587 return simd_make_float4(sinh(x.x), sinh(x.y), sinh(x.z), sinh(x.w)); 4588 } 4589 #endif 4590 4591 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4592 extern simd_float8 _simd_sinh_f8(simd_float8 x); 4593 static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) { 4594 return _simd_sinh_f8(x); 4595 } 4596 #else 4597 static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) { 4598 return simd_make_float8(__tg_sinh(x.lo), __tg_sinh(x.hi)); 4599 } 4600 #endif 4601 4602 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4603 extern simd_float16 _simd_sinh_f16(simd_float16 x); 4604 static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x) { 4605 return _simd_sinh_f16(x); 4606 } 4607 #else 4608 static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x) { 4609 return simd_make_float16(__tg_sinh(x.lo), __tg_sinh(x.hi)); 4610 } 4611 #endif 4612 4613 #if SIMD_LIBRARY_VERSION >= 3 4614 extern simd_double2 _simd_sinh_d2(simd_double2 x); 4615 static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x) { 4616 return _simd_sinh_d2(x); 4617 } 4618 #else 4619 static inline SIMD_CFUNC simd_double2 __tg_sinh(simd_double2 x) { 4620 return simd_make_double2(sinh(x.x), sinh(x.y)); 4621 } 4622 #endif 4623 4624 static inline SIMD_CFUNC simd_double3 __tg_sinh(simd_double3 x) { 4625 return simd_make_double3(__tg_sinh(simd_make_double4(x))); 4626 } 4627 4628 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4629 extern simd_double4 _simd_sinh_d4(simd_double4 x); 4630 static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) { 4631 return _simd_sinh_d4(x); 4632 } 4633 #else 4634 static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) { 4635 return simd_make_double4(__tg_sinh(x.lo), __tg_sinh(x.hi)); 4636 } 4637 #endif 4638 4639 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4640 extern simd_double8 _simd_sinh_d8(simd_double8 x); 4641 static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x) { 4642 return _simd_sinh_d8(x); 4643 } 4644 #else 4645 static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x) { 4646 return simd_make_double8(__tg_sinh(x.lo), __tg_sinh(x.hi)); 4647 } 4648 #endif 4649 4650 #pragma mark - tanh implementation 4651 static inline SIMD_CFUNC simd_float2 __tg_tanh(simd_float2 x) { 4652 return simd_make_float2(__tg_tanh(simd_make_float4(x))); 4653 } 4654 4655 static inline SIMD_CFUNC simd_float3 __tg_tanh(simd_float3 x) { 4656 return simd_make_float3(__tg_tanh(simd_make_float4(x))); 4657 } 4658 4659 #if SIMD_LIBRARY_VERSION >= 3 4660 extern simd_float4 _simd_tanh_f4(simd_float4 x); 4661 static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x) { 4662 return _simd_tanh_f4(x); 4663 } 4664 #else 4665 static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x) { 4666 return simd_make_float4(tanh(x.x), tanh(x.y), tanh(x.z), tanh(x.w)); 4667 } 4668 #endif 4669 4670 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4671 extern simd_float8 _simd_tanh_f8(simd_float8 x); 4672 static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) { 4673 return _simd_tanh_f8(x); 4674 } 4675 #else 4676 static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) { 4677 return simd_make_float8(__tg_tanh(x.lo), __tg_tanh(x.hi)); 4678 } 4679 #endif 4680 4681 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4682 extern simd_float16 _simd_tanh_f16(simd_float16 x); 4683 static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x) { 4684 return _simd_tanh_f16(x); 4685 } 4686 #else 4687 static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x) { 4688 return simd_make_float16(__tg_tanh(x.lo), __tg_tanh(x.hi)); 4689 } 4690 #endif 4691 4692 #if SIMD_LIBRARY_VERSION >= 3 4693 extern simd_double2 _simd_tanh_d2(simd_double2 x); 4694 static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x) { 4695 return _simd_tanh_d2(x); 4696 } 4697 #else 4698 static inline SIMD_CFUNC simd_double2 __tg_tanh(simd_double2 x) { 4699 return simd_make_double2(tanh(x.x), tanh(x.y)); 4700 } 4701 #endif 4702 4703 static inline SIMD_CFUNC simd_double3 __tg_tanh(simd_double3 x) { 4704 return simd_make_double3(__tg_tanh(simd_make_double4(x))); 4705 } 4706 4707 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4708 extern simd_double4 _simd_tanh_d4(simd_double4 x); 4709 static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) { 4710 return _simd_tanh_d4(x); 4711 } 4712 #else 4713 static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) { 4714 return simd_make_double4(__tg_tanh(x.lo), __tg_tanh(x.hi)); 4715 } 4716 #endif 4717 4718 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4719 extern simd_double8 _simd_tanh_d8(simd_double8 x); 4720 static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x) { 4721 return _simd_tanh_d8(x); 4722 } 4723 #else 4724 static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x) { 4725 return simd_make_double8(__tg_tanh(x.lo), __tg_tanh(x.hi)); 4726 } 4727 #endif 4728 4729 #pragma mark - exp implementation 4730 static inline SIMD_CFUNC simd_float2 __tg_exp(simd_float2 x) { 4731 return simd_make_float2(__tg_exp(simd_make_float4(x))); 4732 } 4733 4734 static inline SIMD_CFUNC simd_float3 __tg_exp(simd_float3 x) { 4735 return simd_make_float3(__tg_exp(simd_make_float4(x))); 4736 } 4737 4738 #if SIMD_LIBRARY_VERSION >= 3 4739 extern simd_float4 _simd_exp_f4(simd_float4 x); 4740 static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x) { 4741 return _simd_exp_f4(x); 4742 } 4743 #else 4744 static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x) { 4745 return simd_make_float4(exp(x.x), exp(x.y), exp(x.z), exp(x.w)); 4746 } 4747 #endif 4748 4749 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4750 extern simd_float8 _simd_exp_f8(simd_float8 x); 4751 static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) { 4752 return _simd_exp_f8(x); 4753 } 4754 #else 4755 static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) { 4756 return simd_make_float8(__tg_exp(x.lo), __tg_exp(x.hi)); 4757 } 4758 #endif 4759 4760 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4761 extern simd_float16 _simd_exp_f16(simd_float16 x); 4762 static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x) { 4763 return _simd_exp_f16(x); 4764 } 4765 #else 4766 static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x) { 4767 return simd_make_float16(__tg_exp(x.lo), __tg_exp(x.hi)); 4768 } 4769 #endif 4770 4771 #if SIMD_LIBRARY_VERSION >= 3 4772 extern simd_double2 _simd_exp_d2(simd_double2 x); 4773 static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x) { 4774 return _simd_exp_d2(x); 4775 } 4776 #else 4777 static inline SIMD_CFUNC simd_double2 __tg_exp(simd_double2 x) { 4778 return simd_make_double2(exp(x.x), exp(x.y)); 4779 } 4780 #endif 4781 4782 static inline SIMD_CFUNC simd_double3 __tg_exp(simd_double3 x) { 4783 return simd_make_double3(__tg_exp(simd_make_double4(x))); 4784 } 4785 4786 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4787 extern simd_double4 _simd_exp_d4(simd_double4 x); 4788 static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) { 4789 return _simd_exp_d4(x); 4790 } 4791 #else 4792 static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) { 4793 return simd_make_double4(__tg_exp(x.lo), __tg_exp(x.hi)); 4794 } 4795 #endif 4796 4797 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4798 extern simd_double8 _simd_exp_d8(simd_double8 x); 4799 static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x) { 4800 return _simd_exp_d8(x); 4801 } 4802 #else 4803 static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x) { 4804 return simd_make_double8(__tg_exp(x.lo), __tg_exp(x.hi)); 4805 } 4806 #endif 4807 4808 #pragma mark - exp2 implementation 4809 static inline SIMD_CFUNC simd_float2 __tg_exp2(simd_float2 x) { 4810 return simd_make_float2(__tg_exp2(simd_make_float4(x))); 4811 } 4812 4813 static inline SIMD_CFUNC simd_float3 __tg_exp2(simd_float3 x) { 4814 return simd_make_float3(__tg_exp2(simd_make_float4(x))); 4815 } 4816 4817 #if SIMD_LIBRARY_VERSION >= 3 4818 extern simd_float4 _simd_exp2_f4(simd_float4 x); 4819 static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x) { 4820 return _simd_exp2_f4(x); 4821 } 4822 #else 4823 static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x) { 4824 return simd_make_float4(exp2(x.x), exp2(x.y), exp2(x.z), exp2(x.w)); 4825 } 4826 #endif 4827 4828 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4829 extern simd_float8 _simd_exp2_f8(simd_float8 x); 4830 static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) { 4831 return _simd_exp2_f8(x); 4832 } 4833 #else 4834 static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) { 4835 return simd_make_float8(__tg_exp2(x.lo), __tg_exp2(x.hi)); 4836 } 4837 #endif 4838 4839 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4840 extern simd_float16 _simd_exp2_f16(simd_float16 x); 4841 static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x) { 4842 return _simd_exp2_f16(x); 4843 } 4844 #else 4845 static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x) { 4846 return simd_make_float16(__tg_exp2(x.lo), __tg_exp2(x.hi)); 4847 } 4848 #endif 4849 4850 #if SIMD_LIBRARY_VERSION >= 3 4851 extern simd_double2 _simd_exp2_d2(simd_double2 x); 4852 static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x) { 4853 return _simd_exp2_d2(x); 4854 } 4855 #else 4856 static inline SIMD_CFUNC simd_double2 __tg_exp2(simd_double2 x) { 4857 return simd_make_double2(exp2(x.x), exp2(x.y)); 4858 } 4859 #endif 4860 4861 static inline SIMD_CFUNC simd_double3 __tg_exp2(simd_double3 x) { 4862 return simd_make_double3(__tg_exp2(simd_make_double4(x))); 4863 } 4864 4865 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4866 extern simd_double4 _simd_exp2_d4(simd_double4 x); 4867 static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) { 4868 return _simd_exp2_d4(x); 4869 } 4870 #else 4871 static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) { 4872 return simd_make_double4(__tg_exp2(x.lo), __tg_exp2(x.hi)); 4873 } 4874 #endif 4875 4876 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4877 extern simd_double8 _simd_exp2_d8(simd_double8 x); 4878 static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x) { 4879 return _simd_exp2_d8(x); 4880 } 4881 #else 4882 static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x) { 4883 return simd_make_double8(__tg_exp2(x.lo), __tg_exp2(x.hi)); 4884 } 4885 #endif 4886 4887 #pragma mark - exp10 implementation 4888 #if SIMD_LIBRARY_VERSION >= 1 4889 static inline SIMD_CFUNC simd_float2 __tg_exp10(simd_float2 x) { 4890 return simd_make_float2(__tg_exp10(simd_make_float4(x))); 4891 } 4892 4893 static inline SIMD_CFUNC simd_float3 __tg_exp10(simd_float3 x) { 4894 return simd_make_float3(__tg_exp10(simd_make_float4(x))); 4895 } 4896 4897 #if SIMD_LIBRARY_VERSION >= 3 4898 extern simd_float4 _simd_exp10_f4(simd_float4 x); 4899 static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x) { 4900 return _simd_exp10_f4(x); 4901 } 4902 #else 4903 static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x) { 4904 return simd_make_float4(__exp10(x.x), __exp10(x.y), __exp10(x.z), __exp10(x.w)); 4905 } 4906 #endif 4907 4908 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4909 extern simd_float8 _simd_exp10_f8(simd_float8 x); 4910 static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) { 4911 return _simd_exp10_f8(x); 4912 } 4913 #else 4914 static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) { 4915 return simd_make_float8(__tg_exp10(x.lo), __tg_exp10(x.hi)); 4916 } 4917 #endif 4918 4919 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4920 extern simd_float16 _simd_exp10_f16(simd_float16 x); 4921 static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x) { 4922 return _simd_exp10_f16(x); 4923 } 4924 #else 4925 static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x) { 4926 return simd_make_float16(__tg_exp10(x.lo), __tg_exp10(x.hi)); 4927 } 4928 #endif 4929 4930 #if SIMD_LIBRARY_VERSION >= 3 4931 extern simd_double2 _simd_exp10_d2(simd_double2 x); 4932 static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x) { 4933 return _simd_exp10_d2(x); 4934 } 4935 #else 4936 static inline SIMD_CFUNC simd_double2 __tg_exp10(simd_double2 x) { 4937 return simd_make_double2(__exp10(x.x), __exp10(x.y)); 4938 } 4939 #endif 4940 4941 static inline SIMD_CFUNC simd_double3 __tg_exp10(simd_double3 x) { 4942 return simd_make_double3(__tg_exp10(simd_make_double4(x))); 4943 } 4944 4945 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4946 extern simd_double4 _simd_exp10_d4(simd_double4 x); 4947 static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) { 4948 return _simd_exp10_d4(x); 4949 } 4950 #else 4951 static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) { 4952 return simd_make_double4(__tg_exp10(x.lo), __tg_exp10(x.hi)); 4953 } 4954 #endif 4955 4956 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 4957 extern simd_double8 _simd_exp10_d8(simd_double8 x); 4958 static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x) { 4959 return _simd_exp10_d8(x); 4960 } 4961 #else 4962 static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x) { 4963 return simd_make_double8(__tg_exp10(x.lo), __tg_exp10(x.hi)); 4964 } 4965 #endif 4966 4967 #endif /* SIMD_LIBRARY_VERSION */ 4968 #pragma mark - expm1 implementation 4969 static inline SIMD_CFUNC simd_float2 __tg_expm1(simd_float2 x) { 4970 return simd_make_float2(__tg_expm1(simd_make_float4(x))); 4971 } 4972 4973 static inline SIMD_CFUNC simd_float3 __tg_expm1(simd_float3 x) { 4974 return simd_make_float3(__tg_expm1(simd_make_float4(x))); 4975 } 4976 4977 #if SIMD_LIBRARY_VERSION >= 3 4978 extern simd_float4 _simd_expm1_f4(simd_float4 x); 4979 static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x) { 4980 return _simd_expm1_f4(x); 4981 } 4982 #else 4983 static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x) { 4984 return simd_make_float4(expm1(x.x), expm1(x.y), expm1(x.z), expm1(x.w)); 4985 } 4986 #endif 4987 4988 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 4989 extern simd_float8 _simd_expm1_f8(simd_float8 x); 4990 static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) { 4991 return _simd_expm1_f8(x); 4992 } 4993 #else 4994 static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) { 4995 return simd_make_float8(__tg_expm1(x.lo), __tg_expm1(x.hi)); 4996 } 4997 #endif 4998 4999 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5000 extern simd_float16 _simd_expm1_f16(simd_float16 x); 5001 static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x) { 5002 return _simd_expm1_f16(x); 5003 } 5004 #else 5005 static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x) { 5006 return simd_make_float16(__tg_expm1(x.lo), __tg_expm1(x.hi)); 5007 } 5008 #endif 5009 5010 #if SIMD_LIBRARY_VERSION >= 3 5011 extern simd_double2 _simd_expm1_d2(simd_double2 x); 5012 static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x) { 5013 return _simd_expm1_d2(x); 5014 } 5015 #else 5016 static inline SIMD_CFUNC simd_double2 __tg_expm1(simd_double2 x) { 5017 return simd_make_double2(expm1(x.x), expm1(x.y)); 5018 } 5019 #endif 5020 5021 static inline SIMD_CFUNC simd_double3 __tg_expm1(simd_double3 x) { 5022 return simd_make_double3(__tg_expm1(simd_make_double4(x))); 5023 } 5024 5025 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5026 extern simd_double4 _simd_expm1_d4(simd_double4 x); 5027 static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) { 5028 return _simd_expm1_d4(x); 5029 } 5030 #else 5031 static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) { 5032 return simd_make_double4(__tg_expm1(x.lo), __tg_expm1(x.hi)); 5033 } 5034 #endif 5035 5036 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5037 extern simd_double8 _simd_expm1_d8(simd_double8 x); 5038 static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x) { 5039 return _simd_expm1_d8(x); 5040 } 5041 #else 5042 static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x) { 5043 return simd_make_double8(__tg_expm1(x.lo), __tg_expm1(x.hi)); 5044 } 5045 #endif 5046 5047 #pragma mark - log implementation 5048 static inline SIMD_CFUNC simd_float2 __tg_log(simd_float2 x) { 5049 return simd_make_float2(__tg_log(simd_make_float4(x))); 5050 } 5051 5052 static inline SIMD_CFUNC simd_float3 __tg_log(simd_float3 x) { 5053 return simd_make_float3(__tg_log(simd_make_float4(x))); 5054 } 5055 5056 #if SIMD_LIBRARY_VERSION >= 3 5057 extern simd_float4 _simd_log_f4(simd_float4 x); 5058 static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x) { 5059 return _simd_log_f4(x); 5060 } 5061 #else 5062 static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x) { 5063 return simd_make_float4(log(x.x), log(x.y), log(x.z), log(x.w)); 5064 } 5065 #endif 5066 5067 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5068 extern simd_float8 _simd_log_f8(simd_float8 x); 5069 static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) { 5070 return _simd_log_f8(x); 5071 } 5072 #else 5073 static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) { 5074 return simd_make_float8(__tg_log(x.lo), __tg_log(x.hi)); 5075 } 5076 #endif 5077 5078 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5079 extern simd_float16 _simd_log_f16(simd_float16 x); 5080 static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x) { 5081 return _simd_log_f16(x); 5082 } 5083 #else 5084 static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x) { 5085 return simd_make_float16(__tg_log(x.lo), __tg_log(x.hi)); 5086 } 5087 #endif 5088 5089 #if SIMD_LIBRARY_VERSION >= 3 5090 extern simd_double2 _simd_log_d2(simd_double2 x); 5091 static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x) { 5092 return _simd_log_d2(x); 5093 } 5094 #else 5095 static inline SIMD_CFUNC simd_double2 __tg_log(simd_double2 x) { 5096 return simd_make_double2(log(x.x), log(x.y)); 5097 } 5098 #endif 5099 5100 static inline SIMD_CFUNC simd_double3 __tg_log(simd_double3 x) { 5101 return simd_make_double3(__tg_log(simd_make_double4(x))); 5102 } 5103 5104 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5105 extern simd_double4 _simd_log_d4(simd_double4 x); 5106 static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) { 5107 return _simd_log_d4(x); 5108 } 5109 #else 5110 static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) { 5111 return simd_make_double4(__tg_log(x.lo), __tg_log(x.hi)); 5112 } 5113 #endif 5114 5115 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5116 extern simd_double8 _simd_log_d8(simd_double8 x); 5117 static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x) { 5118 return _simd_log_d8(x); 5119 } 5120 #else 5121 static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x) { 5122 return simd_make_double8(__tg_log(x.lo), __tg_log(x.hi)); 5123 } 5124 #endif 5125 5126 #pragma mark - log2 implementation 5127 static inline SIMD_CFUNC simd_float2 __tg_log2(simd_float2 x) { 5128 return simd_make_float2(__tg_log2(simd_make_float4(x))); 5129 } 5130 5131 static inline SIMD_CFUNC simd_float3 __tg_log2(simd_float3 x) { 5132 return simd_make_float3(__tg_log2(simd_make_float4(x))); 5133 } 5134 5135 #if SIMD_LIBRARY_VERSION >= 3 5136 extern simd_float4 _simd_log2_f4(simd_float4 x); 5137 static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x) { 5138 return _simd_log2_f4(x); 5139 } 5140 #else 5141 static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x) { 5142 return simd_make_float4(log2(x.x), log2(x.y), log2(x.z), log2(x.w)); 5143 } 5144 #endif 5145 5146 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5147 extern simd_float8 _simd_log2_f8(simd_float8 x); 5148 static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) { 5149 return _simd_log2_f8(x); 5150 } 5151 #else 5152 static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) { 5153 return simd_make_float8(__tg_log2(x.lo), __tg_log2(x.hi)); 5154 } 5155 #endif 5156 5157 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5158 extern simd_float16 _simd_log2_f16(simd_float16 x); 5159 static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x) { 5160 return _simd_log2_f16(x); 5161 } 5162 #else 5163 static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x) { 5164 return simd_make_float16(__tg_log2(x.lo), __tg_log2(x.hi)); 5165 } 5166 #endif 5167 5168 #if SIMD_LIBRARY_VERSION >= 3 5169 extern simd_double2 _simd_log2_d2(simd_double2 x); 5170 static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x) { 5171 return _simd_log2_d2(x); 5172 } 5173 #else 5174 static inline SIMD_CFUNC simd_double2 __tg_log2(simd_double2 x) { 5175 return simd_make_double2(log2(x.x), log2(x.y)); 5176 } 5177 #endif 5178 5179 static inline SIMD_CFUNC simd_double3 __tg_log2(simd_double3 x) { 5180 return simd_make_double3(__tg_log2(simd_make_double4(x))); 5181 } 5182 5183 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5184 extern simd_double4 _simd_log2_d4(simd_double4 x); 5185 static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) { 5186 return _simd_log2_d4(x); 5187 } 5188 #else 5189 static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) { 5190 return simd_make_double4(__tg_log2(x.lo), __tg_log2(x.hi)); 5191 } 5192 #endif 5193 5194 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5195 extern simd_double8 _simd_log2_d8(simd_double8 x); 5196 static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x) { 5197 return _simd_log2_d8(x); 5198 } 5199 #else 5200 static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x) { 5201 return simd_make_double8(__tg_log2(x.lo), __tg_log2(x.hi)); 5202 } 5203 #endif 5204 5205 #pragma mark - log10 implementation 5206 static inline SIMD_CFUNC simd_float2 __tg_log10(simd_float2 x) { 5207 return simd_make_float2(__tg_log10(simd_make_float4(x))); 5208 } 5209 5210 static inline SIMD_CFUNC simd_float3 __tg_log10(simd_float3 x) { 5211 return simd_make_float3(__tg_log10(simd_make_float4(x))); 5212 } 5213 5214 #if SIMD_LIBRARY_VERSION >= 3 5215 extern simd_float4 _simd_log10_f4(simd_float4 x); 5216 static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x) { 5217 return _simd_log10_f4(x); 5218 } 5219 #else 5220 static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x) { 5221 return simd_make_float4(log10(x.x), log10(x.y), log10(x.z), log10(x.w)); 5222 } 5223 #endif 5224 5225 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5226 extern simd_float8 _simd_log10_f8(simd_float8 x); 5227 static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) { 5228 return _simd_log10_f8(x); 5229 } 5230 #else 5231 static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) { 5232 return simd_make_float8(__tg_log10(x.lo), __tg_log10(x.hi)); 5233 } 5234 #endif 5235 5236 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5237 extern simd_float16 _simd_log10_f16(simd_float16 x); 5238 static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x) { 5239 return _simd_log10_f16(x); 5240 } 5241 #else 5242 static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x) { 5243 return simd_make_float16(__tg_log10(x.lo), __tg_log10(x.hi)); 5244 } 5245 #endif 5246 5247 #if SIMD_LIBRARY_VERSION >= 3 5248 extern simd_double2 _simd_log10_d2(simd_double2 x); 5249 static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x) { 5250 return _simd_log10_d2(x); 5251 } 5252 #else 5253 static inline SIMD_CFUNC simd_double2 __tg_log10(simd_double2 x) { 5254 return simd_make_double2(log10(x.x), log10(x.y)); 5255 } 5256 #endif 5257 5258 static inline SIMD_CFUNC simd_double3 __tg_log10(simd_double3 x) { 5259 return simd_make_double3(__tg_log10(simd_make_double4(x))); 5260 } 5261 5262 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5263 extern simd_double4 _simd_log10_d4(simd_double4 x); 5264 static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) { 5265 return _simd_log10_d4(x); 5266 } 5267 #else 5268 static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) { 5269 return simd_make_double4(__tg_log10(x.lo), __tg_log10(x.hi)); 5270 } 5271 #endif 5272 5273 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5274 extern simd_double8 _simd_log10_d8(simd_double8 x); 5275 static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x) { 5276 return _simd_log10_d8(x); 5277 } 5278 #else 5279 static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x) { 5280 return simd_make_double8(__tg_log10(x.lo), __tg_log10(x.hi)); 5281 } 5282 #endif 5283 5284 #pragma mark - log1p implementation 5285 static inline SIMD_CFUNC simd_float2 __tg_log1p(simd_float2 x) { 5286 return simd_make_float2(__tg_log1p(simd_make_float4(x))); 5287 } 5288 5289 static inline SIMD_CFUNC simd_float3 __tg_log1p(simd_float3 x) { 5290 return simd_make_float3(__tg_log1p(simd_make_float4(x))); 5291 } 5292 5293 #if SIMD_LIBRARY_VERSION >= 3 5294 extern simd_float4 _simd_log1p_f4(simd_float4 x); 5295 static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x) { 5296 return _simd_log1p_f4(x); 5297 } 5298 #else 5299 static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x) { 5300 return simd_make_float4(log1p(x.x), log1p(x.y), log1p(x.z), log1p(x.w)); 5301 } 5302 #endif 5303 5304 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5305 extern simd_float8 _simd_log1p_f8(simd_float8 x); 5306 static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) { 5307 return _simd_log1p_f8(x); 5308 } 5309 #else 5310 static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) { 5311 return simd_make_float8(__tg_log1p(x.lo), __tg_log1p(x.hi)); 5312 } 5313 #endif 5314 5315 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5316 extern simd_float16 _simd_log1p_f16(simd_float16 x); 5317 static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x) { 5318 return _simd_log1p_f16(x); 5319 } 5320 #else 5321 static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x) { 5322 return simd_make_float16(__tg_log1p(x.lo), __tg_log1p(x.hi)); 5323 } 5324 #endif 5325 5326 #if SIMD_LIBRARY_VERSION >= 3 5327 extern simd_double2 _simd_log1p_d2(simd_double2 x); 5328 static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x) { 5329 return _simd_log1p_d2(x); 5330 } 5331 #else 5332 static inline SIMD_CFUNC simd_double2 __tg_log1p(simd_double2 x) { 5333 return simd_make_double2(log1p(x.x), log1p(x.y)); 5334 } 5335 #endif 5336 5337 static inline SIMD_CFUNC simd_double3 __tg_log1p(simd_double3 x) { 5338 return simd_make_double3(__tg_log1p(simd_make_double4(x))); 5339 } 5340 5341 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5342 extern simd_double4 _simd_log1p_d4(simd_double4 x); 5343 static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) { 5344 return _simd_log1p_d4(x); 5345 } 5346 #else 5347 static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) { 5348 return simd_make_double4(__tg_log1p(x.lo), __tg_log1p(x.hi)); 5349 } 5350 #endif 5351 5352 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5353 extern simd_double8 _simd_log1p_d8(simd_double8 x); 5354 static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x) { 5355 return _simd_log1p_d8(x); 5356 } 5357 #else 5358 static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x) { 5359 return simd_make_double8(__tg_log1p(x.lo), __tg_log1p(x.hi)); 5360 } 5361 #endif 5362 5363 #pragma mark - cbrt implementation 5364 static inline SIMD_CFUNC simd_float2 __tg_cbrt(simd_float2 x) { 5365 return simd_make_float2(__tg_cbrt(simd_make_float4(x))); 5366 } 5367 5368 static inline SIMD_CFUNC simd_float3 __tg_cbrt(simd_float3 x) { 5369 return simd_make_float3(__tg_cbrt(simd_make_float4(x))); 5370 } 5371 5372 #if SIMD_LIBRARY_VERSION >= 3 5373 extern simd_float4 _simd_cbrt_f4(simd_float4 x); 5374 static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x) { 5375 return _simd_cbrt_f4(x); 5376 } 5377 #else 5378 static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x) { 5379 return simd_make_float4(cbrt(x.x), cbrt(x.y), cbrt(x.z), cbrt(x.w)); 5380 } 5381 #endif 5382 5383 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5384 extern simd_float8 _simd_cbrt_f8(simd_float8 x); 5385 static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) { 5386 return _simd_cbrt_f8(x); 5387 } 5388 #else 5389 static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) { 5390 return simd_make_float8(__tg_cbrt(x.lo), __tg_cbrt(x.hi)); 5391 } 5392 #endif 5393 5394 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5395 extern simd_float16 _simd_cbrt_f16(simd_float16 x); 5396 static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x) { 5397 return _simd_cbrt_f16(x); 5398 } 5399 #else 5400 static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x) { 5401 return simd_make_float16(__tg_cbrt(x.lo), __tg_cbrt(x.hi)); 5402 } 5403 #endif 5404 5405 #if SIMD_LIBRARY_VERSION >= 3 5406 extern simd_double2 _simd_cbrt_d2(simd_double2 x); 5407 static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x) { 5408 return _simd_cbrt_d2(x); 5409 } 5410 #else 5411 static inline SIMD_CFUNC simd_double2 __tg_cbrt(simd_double2 x) { 5412 return simd_make_double2(cbrt(x.x), cbrt(x.y)); 5413 } 5414 #endif 5415 5416 static inline SIMD_CFUNC simd_double3 __tg_cbrt(simd_double3 x) { 5417 return simd_make_double3(__tg_cbrt(simd_make_double4(x))); 5418 } 5419 5420 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5421 extern simd_double4 _simd_cbrt_d4(simd_double4 x); 5422 static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) { 5423 return _simd_cbrt_d4(x); 5424 } 5425 #else 5426 static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) { 5427 return simd_make_double4(__tg_cbrt(x.lo), __tg_cbrt(x.hi)); 5428 } 5429 #endif 5430 5431 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5432 extern simd_double8 _simd_cbrt_d8(simd_double8 x); 5433 static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x) { 5434 return _simd_cbrt_d8(x); 5435 } 5436 #else 5437 static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x) { 5438 return simd_make_double8(__tg_cbrt(x.lo), __tg_cbrt(x.hi)); 5439 } 5440 #endif 5441 5442 #pragma mark - erf implementation 5443 static inline SIMD_CFUNC simd_float2 __tg_erf(simd_float2 x) { 5444 return simd_make_float2(__tg_erf(simd_make_float4(x))); 5445 } 5446 5447 static inline SIMD_CFUNC simd_float3 __tg_erf(simd_float3 x) { 5448 return simd_make_float3(__tg_erf(simd_make_float4(x))); 5449 } 5450 5451 #if SIMD_LIBRARY_VERSION >= 3 5452 extern simd_float4 _simd_erf_f4(simd_float4 x); 5453 static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x) { 5454 return _simd_erf_f4(x); 5455 } 5456 #else 5457 static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x) { 5458 return simd_make_float4(erf(x.x), erf(x.y), erf(x.z), erf(x.w)); 5459 } 5460 #endif 5461 5462 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5463 extern simd_float8 _simd_erf_f8(simd_float8 x); 5464 static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) { 5465 return _simd_erf_f8(x); 5466 } 5467 #else 5468 static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) { 5469 return simd_make_float8(__tg_erf(x.lo), __tg_erf(x.hi)); 5470 } 5471 #endif 5472 5473 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5474 extern simd_float16 _simd_erf_f16(simd_float16 x); 5475 static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x) { 5476 return _simd_erf_f16(x); 5477 } 5478 #else 5479 static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x) { 5480 return simd_make_float16(__tg_erf(x.lo), __tg_erf(x.hi)); 5481 } 5482 #endif 5483 5484 #if SIMD_LIBRARY_VERSION >= 3 5485 extern simd_double2 _simd_erf_d2(simd_double2 x); 5486 static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x) { 5487 return _simd_erf_d2(x); 5488 } 5489 #else 5490 static inline SIMD_CFUNC simd_double2 __tg_erf(simd_double2 x) { 5491 return simd_make_double2(erf(x.x), erf(x.y)); 5492 } 5493 #endif 5494 5495 static inline SIMD_CFUNC simd_double3 __tg_erf(simd_double3 x) { 5496 return simd_make_double3(__tg_erf(simd_make_double4(x))); 5497 } 5498 5499 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5500 extern simd_double4 _simd_erf_d4(simd_double4 x); 5501 static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) { 5502 return _simd_erf_d4(x); 5503 } 5504 #else 5505 static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) { 5506 return simd_make_double4(__tg_erf(x.lo), __tg_erf(x.hi)); 5507 } 5508 #endif 5509 5510 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5511 extern simd_double8 _simd_erf_d8(simd_double8 x); 5512 static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x) { 5513 return _simd_erf_d8(x); 5514 } 5515 #else 5516 static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x) { 5517 return simd_make_double8(__tg_erf(x.lo), __tg_erf(x.hi)); 5518 } 5519 #endif 5520 5521 #pragma mark - erfc implementation 5522 static inline SIMD_CFUNC simd_float2 __tg_erfc(simd_float2 x) { 5523 return simd_make_float2(__tg_erfc(simd_make_float4(x))); 5524 } 5525 5526 static inline SIMD_CFUNC simd_float3 __tg_erfc(simd_float3 x) { 5527 return simd_make_float3(__tg_erfc(simd_make_float4(x))); 5528 } 5529 5530 #if SIMD_LIBRARY_VERSION >= 3 5531 extern simd_float4 _simd_erfc_f4(simd_float4 x); 5532 static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x) { 5533 return _simd_erfc_f4(x); 5534 } 5535 #else 5536 static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x) { 5537 return simd_make_float4(erfc(x.x), erfc(x.y), erfc(x.z), erfc(x.w)); 5538 } 5539 #endif 5540 5541 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5542 extern simd_float8 _simd_erfc_f8(simd_float8 x); 5543 static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) { 5544 return _simd_erfc_f8(x); 5545 } 5546 #else 5547 static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) { 5548 return simd_make_float8(__tg_erfc(x.lo), __tg_erfc(x.hi)); 5549 } 5550 #endif 5551 5552 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5553 extern simd_float16 _simd_erfc_f16(simd_float16 x); 5554 static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x) { 5555 return _simd_erfc_f16(x); 5556 } 5557 #else 5558 static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x) { 5559 return simd_make_float16(__tg_erfc(x.lo), __tg_erfc(x.hi)); 5560 } 5561 #endif 5562 5563 #if SIMD_LIBRARY_VERSION >= 3 5564 extern simd_double2 _simd_erfc_d2(simd_double2 x); 5565 static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x) { 5566 return _simd_erfc_d2(x); 5567 } 5568 #else 5569 static inline SIMD_CFUNC simd_double2 __tg_erfc(simd_double2 x) { 5570 return simd_make_double2(erfc(x.x), erfc(x.y)); 5571 } 5572 #endif 5573 5574 static inline SIMD_CFUNC simd_double3 __tg_erfc(simd_double3 x) { 5575 return simd_make_double3(__tg_erfc(simd_make_double4(x))); 5576 } 5577 5578 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5579 extern simd_double4 _simd_erfc_d4(simd_double4 x); 5580 static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) { 5581 return _simd_erfc_d4(x); 5582 } 5583 #else 5584 static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) { 5585 return simd_make_double4(__tg_erfc(x.lo), __tg_erfc(x.hi)); 5586 } 5587 #endif 5588 5589 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5590 extern simd_double8 _simd_erfc_d8(simd_double8 x); 5591 static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x) { 5592 return _simd_erfc_d8(x); 5593 } 5594 #else 5595 static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x) { 5596 return simd_make_double8(__tg_erfc(x.lo), __tg_erfc(x.hi)); 5597 } 5598 #endif 5599 5600 #pragma mark - tgamma implementation 5601 static inline SIMD_CFUNC simd_float2 __tg_tgamma(simd_float2 x) { 5602 return simd_make_float2(__tg_tgamma(simd_make_float4(x))); 5603 } 5604 5605 static inline SIMD_CFUNC simd_float3 __tg_tgamma(simd_float3 x) { 5606 return simd_make_float3(__tg_tgamma(simd_make_float4(x))); 5607 } 5608 5609 #if SIMD_LIBRARY_VERSION >= 3 5610 extern simd_float4 _simd_tgamma_f4(simd_float4 x); 5611 static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x) { 5612 return _simd_tgamma_f4(x); 5613 } 5614 #else 5615 static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x) { 5616 return simd_make_float4(tgamma(x.x), tgamma(x.y), tgamma(x.z), tgamma(x.w)); 5617 } 5618 #endif 5619 5620 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5621 extern simd_float8 _simd_tgamma_f8(simd_float8 x); 5622 static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) { 5623 return _simd_tgamma_f8(x); 5624 } 5625 #else 5626 static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) { 5627 return simd_make_float8(__tg_tgamma(x.lo), __tg_tgamma(x.hi)); 5628 } 5629 #endif 5630 5631 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5632 extern simd_float16 _simd_tgamma_f16(simd_float16 x); 5633 static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x) { 5634 return _simd_tgamma_f16(x); 5635 } 5636 #else 5637 static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x) { 5638 return simd_make_float16(__tg_tgamma(x.lo), __tg_tgamma(x.hi)); 5639 } 5640 #endif 5641 5642 #if SIMD_LIBRARY_VERSION >= 3 5643 extern simd_double2 _simd_tgamma_d2(simd_double2 x); 5644 static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x) { 5645 return _simd_tgamma_d2(x); 5646 } 5647 #else 5648 static inline SIMD_CFUNC simd_double2 __tg_tgamma(simd_double2 x) { 5649 return simd_make_double2(tgamma(x.x), tgamma(x.y)); 5650 } 5651 #endif 5652 5653 static inline SIMD_CFUNC simd_double3 __tg_tgamma(simd_double3 x) { 5654 return simd_make_double3(__tg_tgamma(simd_make_double4(x))); 5655 } 5656 5657 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5658 extern simd_double4 _simd_tgamma_d4(simd_double4 x); 5659 static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) { 5660 return _simd_tgamma_d4(x); 5661 } 5662 #else 5663 static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) { 5664 return simd_make_double4(__tg_tgamma(x.lo), __tg_tgamma(x.hi)); 5665 } 5666 #endif 5667 5668 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5669 extern simd_double8 _simd_tgamma_d8(simd_double8 x); 5670 static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x) { 5671 return _simd_tgamma_d8(x); 5672 } 5673 #else 5674 static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x) { 5675 return simd_make_double8(__tg_tgamma(x.lo), __tg_tgamma(x.hi)); 5676 } 5677 #endif 5678 5679 #pragma mark - round implementation 5680 static inline SIMD_CFUNC simd_float2 __tg_round(simd_float2 x) { 5681 return simd_make_float2(__tg_round(simd_make_float4(x))); 5682 } 5683 5684 static inline SIMD_CFUNC simd_float3 __tg_round(simd_float3 x) { 5685 return simd_make_float3(__tg_round(simd_make_float4(x))); 5686 } 5687 5688 #if SIMD_LIBRARY_VERSION >= 3 5689 extern simd_float4 _simd_round_f4(simd_float4 x); 5690 static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x) { 5691 #if defined __arm64__ || defined __aarch64__ 5692 return vrndaq_f32(x); 5693 #else 5694 return _simd_round_f4(x); 5695 #endif 5696 } 5697 #else 5698 static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x) { 5699 return simd_make_float4(round(x.x), round(x.y), round(x.z), round(x.w)); 5700 } 5701 #endif 5702 5703 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5704 extern simd_float8 _simd_round_f8(simd_float8 x); 5705 static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) { 5706 return _simd_round_f8(x); 5707 } 5708 #else 5709 static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) { 5710 return simd_make_float8(__tg_round(x.lo), __tg_round(x.hi)); 5711 } 5712 #endif 5713 5714 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5715 extern simd_float16 _simd_round_f16(simd_float16 x); 5716 static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x) { 5717 return _simd_round_f16(x); 5718 } 5719 #else 5720 static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x) { 5721 return simd_make_float16(__tg_round(x.lo), __tg_round(x.hi)); 5722 } 5723 #endif 5724 5725 #if SIMD_LIBRARY_VERSION >= 3 5726 extern simd_double2 _simd_round_d2(simd_double2 x); 5727 static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x) { 5728 #if defined __arm64__ || defined __aarch64__ 5729 return vrndaq_f64(x); 5730 #else 5731 return _simd_round_d2(x); 5732 #endif 5733 } 5734 #else 5735 static inline SIMD_CFUNC simd_double2 __tg_round(simd_double2 x) { 5736 return simd_make_double2(round(x.x), round(x.y)); 5737 } 5738 #endif 5739 5740 static inline SIMD_CFUNC simd_double3 __tg_round(simd_double3 x) { 5741 return simd_make_double3(__tg_round(simd_make_double4(x))); 5742 } 5743 5744 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5745 extern simd_double4 _simd_round_d4(simd_double4 x); 5746 static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) { 5747 return _simd_round_d4(x); 5748 } 5749 #else 5750 static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) { 5751 return simd_make_double4(__tg_round(x.lo), __tg_round(x.hi)); 5752 } 5753 #endif 5754 5755 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5756 extern simd_double8 _simd_round_d8(simd_double8 x); 5757 static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x) { 5758 return _simd_round_d8(x); 5759 } 5760 #else 5761 static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x) { 5762 return simd_make_double8(__tg_round(x.lo), __tg_round(x.hi)); 5763 } 5764 #endif 5765 5766 #pragma mark - atan2 implementation 5767 static inline SIMD_CFUNC simd_float2 __tg_atan2(simd_float2 y, simd_float2 x) { 5768 return simd_make_float2(__tg_atan2(simd_make_float4(y), simd_make_float4(x))); 5769 } 5770 5771 static inline SIMD_CFUNC simd_float3 __tg_atan2(simd_float3 y, simd_float3 x) { 5772 return simd_make_float3(__tg_atan2(simd_make_float4(y), simd_make_float4(x))); 5773 } 5774 5775 #if SIMD_LIBRARY_VERSION >= 3 5776 extern simd_float4 _simd_atan2_f4(simd_float4 y, simd_float4 x); 5777 static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x) { 5778 return _simd_atan2_f4(y, x); 5779 } 5780 #else 5781 static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x) { 5782 return simd_make_float4(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)); 5783 } 5784 #endif 5785 5786 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5787 extern simd_float8 _simd_atan2_f8(simd_float8 y, simd_float8 x); 5788 static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) { 5789 return _simd_atan2_f8(y, x); 5790 } 5791 #else 5792 static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) { 5793 return simd_make_float8(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi)); 5794 } 5795 #endif 5796 5797 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5798 extern simd_float16 _simd_atan2_f16(simd_float16 y, simd_float16 x); 5799 static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x) { 5800 return _simd_atan2_f16(y, x); 5801 } 5802 #else 5803 static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x) { 5804 return simd_make_float16(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi)); 5805 } 5806 #endif 5807 5808 #if SIMD_LIBRARY_VERSION >= 3 5809 extern simd_double2 _simd_atan2_d2(simd_double2 y, simd_double2 x); 5810 static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x) { 5811 return _simd_atan2_d2(y, x); 5812 } 5813 #else 5814 static inline SIMD_CFUNC simd_double2 __tg_atan2(simd_double2 y, simd_double2 x) { 5815 return simd_make_double2(atan2(y.x, x.x), atan2(y.y, x.y)); 5816 } 5817 #endif 5818 5819 static inline SIMD_CFUNC simd_double3 __tg_atan2(simd_double3 y, simd_double3 x) { 5820 return simd_make_double3(__tg_atan2(simd_make_double4(y), simd_make_double4(x))); 5821 } 5822 5823 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5824 extern simd_double4 _simd_atan2_d4(simd_double4 y, simd_double4 x); 5825 static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x) { 5826 return _simd_atan2_d4(y, x); 5827 } 5828 #else 5829 static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x) { 5830 return simd_make_double4(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi)); 5831 } 5832 #endif 5833 5834 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5835 extern simd_double8 _simd_atan2_d8(simd_double8 y, simd_double8 x); 5836 static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x) { 5837 return _simd_atan2_d8(y, x); 5838 } 5839 #else 5840 static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x) { 5841 return simd_make_double8(__tg_atan2(y.lo, x.lo), __tg_atan2(y.hi, x.hi)); 5842 } 5843 #endif 5844 5845 #pragma mark - hypot implementation 5846 static inline SIMD_CFUNC simd_float2 __tg_hypot(simd_float2 x, simd_float2 y) { 5847 return simd_make_float2(__tg_hypot(simd_make_float4(x), simd_make_float4(y))); 5848 } 5849 5850 static inline SIMD_CFUNC simd_float3 __tg_hypot(simd_float3 x, simd_float3 y) { 5851 return simd_make_float3(__tg_hypot(simd_make_float4(x), simd_make_float4(y))); 5852 } 5853 5854 #if SIMD_LIBRARY_VERSION >= 3 5855 extern simd_float4 _simd_hypot_f4(simd_float4 x, simd_float4 y); 5856 static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y) { 5857 return _simd_hypot_f4(x, y); 5858 } 5859 #else 5860 static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y) { 5861 return simd_make_float4(hypot(x.x, y.x), hypot(x.y, y.y), hypot(x.z, y.z), hypot(x.w, y.w)); 5862 } 5863 #endif 5864 5865 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5866 extern simd_float8 _simd_hypot_f8(simd_float8 x, simd_float8 y); 5867 static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) { 5868 return _simd_hypot_f8(x, y); 5869 } 5870 #else 5871 static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) { 5872 return simd_make_float8(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi)); 5873 } 5874 #endif 5875 5876 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5877 extern simd_float16 _simd_hypot_f16(simd_float16 x, simd_float16 y); 5878 static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y) { 5879 return _simd_hypot_f16(x, y); 5880 } 5881 #else 5882 static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y) { 5883 return simd_make_float16(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi)); 5884 } 5885 #endif 5886 5887 #if SIMD_LIBRARY_VERSION >= 3 5888 extern simd_double2 _simd_hypot_d2(simd_double2 x, simd_double2 y); 5889 static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y) { 5890 return _simd_hypot_d2(x, y); 5891 } 5892 #else 5893 static inline SIMD_CFUNC simd_double2 __tg_hypot(simd_double2 x, simd_double2 y) { 5894 return simd_make_double2(hypot(x.x, y.x), hypot(x.y, y.y)); 5895 } 5896 #endif 5897 5898 static inline SIMD_CFUNC simd_double3 __tg_hypot(simd_double3 x, simd_double3 y) { 5899 return simd_make_double3(__tg_hypot(simd_make_double4(x), simd_make_double4(y))); 5900 } 5901 5902 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5903 extern simd_double4 _simd_hypot_d4(simd_double4 x, simd_double4 y); 5904 static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y) { 5905 return _simd_hypot_d4(x, y); 5906 } 5907 #else 5908 static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y) { 5909 return simd_make_double4(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi)); 5910 } 5911 #endif 5912 5913 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5914 extern simd_double8 _simd_hypot_d8(simd_double8 x, simd_double8 y); 5915 static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y) { 5916 return _simd_hypot_d8(x, y); 5917 } 5918 #else 5919 static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y) { 5920 return simd_make_double8(__tg_hypot(x.lo, y.lo), __tg_hypot(x.hi, y.hi)); 5921 } 5922 #endif 5923 5924 #pragma mark - pow implementation 5925 static inline SIMD_CFUNC simd_float2 __tg_pow(simd_float2 x, simd_float2 y) { 5926 return simd_make_float2(__tg_pow(simd_make_float4(x), simd_make_float4(y))); 5927 } 5928 5929 static inline SIMD_CFUNC simd_float3 __tg_pow(simd_float3 x, simd_float3 y) { 5930 return simd_make_float3(__tg_pow(simd_make_float4(x), simd_make_float4(y))); 5931 } 5932 5933 #if SIMD_LIBRARY_VERSION >= 3 5934 extern simd_float4 _simd_pow_f4(simd_float4 x, simd_float4 y); 5935 static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y) { 5936 return _simd_pow_f4(x, y); 5937 } 5938 #else 5939 static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y) { 5940 return simd_make_float4(pow(x.x, y.x), pow(x.y, y.y), pow(x.z, y.z), pow(x.w, y.w)); 5941 } 5942 #endif 5943 5944 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5945 extern simd_float8 _simd_pow_f8(simd_float8 x, simd_float8 y); 5946 static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) { 5947 return _simd_pow_f8(x, y); 5948 } 5949 #else 5950 static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) { 5951 return simd_make_float8(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi)); 5952 } 5953 #endif 5954 5955 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5956 extern simd_float16 _simd_pow_f16(simd_float16 x, simd_float16 y); 5957 static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y) { 5958 return _simd_pow_f16(x, y); 5959 } 5960 #else 5961 static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y) { 5962 return simd_make_float16(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi)); 5963 } 5964 #endif 5965 5966 #if SIMD_LIBRARY_VERSION >= 3 5967 extern simd_double2 _simd_pow_d2(simd_double2 x, simd_double2 y); 5968 static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y) { 5969 return _simd_pow_d2(x, y); 5970 } 5971 #else 5972 static inline SIMD_CFUNC simd_double2 __tg_pow(simd_double2 x, simd_double2 y) { 5973 return simd_make_double2(pow(x.x, y.x), pow(x.y, y.y)); 5974 } 5975 #endif 5976 5977 static inline SIMD_CFUNC simd_double3 __tg_pow(simd_double3 x, simd_double3 y) { 5978 return simd_make_double3(__tg_pow(simd_make_double4(x), simd_make_double4(y))); 5979 } 5980 5981 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 5982 extern simd_double4 _simd_pow_d4(simd_double4 x, simd_double4 y); 5983 static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) { 5984 return _simd_pow_d4(x, y); 5985 } 5986 #else 5987 static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) { 5988 return simd_make_double4(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi)); 5989 } 5990 #endif 5991 5992 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 5993 extern simd_double8 _simd_pow_d8(simd_double8 x, simd_double8 y); 5994 static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y) { 5995 return _simd_pow_d8(x, y); 5996 } 5997 #else 5998 static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y) { 5999 return simd_make_double8(__tg_pow(x.lo, y.lo), __tg_pow(x.hi, y.hi)); 6000 } 6001 #endif 6002 6003 #pragma mark - fmod implementation 6004 static inline SIMD_CFUNC simd_float2 __tg_fmod(simd_float2 x, simd_float2 y) { 6005 return simd_make_float2(__tg_fmod(simd_make_float4(x), simd_make_float4(y))); 6006 } 6007 6008 static inline SIMD_CFUNC simd_float3 __tg_fmod(simd_float3 x, simd_float3 y) { 6009 return simd_make_float3(__tg_fmod(simd_make_float4(x), simd_make_float4(y))); 6010 } 6011 6012 #if SIMD_LIBRARY_VERSION >= 3 6013 extern simd_float4 _simd_fmod_f4(simd_float4 x, simd_float4 y); 6014 static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y) { 6015 return _simd_fmod_f4(x, y); 6016 } 6017 #else 6018 static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y) { 6019 return simd_make_float4(fmod(x.x, y.x), fmod(x.y, y.y), fmod(x.z, y.z), fmod(x.w, y.w)); 6020 } 6021 #endif 6022 6023 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6024 extern simd_float8 _simd_fmod_f8(simd_float8 x, simd_float8 y); 6025 static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) { 6026 return _simd_fmod_f8(x, y); 6027 } 6028 #else 6029 static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) { 6030 return simd_make_float8(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi)); 6031 } 6032 #endif 6033 6034 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6035 extern simd_float16 _simd_fmod_f16(simd_float16 x, simd_float16 y); 6036 static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y) { 6037 return _simd_fmod_f16(x, y); 6038 } 6039 #else 6040 static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y) { 6041 return simd_make_float16(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi)); 6042 } 6043 #endif 6044 6045 #if SIMD_LIBRARY_VERSION >= 3 6046 extern simd_double2 _simd_fmod_d2(simd_double2 x, simd_double2 y); 6047 static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y) { 6048 return _simd_fmod_d2(x, y); 6049 } 6050 #else 6051 static inline SIMD_CFUNC simd_double2 __tg_fmod(simd_double2 x, simd_double2 y) { 6052 return simd_make_double2(fmod(x.x, y.x), fmod(x.y, y.y)); 6053 } 6054 #endif 6055 6056 static inline SIMD_CFUNC simd_double3 __tg_fmod(simd_double3 x, simd_double3 y) { 6057 return simd_make_double3(__tg_fmod(simd_make_double4(x), simd_make_double4(y))); 6058 } 6059 6060 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6061 extern simd_double4 _simd_fmod_d4(simd_double4 x, simd_double4 y); 6062 static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y) { 6063 return _simd_fmod_d4(x, y); 6064 } 6065 #else 6066 static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y) { 6067 return simd_make_double4(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi)); 6068 } 6069 #endif 6070 6071 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6072 extern simd_double8 _simd_fmod_d8(simd_double8 x, simd_double8 y); 6073 static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y) { 6074 return _simd_fmod_d8(x, y); 6075 } 6076 #else 6077 static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y) { 6078 return simd_make_double8(__tg_fmod(x.lo, y.lo), __tg_fmod(x.hi, y.hi)); 6079 } 6080 #endif 6081 6082 #pragma mark - remainder implementation 6083 static inline SIMD_CFUNC simd_float2 __tg_remainder(simd_float2 x, simd_float2 y) { 6084 return simd_make_float2(__tg_remainder(simd_make_float4(x), simd_make_float4(y))); 6085 } 6086 6087 static inline SIMD_CFUNC simd_float3 __tg_remainder(simd_float3 x, simd_float3 y) { 6088 return simd_make_float3(__tg_remainder(simd_make_float4(x), simd_make_float4(y))); 6089 } 6090 6091 #if SIMD_LIBRARY_VERSION >= 3 6092 extern simd_float4 _simd_remainder_f4(simd_float4 x, simd_float4 y); 6093 static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y) { 6094 return _simd_remainder_f4(x, y); 6095 } 6096 #else 6097 static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y) { 6098 return simd_make_float4(remainder(x.x, y.x), remainder(x.y, y.y), remainder(x.z, y.z), remainder(x.w, y.w)); 6099 } 6100 #endif 6101 6102 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6103 extern simd_float8 _simd_remainder_f8(simd_float8 x, simd_float8 y); 6104 static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y) { 6105 return _simd_remainder_f8(x, y); 6106 } 6107 #else 6108 static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y) { 6109 return simd_make_float8(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi)); 6110 } 6111 #endif 6112 6113 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6114 extern simd_float16 _simd_remainder_f16(simd_float16 x, simd_float16 y); 6115 static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y) { 6116 return _simd_remainder_f16(x, y); 6117 } 6118 #else 6119 static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y) { 6120 return simd_make_float16(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi)); 6121 } 6122 #endif 6123 6124 #if SIMD_LIBRARY_VERSION >= 3 6125 extern simd_double2 _simd_remainder_d2(simd_double2 x, simd_double2 y); 6126 static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y) { 6127 return _simd_remainder_d2(x, y); 6128 } 6129 #else 6130 static inline SIMD_CFUNC simd_double2 __tg_remainder(simd_double2 x, simd_double2 y) { 6131 return simd_make_double2(remainder(x.x, y.x), remainder(x.y, y.y)); 6132 } 6133 #endif 6134 6135 static inline SIMD_CFUNC simd_double3 __tg_remainder(simd_double3 x, simd_double3 y) { 6136 return simd_make_double3(__tg_remainder(simd_make_double4(x), simd_make_double4(y))); 6137 } 6138 6139 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6140 extern simd_double4 _simd_remainder_d4(simd_double4 x, simd_double4 y); 6141 static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y) { 6142 return _simd_remainder_d4(x, y); 6143 } 6144 #else 6145 static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y) { 6146 return simd_make_double4(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi)); 6147 } 6148 #endif 6149 6150 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6151 extern simd_double8 _simd_remainder_d8(simd_double8 x, simd_double8 y); 6152 static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y) { 6153 return _simd_remainder_d8(x, y); 6154 } 6155 #else 6156 static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y) { 6157 return simd_make_double8(__tg_remainder(x.lo, y.lo), __tg_remainder(x.hi, y.hi)); 6158 } 6159 #endif 6160 6161 #pragma mark - nextafter implementation 6162 static inline SIMD_CFUNC simd_float2 __tg_nextafter(simd_float2 x, simd_float2 y) { 6163 return simd_make_float2(__tg_nextafter(simd_make_float4(x), simd_make_float4(y))); 6164 } 6165 6166 static inline SIMD_CFUNC simd_float3 __tg_nextafter(simd_float3 x, simd_float3 y) { 6167 return simd_make_float3(__tg_nextafter(simd_make_float4(x), simd_make_float4(y))); 6168 } 6169 6170 #if SIMD_LIBRARY_VERSION >= 3 6171 extern simd_float4 _simd_nextafter_f4(simd_float4 x, simd_float4 y); 6172 static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y) { 6173 return _simd_nextafter_f4(x, y); 6174 } 6175 #else 6176 static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y) { 6177 return simd_make_float4(nextafter(x.x, y.x), nextafter(x.y, y.y), nextafter(x.z, y.z), nextafter(x.w, y.w)); 6178 } 6179 #endif 6180 6181 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6182 extern simd_float8 _simd_nextafter_f8(simd_float8 x, simd_float8 y); 6183 static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y) { 6184 return _simd_nextafter_f8(x, y); 6185 } 6186 #else 6187 static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y) { 6188 return simd_make_float8(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi)); 6189 } 6190 #endif 6191 6192 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6193 extern simd_float16 _simd_nextafter_f16(simd_float16 x, simd_float16 y); 6194 static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y) { 6195 return _simd_nextafter_f16(x, y); 6196 } 6197 #else 6198 static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y) { 6199 return simd_make_float16(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi)); 6200 } 6201 #endif 6202 6203 #if SIMD_LIBRARY_VERSION >= 3 6204 extern simd_double2 _simd_nextafter_d2(simd_double2 x, simd_double2 y); 6205 static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y) { 6206 return _simd_nextafter_d2(x, y); 6207 } 6208 #else 6209 static inline SIMD_CFUNC simd_double2 __tg_nextafter(simd_double2 x, simd_double2 y) { 6210 return simd_make_double2(nextafter(x.x, y.x), nextafter(x.y, y.y)); 6211 } 6212 #endif 6213 6214 static inline SIMD_CFUNC simd_double3 __tg_nextafter(simd_double3 x, simd_double3 y) { 6215 return simd_make_double3(__tg_nextafter(simd_make_double4(x), simd_make_double4(y))); 6216 } 6217 6218 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__ 6219 extern simd_double4 _simd_nextafter_d4(simd_double4 x, simd_double4 y); 6220 static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y) { 6221 return _simd_nextafter_d4(x, y); 6222 } 6223 #else 6224 static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y) { 6225 return simd_make_double4(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi)); 6226 } 6227 #endif 6228 6229 #if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__ 6230 extern simd_double8 _simd_nextafter_d8(simd_double8 x, simd_double8 y); 6231 static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y) { 6232 return _simd_nextafter_d8(x, y); 6233 } 6234 #else 6235 static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y) { 6236 return simd_make_double8(__tg_nextafter(x.lo, y.lo), __tg_nextafter(x.hi, y.hi)); 6237 } 6238 #endif 6239 6240 #if SIMD_LIBRARY_VERSION >= 5 6241 #pragma mark - sincos implementation 6242 static inline SIMD_NONCONST void __tg_sincos(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp) { 6243 simd_float4 sin_val; 6244 simd_float4 cos_val; 6245 __tg_sincos(simd_make_float4(x), &sin_val, &cos_val); 6246 *sinp = simd_make_float2(sin_val); 6247 *cosp = simd_make_float2(cos_val); 6248 } 6249 6250 static inline SIMD_NONCONST void __tg_sincos(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp) { 6251 simd_float4 sin_val; 6252 simd_float4 cos_val; 6253 __tg_sincos(simd_make_float4(x), &sin_val, &cos_val); 6254 *sinp = simd_make_float3(sin_val); 6255 *cosp = simd_make_float3(cos_val); 6256 } 6257 6258 extern void _simd_sincos_f4(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp); 6259 static inline SIMD_NONCONST void __tg_sincos(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp) { 6260 return _simd_sincos_f4(x, sinp, cosp); 6261 } 6262 6263 static inline SIMD_NONCONST void __tg_sincos(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp) { 6264 __tg_sincos(x.lo, (simd_float4 *)sinp+0, (simd_float4 *)cosp+0); 6265 __tg_sincos(x.hi, (simd_float4 *)sinp+1, (simd_float4 *)cosp+1); 6266 } 6267 6268 static inline SIMD_NONCONST void __tg_sincos(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp) { 6269 __tg_sincos(x.lo, (simd_float8 *)sinp+0, (simd_float8 *)cosp+0); 6270 __tg_sincos(x.hi, (simd_float8 *)sinp+1, (simd_float8 *)cosp+1); 6271 } 6272 6273 extern void _simd_sincos_d2(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp); 6274 static inline SIMD_NONCONST void __tg_sincos(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp) { 6275 return _simd_sincos_d2(x, sinp, cosp); 6276 } 6277 6278 static inline SIMD_NONCONST void __tg_sincos(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp) { 6279 simd_double4 sin_val; 6280 simd_double4 cos_val; 6281 __tg_sincos(simd_make_double4(x), &sin_val, &cos_val); 6282 *sinp = simd_make_double3(sin_val); 6283 *cosp = simd_make_double3(cos_val); 6284 } 6285 6286 static inline SIMD_NONCONST void __tg_sincos(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp) { 6287 __tg_sincos(x.lo, (simd_double2 *)sinp+0, (simd_double2 *)cosp+0); 6288 __tg_sincos(x.hi, (simd_double2 *)sinp+1, (simd_double2 *)cosp+1); 6289 } 6290 6291 static inline SIMD_NONCONST void __tg_sincos(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp) { 6292 __tg_sincos(x.lo, (simd_double4 *)sinp+0, (simd_double4 *)cosp+0); 6293 __tg_sincos(x.hi, (simd_double4 *)sinp+1, (simd_double4 *)cosp+1); 6294 } 6295 6296 #pragma mark - sincospi implementation 6297 static inline SIMD_NONCONST void __tg_sincospi(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp) { 6298 simd_float4 sin_val; 6299 simd_float4 cos_val; 6300 __tg_sincospi(simd_make_float4(x), &sin_val, &cos_val); 6301 *sinp = simd_make_float2(sin_val); 6302 *cosp = simd_make_float2(cos_val); 6303 } 6304 6305 static inline SIMD_NONCONST void __tg_sincospi(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp) { 6306 simd_float4 sin_val; 6307 simd_float4 cos_val; 6308 __tg_sincospi(simd_make_float4(x), &sin_val, &cos_val); 6309 *sinp = simd_make_float3(sin_val); 6310 *cosp = simd_make_float3(cos_val); 6311 } 6312 6313 extern void _simd_sincospi_f4(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp); 6314 static inline SIMD_NONCONST void __tg_sincospi(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp) { 6315 return _simd_sincospi_f4(x, sinp, cosp); 6316 } 6317 6318 static inline SIMD_NONCONST void __tg_sincospi(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp) { 6319 __tg_sincospi(x.lo, (simd_float4 *)sinp+0, (simd_float4 *)cosp+0); 6320 __tg_sincospi(x.hi, (simd_float4 *)sinp+1, (simd_float4 *)cosp+1); 6321 } 6322 6323 static inline SIMD_NONCONST void __tg_sincospi(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp) { 6324 __tg_sincospi(x.lo, (simd_float8 *)sinp+0, (simd_float8 *)cosp+0); 6325 __tg_sincospi(x.hi, (simd_float8 *)sinp+1, (simd_float8 *)cosp+1); 6326 } 6327 6328 extern void _simd_sincospi_d2(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp); 6329 static inline SIMD_NONCONST void __tg_sincospi(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp) { 6330 return _simd_sincospi_d2(x, sinp, cosp); 6331 } 6332 6333 static inline SIMD_NONCONST void __tg_sincospi(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp) { 6334 simd_double4 sin_val; 6335 simd_double4 cos_val; 6336 __tg_sincospi(simd_make_double4(x), &sin_val, &cos_val); 6337 *sinp = simd_make_double3(sin_val); 6338 *cosp = simd_make_double3(cos_val); 6339 } 6340 6341 static inline SIMD_NONCONST void __tg_sincospi(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp) { 6342 __tg_sincospi(x.lo, (simd_double2 *)sinp+0, (simd_double2 *)cosp+0); 6343 __tg_sincospi(x.hi, (simd_double2 *)sinp+1, (simd_double2 *)cosp+1); 6344 } 6345 6346 static inline SIMD_NONCONST void __tg_sincospi(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp) { 6347 __tg_sincospi(x.lo, (simd_double4 *)sinp+0, (simd_double4 *)cosp+0); 6348 __tg_sincospi(x.hi, (simd_double4 *)sinp+1, (simd_double4 *)cosp+1); 6349 } 6350 6351 #endif // SIMD_LIBRARY_VERSION >= 5 6352 #pragma mark - lgamma implementation 6353 static inline SIMD_CFUNC simd_float2 __tg_lgamma(simd_float2 x) { 6354 return simd_make_float2(__tg_lgamma(simd_make_float4(x))); 6355 } 6356 6357 static inline SIMD_CFUNC simd_float3 __tg_lgamma(simd_float3 x) { 6358 return simd_make_float3(__tg_lgamma(simd_make_float4(x))); 6359 } 6360 6361 #if SIMD_LIBRARY_VERSION >= 4 6362 extern simd_float4 _simd_lgamma_f4(simd_float4 x); 6363 static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x) { 6364 return _simd_lgamma_f4(x); 6365 } 6366 #else 6367 static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x) { 6368 return simd_make_float4(lgamma(x.x), lgamma(x.y), lgamma(x.z), lgamma(x.w)); 6369 } 6370 #endif 6371 6372 #if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX2__ 6373 extern simd_float8 _simd_lgamma_f8(simd_float8 x); 6374 static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x) { 6375 return _simd_lgamma_f8(x); 6376 } 6377 #else 6378 static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x) { 6379 return simd_make_float8(__tg_lgamma(x.lo), __tg_lgamma(x.hi)); 6380 } 6381 #endif 6382 6383 #if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX512F__ 6384 extern simd_float16 _simd_lgamma_f16(simd_float16 x); 6385 static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x) { 6386 return _simd_lgamma_f16(x); 6387 } 6388 #else 6389 static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x) { 6390 return simd_make_float16(__tg_lgamma(x.lo), __tg_lgamma(x.hi)); 6391 } 6392 #endif 6393 6394 #if SIMD_LIBRARY_VERSION >= 4 6395 extern simd_double2 _simd_lgamma_d2(simd_double2 x); 6396 static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x) { 6397 return _simd_lgamma_d2(x); 6398 } 6399 #else 6400 static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x) { 6401 return simd_make_double2(lgamma(x.x), lgamma(x.y)); 6402 } 6403 #endif 6404 6405 static inline SIMD_CFUNC simd_double3 __tg_lgamma(simd_double3 x) { 6406 return simd_make_double3(__tg_lgamma(simd_make_double4(x))); 6407 } 6408 6409 #if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX2__ 6410 extern simd_double4 _simd_lgamma_d4(simd_double4 x); 6411 static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x) { 6412 return _simd_lgamma_d4(x); 6413 } 6414 #else 6415 static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x) { 6416 return simd_make_double4(__tg_lgamma(x.lo), __tg_lgamma(x.hi)); 6417 } 6418 #endif 6419 6420 #if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX512F__ 6421 extern simd_double8 _simd_lgamma_d8(simd_double8 x); 6422 static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x) { 6423 return _simd_lgamma_d8(x); 6424 } 6425 #else 6426 static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x) { 6427 return simd_make_double8(__tg_lgamma(x.lo), __tg_lgamma(x.hi)); 6428 } 6429 #endif 6430 6431 static inline SIMD_CFUNC simd_float2 __tg_fdim(simd_float2 x, simd_float2 y) { return simd_bitselect(x-y, 0, x<y); } 6432 static inline SIMD_CFUNC simd_float3 __tg_fdim(simd_float3 x, simd_float3 y) { return simd_bitselect(x-y, 0, x<y); } 6433 static inline SIMD_CFUNC simd_float4 __tg_fdim(simd_float4 x, simd_float4 y) { return simd_bitselect(x-y, 0, x<y); } 6434 static inline SIMD_CFUNC simd_float8 __tg_fdim(simd_float8 x, simd_float8 y) { return simd_bitselect(x-y, 0, x<y); } 6435 static inline SIMD_CFUNC simd_float16 __tg_fdim(simd_float16 x, simd_float16 y) { return simd_bitselect(x-y, 0, x<y); } 6436 static inline SIMD_CFUNC simd_double2 __tg_fdim(simd_double2 x, simd_double2 y) { return simd_bitselect(x-y, 0, x<y); } 6437 static inline SIMD_CFUNC simd_double3 __tg_fdim(simd_double3 x, simd_double3 y) { return simd_bitselect(x-y, 0, x<y); } 6438 static inline SIMD_CFUNC simd_double4 __tg_fdim(simd_double4 x, simd_double4 y) { return simd_bitselect(x-y, 0, x<y); } 6439 static inline SIMD_CFUNC simd_double8 __tg_fdim(simd_double8 x, simd_double8 y) { return simd_bitselect(x-y, 0, x<y); } 6440 6441 static inline SIMD_CFUNC simd_float2 __tg_fma(simd_float2 x, simd_float2 y, simd_float2 z) { 6442 #if defined __arm64__ || defined __aarch64__ || defined __ARM_VFPV4__ 6443 return vfma_f32(z, x, y); 6444 #else 6445 return simd_make_float2(__tg_fma(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_float4_undef(z))); 6446 #endif 6447 } 6448 6449 static inline SIMD_CFUNC simd_float3 __tg_fma(simd_float3 x, simd_float3 y, simd_float3 z) { 6450 return simd_make_float3(__tg_fma(simd_make_float4(x), simd_make_float4(y), simd_make_float4(z))); 6451 } 6452 6453 #if SIMD_LIBRARY_VERSION >= 3 6454 extern simd_float4 _simd_fma_f4(simd_float4 x, simd_float4 y, simd_float4 z); 6455 #endif 6456 static inline SIMD_CFUNC simd_float4 __tg_fma(simd_float4 x, simd_float4 y, simd_float4 z) { 6457 #if defined __arm64__ || defined __aarch64__ || defined __ARM_VFPV4__ 6458 return vfmaq_f32(z, x, y); 6459 #elif (defined __i386__ || defined __x86_64__) && defined __FMA__ 6460 return _mm_fmadd_ps(x, y, z); 6461 #elif SIMD_LIBRARY_VERSION >= 3 6462 return _simd_fma_f4(x, y, z); 6463 #else 6464 return simd_make_float4(fma(x.x, y.x, z.x), fma(x.y, y.y, z.y), fma(x.z, y.z, z.z), fma(x.w, y.w, z.w)); 6465 #endif 6466 } 6467 6468 static inline SIMD_CFUNC simd_float8 __tg_fma(simd_float8 x, simd_float8 y, simd_float8 z) { 6469 #if (defined __i386__ || defined __x86_64__) && defined __FMA__ 6470 return _mm256_fmadd_ps(x, y, z); 6471 #else 6472 return simd_make_float8(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi)); 6473 #endif 6474 } 6475 6476 static inline SIMD_CFUNC simd_float16 __tg_fma(simd_float16 x, simd_float16 y, simd_float16 z) { 6477 #if defined __x86_64__ && defined __AVX512F__ 6478 return _mm512_fmadd_ps(x, y, z); 6479 #else 6480 return simd_make_float16(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi)); 6481 #endif 6482 } 6483 6484 #if SIMD_LIBRARY_VERSION >= 3 6485 extern simd_double2 _simd_fma_d2(simd_double2 x, simd_double2 y, simd_double2 z); 6486 #endif 6487 static inline SIMD_CFUNC simd_double2 __tg_fma(simd_double2 x, simd_double2 y, simd_double2 z) { 6488 #if defined __arm64__ || defined __aarch64__ 6489 return vfmaq_f64(z, x, y); 6490 #elif (defined __i386__ || defined __x86_64__) && defined __FMA__ 6491 return _mm_fmadd_pd(x, y, z); 6492 #elif SIMD_LIBRARY_VERSION >= 3 6493 return _simd_fma_d2(x, y, z); 6494 #else 6495 return simd_make_double2(fma(x.x, y.x, z.x), fma(x.y, y.y, z.y)); 6496 #endif 6497 } 6498 6499 static inline SIMD_CFUNC simd_double3 __tg_fma(simd_double3 x, simd_double3 y, simd_double3 z) { 6500 return simd_make_double3(__tg_fma(simd_make_double4(x), simd_make_double4(y), simd_make_double4(z))); 6501 } 6502 6503 static inline SIMD_CFUNC simd_double4 __tg_fma(simd_double4 x, simd_double4 y, simd_double4 z) { 6504 #if (defined __i386__ || defined __x86_64__) && defined __FMA__ 6505 return _mm256_fmadd_pd(x, y, z); 6506 #else 6507 return simd_make_double4(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi)); 6508 #endif 6509 } 6510 6511 static inline SIMD_CFUNC simd_double8 __tg_fma(simd_double8 x, simd_double8 y, simd_double8 z) { 6512 #if defined __x86_64__ && defined __AVX512F__ 6513 return _mm512_fmadd_pd(x, y, z); 6514 #else 6515 return simd_make_double8(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi)); 6516 #endif 6517 } 6518 6519 static inline SIMD_CFUNC _Float16 simd_muladd(_Float16 x, _Float16 y, _Float16 z) { 6520 #pragma STDC FP_CONTRACT ON 6521 return x*y + z; 6522 } 6523 static inline SIMD_CFUNC simd_half2 simd_muladd(simd_half2 x, simd_half2 y, simd_half2 z) { 6524 #pragma STDC FP_CONTRACT ON 6525 return x*y + z; 6526 } 6527 static inline SIMD_CFUNC simd_half3 simd_muladd(simd_half3 x, simd_half3 y, simd_half3 z) { 6528 #pragma STDC FP_CONTRACT ON 6529 return x*y + z; 6530 } 6531 static inline SIMD_CFUNC simd_half4 simd_muladd(simd_half4 x, simd_half4 y, simd_half4 z) { 6532 #pragma STDC FP_CONTRACT ON 6533 return x*y + z; 6534 } 6535 static inline SIMD_CFUNC simd_half8 simd_muladd(simd_half8 x, simd_half8 y, simd_half8 z) { 6536 #pragma STDC FP_CONTRACT ON 6537 return x*y + z; 6538 } 6539 static inline SIMD_CFUNC simd_half16 simd_muladd(simd_half16 x, simd_half16 y, simd_half16 z) { 6540 #pragma STDC FP_CONTRACT ON 6541 return x*y + z; 6542 } 6543 static inline SIMD_CFUNC simd_half32 simd_muladd(simd_half32 x, simd_half32 y, simd_half32 z) { 6544 #pragma STDC FP_CONTRACT ON 6545 return x*y + z; 6546 } 6547 static inline SIMD_CFUNC float simd_muladd(float x, float y, float z) { 6548 #pragma STDC FP_CONTRACT ON 6549 return x*y + z; 6550 } 6551 static inline SIMD_CFUNC simd_float2 simd_muladd(simd_float2 x, simd_float2 y, simd_float2 z) { 6552 #pragma STDC FP_CONTRACT ON 6553 return x*y + z; 6554 } 6555 static inline SIMD_CFUNC simd_float3 simd_muladd(simd_float3 x, simd_float3 y, simd_float3 z) { 6556 #pragma STDC FP_CONTRACT ON 6557 return x*y + z; 6558 } 6559 static inline SIMD_CFUNC simd_float4 simd_muladd(simd_float4 x, simd_float4 y, simd_float4 z) { 6560 #pragma STDC FP_CONTRACT ON 6561 return x*y + z; 6562 } 6563 static inline SIMD_CFUNC simd_float8 simd_muladd(simd_float8 x, simd_float8 y, simd_float8 z) { 6564 #pragma STDC FP_CONTRACT ON 6565 return x*y + z; 6566 } 6567 static inline SIMD_CFUNC simd_float16 simd_muladd(simd_float16 x, simd_float16 y, simd_float16 z) { 6568 #pragma STDC FP_CONTRACT ON 6569 return x*y + z; 6570 } 6571 static inline SIMD_CFUNC double simd_muladd(double x, double y, double z) { 6572 #pragma STDC FP_CONTRACT ON 6573 return x*y + z; 6574 } 6575 static inline SIMD_CFUNC simd_double2 simd_muladd(simd_double2 x, simd_double2 y, simd_double2 z) { 6576 #pragma STDC FP_CONTRACT ON 6577 return x*y + z; 6578 } 6579 static inline SIMD_CFUNC simd_double3 simd_muladd(simd_double3 x, simd_double3 y, simd_double3 z) { 6580 #pragma STDC FP_CONTRACT ON 6581 return x*y + z; 6582 } 6583 static inline SIMD_CFUNC simd_double4 simd_muladd(simd_double4 x, simd_double4 y, simd_double4 z) { 6584 #pragma STDC FP_CONTRACT ON 6585 return x*y + z; 6586 } 6587 static inline SIMD_CFUNC simd_double8 simd_muladd(simd_double8 x, simd_double8 y, simd_double8 z) { 6588 #pragma STDC FP_CONTRACT ON 6589 return x*y + z; 6590 } 6591 #ifdef __cplusplus 6592 } /* extern "C" */ 6593 #endif 6594 #endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */ 6595 #endif /* SIMD_MATH_HEADER */