Index: include/llvm/Analysis/TargetLibraryInfo.def =================================================================== --- include/llvm/Analysis/TargetLibraryInfo.def +++ include/llvm/Analysis/TargetLibraryInfo.def @@ -888,6 +888,12 @@ TLI_DEFINE_ENUM_INTERNAL(sin) TLI_DEFINE_STRING_INTERNAL("sin") /// float sinf(float x); +/// void sincos(double x, double *y, double *z); +TLI_DEFINE_ENUM_INTERNAL(sincos) +TLI_DEFINE_STRING_INTERNAL("sincos") +/// void sincosf(float x, float *y, float *z); +TLI_DEFINE_ENUM_INTERNAL(sincosf) +TLI_DEFINE_STRING_INTERNAL("sincosf") TLI_DEFINE_ENUM_INTERNAL(sinf) TLI_DEFINE_STRING_INTERNAL("sinf") /// double sinh(double x); Index: include/llvm/IR/Intrinsics.td =================================================================== --- include/llvm/IR/Intrinsics.td +++ include/llvm/IR/Intrinsics.td @@ -395,6 +395,23 @@ [IntrNoMem]>; } +// NOTE: The design decision here is to let the vectorizer expand args 2 and 3 +// to a vector of pointers. Unfortunately, without further analysis, this +// implies scatter semantics. Thus, we will do SCEV analysis on the original +// scalar args to determine the type of stores to generate after the intrinsic +// call. Args 2 and 3 are specified as llvm_any_ty because there is no way to +// represent a combination of any type of pointer and any type of float +// simultaneously. Let the signature checking function in +// lib/Analysis/VectorUtils.cpp enforce correct typing for the intrinsic. +// This intrinsic is marked as IntrArgMemOnly because it returns void and we +// want to prevent the call from being eliminated as dead code before the +// translation to a vector math library call. +def int_sincos : Intrinsic<[], + [llvm_anyfloat_ty, + llvm_any_ty, + llvm_any_ty], + [IntrArgMemOnly]>; + def int_minnum : Intrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem, Commutative] >; Index: include/llvm/InitializePasses.h =================================================================== --- include/llvm/InitializePasses.h +++ include/llvm/InitializePasses.h @@ -333,6 +333,7 @@ void initializeLoopVersioningPassPass(PassRegistry &); void initializeWholeProgramDevirtPass(PassRegistry &); void initializePatchableFunctionPass(PassRegistry &); +void initializeIntrinToMathLibPass(PassRegistry&); } #endif Index: include/llvm/LinkAllPasses.h =================================================================== --- include/llvm/LinkAllPasses.h +++ include/llvm/LinkAllPasses.h @@ -46,6 +46,7 @@ #include "llvm/Transforms/Utils/SymbolRewriter.h" #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h" #include "llvm/Transforms/Vectorize.h" +#include "llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h" #include "llvm/Support/Valgrind.h" #include @@ -192,6 +193,7 @@ (void) llvm::createMemDerefPrinter(); (void) llvm::createFloat2IntPass(); (void) llvm::createEliminateAvailableExternallyPass(); + (void) llvm::createIntrinToMathLibPass(); (void)new llvm::IntervalPartition(); (void)new llvm::ScalarEvolutionWrapperPass(); Index: include/llvm/Transforms/IntrinToMathLib/ImlAccuracyInterface.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/ImlAccuracyInterface.h +++ include/llvm/Transforms/IntrinToMathLib/ImlAccuracyInterface.h @@ -0,0 +1,71 @@ +//=-- ImlAccuracyInterface.h - Interface for finding appropriate -*- C++ -*--=// +// math functions based on precision +// attributes. +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file defines an interface that is used to find math functions based +/// on precision attributes and whether or not a particular function is +/// available as an inline instruction sequence. +/// +// ===--------------------------------------------------------------------=== // + +#ifndef LLVM_TRANSFORMS_INTRINTOMATHLIB_IML_ACCURACY_INTERFACE_H +#define LLVM_TRANSFORMS_INTRINTOMATHLIB_IML_ACCURACY_INTERFACE_H + +#if defined __cplusplus +extern "C" { +#endif // __cplusplus + + +/// \brief String pair which defines name and value for a single attribute. The +/// first string in a pair contains the attribute name. The second defines the +/// attribute value. There is also a pointer to the next attribute structure. +typedef struct ImfAttr { + const char* Name; + const char* Value; + struct ImfAttr* Next; +} ImfAttr; + +/// \brief This function returns the name of the library function to call given +/// the specified constraints. +/// +/// \param BaseName The name of the math function of interest, e.g. sin, expf. +/// +/// \param Attributes Defines desired constrains for the function. Attributes +/// array is terminated by an attribute with NULL next +/// pointer. +extern const char* getLibraryFunctionName(const char* BaseName, + const ImfAttr* Attributes); + +/// \brief This function returns 1 or 0 meaning "yes" or "no". It answers the +/// question: whether the compiler may use an instructions sequence with certain +/// properties described by InlineImplementationAttributes list given the +/// conditions specified by UserSpecifiedAttributes list. +/// +/// \param FunctionName The name of the math function of interest, e.g. sin, +/// expf. +/// +/// \param UserSpecifiedAttributes +/// Define desired constrains for the function. Attributes array is terminated +/// by a pair with the NULL attribute name. +/// +/// \param InlineImplementationAttributes +/// Define properties of some function implementation (presumably known to the +/// compiler). Attributes array is terminated by a pair with the NULL attribute +/// name. +int mayIUseInlineImplementation(const char* FunctionName, + const ImfAttr* UserSpecifiedAttributes, + const ImfAttr* InlineImplementationAttributes); + +#if defined __cplusplus +} +#endif // __cplusplus + +#endif // LLVM_TRANSFORMS_INTRINTOMATHLIB_IML_ACCURACY_INTERFACE_H Index: include/llvm/Transforms/IntrinToMathLib/ImlAttrPrivate.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/ImlAttrPrivate.h +++ include/llvm/Transforms/IntrinToMathLib/ImlAttrPrivate.h @@ -0,0 +1,27 @@ +//==------------ ImlAttrPrivate.h - Common use macros -*- C++ -*------------==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file defines a general set of macros. +/// +// ===--------------------------------------------------------------------=== // + +#ifndef LLVM_TRANSFORMS_INTRINTOMATHLIB_IMLATTRPRIVATE_H +#define LLVM_TRANSFORMS_INTRINTOMATHLIB_IMLATTRPRIVATE_H + +#ifndef _WIN32 +// Linux/MacOS/QNX +// Hidden visibility for any internal symbol which is shared inside the library +#define IMLATTR_INTERNAL_FUNC_VISIBILITY __attribute__((visibility("hidden"))) +#else +// Windows +#define IMLATTR_INTERNAL_FUNC_VISIBILITY +#endif + +#endif // LLVM_TRANSFORMS_INTRINTOMATHLIB_IMLATTRPRIVATE_H Index: include/llvm/Transforms/IntrinToMathLib/ImlExp2f.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/ImlExp2f.h +++ include/llvm/Transforms/IntrinToMathLib/ImlExp2f.h @@ -0,0 +1,187 @@ +//===------------ ImlExp2f.h - Implementation of exp2f -*- C++ -*----------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file provides the implementation of a bitwise reproducible exp2f. +/// This code was copied here to avoid a dependency to the math library and is +/// called from ImlAccuracyInterface.cpp. +/// +// ===--------------------------------------------------------------------=== // + +/// \brief Returns the exponential of \p x. +// +// float exp2f(float x) +// +// Generic CPU version +// +// Description: +// Let K = 64 (table size). +// x n +// 2 = 2 * (1 + T[j]) * (1 + P(y)) +// where +// x = m/K + y, y in [0.0..1/K] +// m = n*K + j, m,n,j - signed integer, j in [-K/2..K/2] +// j/K +// values of 2 are tabulated as T[j]. +// +// P(y) is a minimax polynomial approximation of exp2f(x)-1 +// on small interval [0.0..1/K] (were calculated by Maple V). +// +// Special cases: +// exp2f(NaN) = NaN +// exp2f(+INF) = +INF +// exp2f(-INF) = 0 +// exp2f(x) = 1 for subnormals +// for finite argument, exp2f returns exact result for any integer x in +// [-149..127] +// For IEEE float +// if x >= 128.0 then exp2f(x) overflow +// if x < -151.0 then exp2f(x) underflow + +static float imlAttrExp2f(float x) { +/* macros to sign-expand low 'Num' bits of 'Val' to native integer */ +#define SignExpand(Val, Num) \ + ((int)(Val) << (32 - (Num))) >> (32 - (Num)) // sign expand of 'Num' LSBs + +#define EXACT_RESULTS // raise inexact more accurately, but slow down the + // routine + + static const unsigned Range[] = {0x42ffffff, 0x431e0000}; // 128,151 + + static const double P[] = { + .69314718055214481968005225839151665254000291772723e-0 // 3FE62E42 + // FEFA39EF + , + .24022651095133014901564508704543890813313513082204e-0 // 3FCEBFBD + // FF82C58F + , + .55503393667531251585018864474520942624622996868437e-1 // 3FAC6B08 + // D704A135 + , + .96703711395723542012735846658159878679459918215073e-2 // 3F83B2AB + // 6FB88304 + }; + + static const double KOne = 64.0; // 40500000 00000000 K + + static const double NOneK = -.156250e-01; // 3F900000 00000000 1/K + +#define InfZero ((const float *)_InfZero) + static const unsigned _InfZero[] = {0x7f800000, 0x00000000}; // +INF,+0 + +// miscellaneous data + +#define Two23h (*(const float *)_Two23h) + static const unsigned _Two23h[] = {0x4b400000}; // 2^23+2^22 + +#define Overflow32(S) (LargeValue32[(S)] * LargeValue32[0]) +#define LargeValue32 ((const float *)_LargeValue32) + static const unsigned int _LargeValue32[] = { + 0x71800000, 0xf1800000}; // +2^100,-2^100 + +#define Underflow32(S) (SmallValue32[(S)] * SmallValue32[0]) +#define SmallValue32 ((const float *)_SmallValue32) + static const unsigned int _SmallValue32[] = { + 0x0d800000, 0x8d800000}; // +2^(-100),-2^(-100) + + static const float Ones[2] = {1.0f, -1.0f}; + +#define Bias32 127 +#define Bias64 1023 + +#define Expo32(i) (((i) >> 23) - Bias32) +#define Fraction32(i) ((i) << (32 - 23 + Expo32(i))) + +#define I32(f) (*(volatile int *)&f) +#define I64(f) (*(long long int *)&f) + +// exp2f() data +#define L 6 +#define K 64 // 2^L + +#define T __LibmExpfTable64 +#include "ImlExpfTable.h" + + unsigned Ix; + int Sign, m, n, j; + float ResultF, Scf; + float volatile Tv; + double y, z, t, p, Scale; + + Ix = (I32(x) & ~0x80000000); +#ifdef EXACT_RESULTS + // Check for argument values for which result must be exact. For exp2f, this + // is all integers in the inclusive Range [-149..127]. + if ((Ix - 0x3f800000 <= 0x42fe0000 - 0x3f800000) && + (Fraction32(Ix) == 0) && // |x| >= 1.0, x is integer + (Tv = (x + Two23h), m = SignExpand(I32(Tv), 23 - 1), + m >= -149)) { // m = (int)x + if ((m += Bias32) > 0) { // exact normal result + I32(ResultF) = ((int)m << 23); + } else { // exact subnormal ResultF + I32(ResultF) = ((int)1 << (m + 22)); + } + return ResultF; + } +#endif // EXACT_RESULTS + if (Ix < 0x42fa0000 /*125.0*/) { // 0 <= |x| < 125.0 + if (Ix < 0x31800000) { // 0 <= |x| < 2^(-28) + return Tv = (Ones[0] + + x); // value of 1.0 with inexact raised, except for x==0 + } + Tv = (x * KOne + Two23h); + t = (Tv - Two23h); + m = SignExpand(I32(Tv), 23 - 1); + y = (x + t * NOneK); + j = SignExpand(m, L); + n = (m - j) >> L; + I32(Scf) = (int)(n + Bias32) << 23; + z = y * y; + p = (P[3] * z + P[1]) * z + (P[2] * z + P[0]) * y; + ResultF = (p * T[K / 2 + j] + T[K / 2 + j]) * Scf; + return ResultF; + } + Sign = ((unsigned)I32(x) >> 31); + if (Ix <= Range[Sign]) { // 125.0 <= |x| <= Range + Tv = (x * KOne + Two23h); + t = (Tv - Two23h); + m = SignExpand(I32(Tv), 23 - 1); + y = (x + t * NOneK); + j = SignExpand(m, L); + n = (m - j) >> L; + I64(Scale) = (long long int)(Bias64 + n) << 52; + z = y * y; + p = (P[3] * z + P[1]) * z + (P[2] * z + P[0]) * y; + ResultF = (p * T[K / 2 + j] + T[K / 2 + j]) * Scale; + if (I32(ResultF) < 0x00800000) { + //__libm_error_support (&x, &x, &ResultF, exp2f_underflow); + } + return ResultF; + } + // NaN, INF, or Range error + if (Ix < 0x7f800000) { // Range error + if (Sign) { + ResultF = + Underflow32(0); // raise underflow+inexact, return +0/+MinSub + //__libm_error_support (&x, &x, &ResultF, exp2f_underflow); + return ResultF; + } else { + ResultF = + Overflow32(0); // raise overflow+inexact, return +INF/+MaxNorm + //__libm_error_support (&x, &x, &ResultF, exp2f_overflow); + return ResultF; + } + } else { // NaN or INF + if (Ix == 0x7f800000) { // INF + return InfZero[Sign]; + } else { // NaN + return x + x; // raise invalid on SNaN + } + } +} Index: include/llvm/Transforms/IntrinToMathLib/ImlExpfTable.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/ImlExpfTable.h +++ include/llvm/Transforms/IntrinToMathLib/ImlExpfTable.h @@ -0,0 +1,91 @@ +//==- ImlExpfTable.h - Exponential functions interpolation table -*- C++ -*-==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file includes the exponential function interpolation table and was +/// placed here to avoid a dependency to the math library. +/// +// ===--------------------------------------------------------------------=== // +// +// const double __LibmExpfTable64[] +// Exponential functions interpolation table. +// +// Description: +// Let K = 64 (table size). +// j/K +// for integer j in [-K/2..K/2], values of 2 are tabulated as T[j]. + + +static const double __LibmExpfTable64[] = { + 0.707106781186547570 + ,0.714806669195985010 + ,0.722590403488523330 + ,0.730458897090323520 + ,0.738413072969749670 + ,0.746453864145632420 + ,0.754582213796711420 + ,0.762799075372269210 + ,0.771105412703970370 + ,0.779502200118918460 + ,0.787990422553943250 + ,0.796571075671133500 + ,0.805245165974627140 + ,0.814013710928673920 + ,0.822877739076982470 + ,0.831838290163368190 + ,0.840896415253714500 + ,0.850053176859261740 + ,0.859309649061238970 + ,0.868666917636853110 + ,0.878126080186649730 + ,0.887688246263260590 + ,0.897354537501553580 + ,0.907126087750199430 + ,0.917004043204671220 + ,0.926989562541692740 + ,0.937083817055149980 + ,0.947287990793482800 + ,0.957603280698573700 + ,0.968030896746147170 + ,0.978572062087700090 + ,0.989228013193975460 + ,1.000000000000000000 + ,1.010889286051700500 + ,1.021897148654116600 + ,1.033024879021228400 + ,1.044273782427413800 + ,1.055645178360557200 + ,1.067140400676823700 + ,1.078760797757119900 + ,1.090507732665257700 + ,1.102382583307840900 + ,1.114386742595892400 + ,1.126521618608241800 + ,1.138788634756691600 + ,1.151189229952982700 + ,1.163724858777577500 + ,1.176396991650281200 + ,1.189207115002721000 + ,1.202156731452703100 + ,1.215247359980469000 + ,1.228480536106870000 + ,1.241857812073484000 + ,1.255380757024691100 + ,1.269050957191733200 + ,1.282870016078778300 + ,1.296839554651009600 + ,1.310961211524764400 + ,1.325236643159741300 + ,1.339667524053302900 + ,1.354255546936892700 + ,1.369002422974590500 + ,1.383909881963832000 + ,1.398979672538311200 + ,1.414213562373095100 +}; Index: include/llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h +++ include/llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h @@ -0,0 +1,170 @@ +//==-- IntrinToMathLib.h - Class definition for IntrinToMathLib -*- C++ -*--==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file defines the class for transforming vector intrinsics to SVML +/// calls and scalar intrinsics to libm calls. +/// +// ===--------------------------------------------------------------------=== // + +#include "llvm/Transforms/IntrinToMathLib/ImlAccuracyInterface.h" +#include "llvm/Analysis/TargetLibraryInfo.h" +#include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Module.h" +#include "llvm/Pass.h" + +#ifndef LLVM_TRANSFORMS_INTRINTOMATHLIB_INTRINTOMATHLIB_H +#define LLVM_TRANSFORMS_INTRINTOMATHLIB_INTRINTOMATHLIB_H + +namespace llvm { + +namespace vpo { + +enum LoadStoreMode { + LSM_Scalar = 0, + LSM_UnitStride = 1, + LSM_NonUnitStride = 2, + LSM_Indirect = 3 // gather/scatter +}; + +class IntrinToMathLib : public FunctionPass { + +private: + /// Parent of Func. + Module *M; + + /// Current function being processed. + Function *Func; + + bool runOnFunction(Function &F) override; + + /// \brief Gets the name of a math library function from an LLVM intrinsic + /// name, which will be used for querying the IML accuracy interface. This + /// function returns true if the intrinsic is properly formed and can be + /// found as a LibFunc in TargetLibraryInfo. Properly formed intrinsics + /// begin with "llvm." and are followed by the function name and vector + /// type information which are separated by a '.'. E.g., llvm.sin.v4f32. + bool parseIntrinsicName(StringRef IntrinsicName, StringRef &FuncName, + TargetLibraryInfo *TLI); + + /// \brief For a given intrinsic \p II, try to find an equivalent math + /// library function to replace it with. + const char* findX86Variant(IntrinsicInst *II, Type *ElemType, + StringRef FuncName, unsigned TargetVL); + + /// \brief Add an IMF attribute to the attribute list. + void addAttributeToList(ImfAttr **List, ImfAttr **Tail, ImfAttr *Attr); + + /// \brief Delete all attributes from the IMF attribute list. + void deleteAttributeList(ImfAttr **List); + + /// \brief Determines if a StringRef representation of an IMF attribute is + /// legal. + bool isValidIMFAttribute(std::string AttrName); + + /// \brief Returns the number of registers that must be used for a value + /// with a bit width of \p TypeBitWidth and logical vector length of + /// \p LogicalVL. + /// Also returns the target vector length in TargetVL. + unsigned calculateNumReturns(TargetTransformInfo *TTI, unsigned TypeBitWidth, + unsigned LogicalVL, unsigned *TargetVL); + + /// \brief Split the function call parameters into pseudo-registers the size + /// corresponding to the legal target vector length. + void splitArgs(SmallVectorImpl &Args, + SmallVectorImpl> &NewArgs, + unsigned NumRet, unsigned TargetVL); + + /// \brief Build a linked list of IMF attributes used to query the IML + /// accuracy interface. + void createImfAttributeList(IntrinsicInst *II, ImfAttr **List); + + /// \brief Performs type legalization on parameter arguments and inserts the + /// legally typed math function declaration. + FunctionType *legalizeFunctionTypes(FunctionType *FT, + SmallVectorImpl &Args, + unsigned TargetVL, LibFunc::Func &LF); + + /// \brief Generates \p NumRet number of call instructions to the math + /// function and inserts them into \p Calls. \p Args are the arguments used + /// for the call instructions. + void generateMathLibCalls(unsigned NumRet, Constant *Func, + SmallVectorImpl> &Args, + SmallVectorImpl &Calls, + Instruction **InsertPt); + + /// \brief For multiple math library call cases, combine all of the result + /// vectors of the target vector length into a single vector of the logical + /// vector length. + Instruction *combineCallResults(unsigned NumRet, + SmallVectorImpl &WorkList, + Instruction **InsertPt); + + /// \brief Add the AlwaysInline attribute to the function call. + void addAlwaysInlineAttribute(CallInst *CI); + + /// \brief Finds the stride attribute for the call argument and returns + /// the type of load/store needed for code gen. This function also returns + /// the StringRef for the stride value through the \p AttrValStr reference. + LoadStoreMode getLoadStoreModeForArg(AttributeSet &AS, unsigned ArgNo, + StringRef &AttrValStr); + + /// \brief Generate the store for the X86 __svml_sincos variant based on the + /// memory reference pattern passed via argument attributes on the intrinsic + /// call (VectorIntrin). + void generateSinCosStore(IntrinsicInst *VectorIntrin, + Instruction *ResultVector, unsigned NumElemsToStore, + unsigned TargetVL, unsigned StorePtrIdx, + Instruction **InsertPt); + + /// \brief Duplicate low order elements of a smaller vector into a larger + /// vector. + void generateNewArgsFromPartialVectors(IntrinsicInst *II, FunctionType *FT, + unsigned TargetVL, + SmallVectorImpl &NewArgs, + Instruction **InsertPt); + + /// \brief Extracts NumElems from vector register \p Vector and returns an + /// extract instruction. + Instruction *extractElemsFromVector(Value *Vector, unsigned StartPos, + unsigned NumElems); + + /// \brief Checks if both types are vectors and if \p ValType width is less + /// than \p LegalType width. If yes, the function returns true. + bool isLessThanFullVector(Type *ValType, Type *LegalType); + + /// \brief Returns the largest vector type represented in the intrinsic + /// signature. + VectorType *getIntrinsicType(IntrinsicInst *Intrin); + + /// \brief Generate VL calls to the scalar library version of the function. + void scalarizeVectorIntrinsic(IntrinsicInst *II, StringRef LibFuncName, + unsigned VL, Type *ElemType); + + /// \brief Returns true if the library function is a sincos variant. + bool isSinCosVariant(LibFunc::Func LF); + +public: + static char ID; + + IntrinToMathLib(); + + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addRequired(); + AU.addRequired(); + } + +}; // end pass class +} // end vpo namespace + +FunctionPass *createIntrinToMathLibPass(); +} // end llvm namespace + +#endif // LLVM_TRANSFORMS_INTRINTOMATHLIB_MAPINTRINTOIML_H Index: include/llvm/Transforms/IntrinToMathLib/Messaging.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/Messaging.h +++ include/llvm/Transforms/IntrinToMathLib/Messaging.h @@ -0,0 +1,27 @@ +//==-- Messaging.h - Debug interface for math library searching -*- C++ -*--==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file defines the interface for debug printing when searching for math +/// functions. +/// +// ===--------------------------------------------------------------------=== // + +#include "llvm/Support/Debug.h" +#include "llvm/Support/raw_ostream.h" +#include + +using namespace llvm; + +#ifndef LLVM_TRANSFORMS_INTRINTOMATHLIB_MESSAGING_H +#define LLVM_TRANSFORMS_INTRINTOMATHLIB_MESSAGING_H + +#define PRN_MSG(...) DEBUG(printf(__VA_ARGS__)) + +#endif // LLVM_TRANSFORMS_INTRINTOMATHLIB_MESSAGING_H Index: include/llvm/Transforms/IntrinToMathLib/Search.h =================================================================== --- include/llvm/Transforms/IntrinToMathLib/Search.h +++ include/llvm/Transforms/IntrinToMathLib/Search.h @@ -0,0 +1,36 @@ +//===----- Search.h - Interface for math library name string -*- C++ -*----===// +// searching. +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +// ===--------------------------------------------------------------------=== // +/// +/// \file +/// This file defines methods that are used to search various arrays for math +/// library function names. +/// +// ===--------------------------------------------------------------------=== // + +#ifndef LLVM_TRANSFORMS_INTRINTOMATHLIB_SEARCH_H +#define LLVM_TRANSFORMS_INTRINTOMATHLIB_SEARCH_H + +#if defined __cplusplus +extern "C" { +#endif // __cplusplus + +int imlAttrGetNameIndex(const char* Name, const char* WhereToSearch[], + int max_size); + +int imlAttrGetNameIndexUnsorted(const char* Name, const char* WhereToSearch[], + int MaxSize); + +int imlAttrGetIntIndex(const int Name, const int* WhereToSearch, int MaxSize); + +#if defined __cplusplus +} +#endif // __cplusplus + +#endif // LLVM_TRANSFORMS_INTRINTOMATHLIB_SEARCH_H Index: lib/Transforms/CMakeLists.txt =================================================================== --- lib/Transforms/CMakeLists.txt +++ lib/Transforms/CMakeLists.txt @@ -6,3 +6,4 @@ add_subdirectory(Vectorize) add_subdirectory(Hello) add_subdirectory(ObjCARC) +add_subdirectory(IntrinToMathLib) Index: lib/Transforms/IPO/LLVMBuild.txt =================================================================== --- lib/Transforms/IPO/LLVMBuild.txt +++ lib/Transforms/IPO/LLVMBuild.txt @@ -20,4 +20,4 @@ name = IPO parent = Transforms library_name = ipo -required_libraries = Analysis Core InstCombine IRReader Linker Object ProfileData Scalar Support TransformUtils Vectorize Instrumentation +required_libraries = Analysis Core InstCombine IRReader Linker Object ProfileData Scalar Support TransformUtils Vectorize Instrumentation IntrinToMathLib Index: lib/Transforms/IPO/PassManagerBuilder.cpp =================================================================== --- lib/Transforms/IPO/PassManagerBuilder.cpp +++ lib/Transforms/IPO/PassManagerBuilder.cpp @@ -37,6 +37,7 @@ #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar/GVN.h" #include "llvm/Transforms/Vectorize.h" +#include "llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h" using namespace llvm; @@ -104,6 +105,10 @@ cl::desc( "Enable the GlobalsModRef AliasAnalysis outside of the LTO pipeline.")); +static cl::opt RunIntrinToMathLib("enable-intrin-to-mathlib", + cl::init(false), cl::Hidden, + cl::desc("Translate math intrinsics to math library calls.")); + static cl::opt EnableLoopLoadElim( "enable-loop-load-elim", cl::init(true), cl::Hidden, cl::desc("Enable the LoopLoadElimination Pass")); @@ -573,6 +578,11 @@ MPM.add(createMergeFunctionsPass()); addExtensionsToPM(EP_OptimizerLast, MPM); + + // This pass translates math intrinsics to math library calls. + if (RunIntrinToMathLib) { + MPM.add(createIntrinToMathLibPass()); + } } void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) { Index: lib/Transforms/IntrinToMathLib/CMakeLists.txt =================================================================== --- lib/Transforms/IntrinToMathLib/CMakeLists.txt +++ lib/Transforms/IntrinToMathLib/CMakeLists.txt @@ -0,0 +1,6 @@ +add_llvm_library(LLVMIntrinToMathLib + IntrinToMathLib.cpp + ImlAccuracyInterface.cpp + Search.cpp) + +add_dependencies(LLVMIntrinToMathLib intrinsics_gen) Index: lib/Transforms/IntrinToMathLib/ImlAccuracyInterface.cpp =================================================================== --- lib/Transforms/IntrinToMathLib/ImlAccuracyInterface.cpp +++ lib/Transforms/IntrinToMathLib/ImlAccuracyInterface.cpp @@ -0,0 +1,1362 @@ +//==---- ImlAccuracyInterface.cpp - compiler/library interface -*- C++ -*---==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Compiler/library interface that is supposed to pass queries to the library +/// and return function names appropriate for the query. +// +// ===--------------------------------------------------------------------=== // + +#include "llvm/Transforms/IntrinToMathLib/ImlAccuracyInterface.h" +#include "llvm/Transforms/IntrinToMathLib/ImlAttrPrivate.h" +#include "llvm/Transforms/IntrinToMathLib/Messaging.h" +#include "llvm/Transforms/IntrinToMathLib/Search.h" +#include +#include + +#define DEBUG_TYPE "ImlAccuracyInterface" + +#if defined __cplusplus +extern "C" { +#endif // __cplusplus + +// This should be equal to +// SUPPORTED_ACCURACIES_NUMBER*SUPPORTED_CONFIGURATIONS_NUMBER +#define SUPPORTED_VARIANTS_NUMBER 4 + +// Macros to simplify navigation in LibmDescriptionTable +#define LibmFuncNameStr(FunctionId) LibmDescriptionTable[FunctionId][0] +#define LibmFuncPrecisionStr(FunctionId) \ + LibmDescriptionTable[FunctionId][1] +#define LibmFuncVariantStr(FunctionId, Variant) \ + LibmDescriptionTable[(FunctionId)][2 + (Variant)] + +#define InlineFuncNameStr(FunctionId) \ + InlineDescriptionTable[FunctionId][0] +#define InlineFuncPrecisionStr(FunctionId) \ + InlineDescriptionTable[FunctionId][1] + +// Defines precision levels: +// +// AE_AccuracyLow : not greater than 4 ulps +// AE_AccuracyEnhancedPerformance : not greater than 2^12 for single or +// 2^26 for double ulps +// AE_AccuracyBitwiseReproducible : not greater than 0.6 ulps for all CPU +// configurations +// AE_AccuracyHigh : not greater than 0.6 ulps +// AE_AccuracyCorrectlyRounded : 0.5 ulps +// +// note: update in sync with the LibmDescriptionTable +// +typedef enum { + AE_AccuracyLow = 0, + AE_AccuracyEnhancedPerformance, + AE_AccuracyBitwiseReproducible, + AE_AccuracyHigh, + AE_AccuracyCorrectlyRounded, + SUPPORTED_ACCURACIES_NUMBER +} AccuracyEnum; + +#if 0 +static const char* ValidAccuracyNames[] = +{ + "la", "ep", "br", "ha", "cr" +}; +#endif + +// Note: here we maintain ordered list of accuracies, for ease of compares: +// AccuracyVector[AE_AccuracyEnhancedPerformance] < +// AccuracyVector[AE_AccuracyHigh] +// This is done for the sole purpose of not re-arranging the library +// description table. Should be removed in the future. +static const int AccuracyVector[SUPPORTED_ACCURACIES_NUMBER] = {1, 0, 3, 2, 4}; + +typedef enum { + PE_PrecisionUnsupported = -1, + PE_PrecisionSingle = 0, + PE_PrecisionDouble, + PE_PrecisionLongDouble, + PE_PrecisionQuad, + PE_PrecisionSignedChar, + PE_PrecisionUnsignedChar, + PE_PrecisionSignedShort, + PE_PrecisionUnsignedShort, + PE_PrecisionSignedInt, + PE_PrecisionUnsignedInt, + PE_PrecisionSignedLongLong, + PE_PrecisionUnsignedLongLong, + PE_PrecisionSingleComplex, + PE_PrecisionDoubleComplex, + PE_PrecisionLongDoubleComplex, + PE_PrecisionQuadComplex +} PrecisionEnum; + +static const char *ValidPrecisionNames[] = { + "unsupported", "single", "double", + "long_double", "quad", "signed_char", + "unsigned_char", "signed_short", "unsigned_short", + "signed_int", "unsigned_int", "signed_longlong", + "unsigned_longlong", "single_complex", "double_complex", + "long_double_complex", "quad_complex"}; + +// This list contains all currently supported +// configurations in text and enumerations representations. +// Note: this list must be in sync with the ValidConfigurationsNames list +typedef enum { + CE_ConfigurationUnsupported = -1, + CE_ConfigurationAll = 0, + CE_ConfigurationP3 = 1, + CE_ConfigurationP4 = 2, + CE_ConfigurationKnf, + CE_ConfigurationKnc, + SUPPORTED_CONFIGURATIONS_NUMBER +} ConfigurationsEnum; + +// Note: this list is assumed unsorted +static const char *ValidConfigurationsNames[SUPPORTED_CONFIGURATIONS_NUMBER] = + {"all", "p3", "p4", "knf", "knc"}; + +// This structure contains all possible information +// on the function. It replaces text specification with +// the enumerated descriptors. +typedef struct { + const char *ParentFunctionName; + const char *VariantFunctionName; + // Here are the attributes of function itself: + // e.g. sin is the first function in the library, + // it has double precision. + + // function position in LibmDescriptionTable + int Index; + // function precision + PrecisionEnum Precision; + + // Below are dynamic attributes: the ones that + // may vary. E.g. one may request a certain function + // but in different accuracy flavors, or optimized + // for different processor (e.g. configuration). + + // requested accuracy + AccuracyEnum Accuracy; + // requested configuration + ConfigurationsEnum Configuration; + // requested relative error + float UlpError; + // requested absolute error + float AbsoluteError; + // requested accurate bits + float AccurateBits; + // flag 1 if restricted domain requested, 0 otherwise + int DomainExclusion; + // flag 1 if arch consistency requested, 0 otherwise + int ArchConsistency; + // flag 1 if correcly set status bits requested, 0 otherwise + int ValidStatusBits; + +} FunctionDescriptionType; + +// This list contains all currently supported +// attributes in text and enumerations representations. +// Note: this list must be in sync with the ValidAttributesNames list +typedef enum { + FAE_AttributeAbsoluteError = 0, + FAE_AttributeAccurateBits, + FAE_AttributeAccurateBits128, + FAE_AttributeAccurateBits32, + FAE_AttributeAccurateBits64, + FAE_AttributeAccurateBits80, + FAE_AttributeBitwiseConsistency, + FAE_AttributeConfiguration, + FAE_AttributeDomainExclusion, + FAE_AttributeRelativeError, + FAE_AttributePrecision, + FAE_AttributeValidStatusBits, + SUPPORTED_ATTRIBUTES_NUMBER +} FunctionAttributeEnum; + +// Note: this list must be !sorted! +static const char *ValidAttributesNames[SUPPORTED_ATTRIBUTES_NUMBER] = { + "absolute-error", // 0 + "accuracy-bits", // 1 + "accuracy-bits-128", // 2 + "accuracy-bits-32", // 3 + "accuracy-bits-64", // 4 + "accuracy-bits-80", // 5 + "arch-consistency", // 6 + "configuration", // 7 + "domain-exclusion", // 8 + "max-error", // 9 + "precision", // 10 + "valid-status-bits" // 11 +}; + +typedef union { + float FloatVal; + double DoubleVal; + int IntVal; + long LongVal; + const char *StringVal; + void *PointerVal; +} AllTypesUnion; + +typedef struct { + FunctionAttributeEnum AttributeName; + AllTypesUnion AttributeValue; +} FunctionAttributeType; + +#define _ImlAttrSizeofTable(__table) \ + (int)(sizeof(__table) / sizeof(__table[0])) + +// LIBM library description table in short format +// TODO: Can probably eliminate the iml_table_ocl.inc reference, but verify +// before enabling scalar math call transformations. + +static const char *LibmDescriptionTable[][2 + SUPPORTED_VARIANTS_NUMBER] = { +#if (defined IML_OCLSVML_BUILD) +#include "iml_table_ocl.inc" +#else +// TODO: add support for libm lookups. +//#include "ImlTableLibm.inc" +{ "no_func", "n", "no_func_variant" } +#endif +}; + +static const int LibmFunctionsNum = + _ImlAttrSizeofTable(LibmDescriptionTable); + +// Inline library description table in short format +static const char *InlineDescriptionTable[][2] = { +#include "ImlTableInline.inc" +}; + +static const int InlineFunctionsNum = + _ImlAttrSizeofTable(InlineDescriptionTable); + +// SVML library description table in full format. +// TODO: Create TableGen backend to build this table. +static FunctionDescriptionType FunctionDescriptionTable[] = { +#include "ImlTableSvmlIA32.inc" +}; +static const int SvmlFunctionsNum = + _ImlAttrSizeofTable(FunctionDescriptionTable); + +// exp2f implementation included here to avoid dependency on math library +#include "llvm/Transforms/IntrinToMathLib/ImlExp2f.h" + +#if 0 +static const char* attrGetAccuracyName(AccuracyEnum a) { + return ValidAccuracyNames[a]; +} +#endif + +static const char *attrGetConfigName(ConfigurationsEnum CE) { + if (CE == CE_ConfigurationUnsupported) + return "unsupported"; + else + return ValidConfigurationsNames[CE]; +} + +// This function converts a floating point quantity representing a number of +// correct mantissa bits into the error estimate measured in ulps. Mantissa +// width, needed to perform this conversion correctly, is derived based on +// Precision parameter. + +static float attrBits2Ulps(float Bits, PrecisionEnum Precision) { + + float Prec, Ulps; + + switch (Precision) { + case PE_PrecisionSingle: + case PE_PrecisionSingleComplex: + Prec = 24.0f; + break; + case PE_PrecisionDouble: + case PE_PrecisionDoubleComplex: + Prec = 53.0f; + break; + case PE_PrecisionLongDouble: + case PE_PrecisionLongDoubleComplex: + Prec = 64.0f; + break; + case PE_PrecisionQuad: + case PE_PrecisionQuadComplex: + Prec = 113.0f; + break; + default: // nonsense + PRN_MSG("%-32s: [warning] for given precision ulps are meaningless\n", + "attrBits2Ulps"); + return 0.0; + } + + // b = p - 1 - log2(u) + Ulps = imlAttrExp2f(Prec - 1.0f - Bits); + return Ulps; +} + +// This function translates the precision string into precision enumeration +// based on the first letter. + +static PrecisionEnum attrMapPrecisionStr2Enum(const char *StringPrecision) { + + if (StringPrecision[0] == 's') + return PE_PrecisionSingle; + + if (StringPrecision[0] == 'd') + return PE_PrecisionDouble; + + if (StringPrecision[0] == 'c') + return PE_PrecisionSingleComplex; + + if (StringPrecision[0] == 'z') + return PE_PrecisionDoubleComplex; + + if (StringPrecision[0] == 'i') + return PE_PrecisionSignedInt; + + if (StringPrecision[0] == 'u') + return PE_PrecisionUnsignedInt; + + if (StringPrecision[0] == 'l') + return PE_PrecisionLongDouble; + + if (StringPrecision[0] == 'q') + return PE_PrecisionQuad; + + if (StringPrecision[0] == 'x') + return PE_PrecisionLongDoubleComplex; + + if (StringPrecision[0] == 'w') + return PE_PrecisionQuadComplex; + + return PE_PrecisionUnsupported; +} + +// This function inits the function_description structure +static int +attrInitFuncDescription(FunctionDescriptionType *FunctionDescription) { + + if (FunctionDescription == nullptr) { + PRN_MSG("%-32s: [ERROR] in attrInitFuncDescription: passed NULL pointer\n", + "attrInitFuncDescription"); + return -1; + } + + FunctionDescription->ParentFunctionName = nullptr; + FunctionDescription->VariantFunctionName = nullptr; + FunctionDescription->Index = -1; + FunctionDescription->Precision = PE_PrecisionUnsupported; + FunctionDescription->Accuracy = AE_AccuracyCorrectlyRounded; + FunctionDescription->Configuration = CE_ConfigurationAll; + FunctionDescription->UlpError = -3.14f; + FunctionDescription->AccurateBits = -1.57f; + FunctionDescription->AbsoluteError = -6.28f; + FunctionDescription->DomainExclusion = -1; + FunctionDescription->ArchConsistency = 0; + FunctionDescription->ValidStatusBits = 0; + + return 0; +} + +// This function converts a pair of strings attribute name-value +// into internal attribute structure representation. +static int attrExternal2InternalAttr(FunctionAttributeType *InternalAttribute, + const ImfAttr *ExternalAttribute) { + int Flag = 0; + const char *AName = nullptr; + int AttrChosen = 0; + + // search internal_attribute name within allowed names + Flag = + imlAttrGetNameIndex(ExternalAttribute->Name, ValidAttributesNames, + SUPPORTED_ATTRIBUTES_NUMBER); + if (Flag < 0) { + PRN_MSG("%-32s: [ERROR] internal_attribute name \"%s\" wasn't found \n", + "attrExternal2InternalAttr", ExternalAttribute->Name); + } + + InternalAttribute->AttributeName = (FunctionAttributeEnum)Flag; + + switch (InternalAttribute->AttributeName) { + case FAE_AttributeConfiguration: + AName = "c_attribute_configuration"; + Flag = imlAttrGetNameIndexUnsorted(ExternalAttribute->Value, + ValidConfigurationsNames, + SUPPORTED_CONFIGURATIONS_NUMBER); + if (Flag < 0) { + PRN_MSG("%-32s: [failure] configuration value \"%s\" wasn't found \n", + "attrExternal2InternalAttr", ExternalAttribute->Value); + } + + InternalAttribute->AttributeValue.IntVal = Flag; + PRN_MSG("%-32s: \tattribute %s = %d \n", "attrExternal2InternalAttr", AName, + InternalAttribute->AttributeValue.IntVal); + break; + + case FAE_AttributeAccurateBits32: + AName = "c_attribute_accurate_bits_32"; + AttrChosen = 1; + case FAE_AttributeAccurateBits64: + if (!AttrChosen) { + AName = "c_attribute_accurate_bits_64"; + AttrChosen = 1; + } + case FAE_AttributeAccurateBits80: + if (!AttrChosen) { + AName = "c_attribute_accurate_bits_80"; + AttrChosen = 1; + } + case FAE_AttributeAccurateBits128: + if (!AttrChosen) { + AName = "c_attribute_accurate_bits_128"; + AttrChosen = 1; + } + case FAE_AttributeAccurateBits: + if (!AttrChosen) { + AName = "c_attribute_accurate_bits"; + AttrChosen = 1; + } + case FAE_AttributeAbsoluteError: + if (!AttrChosen) { + AName = "c_attribute_absolute_error"; + AttrChosen = 1; + } + case FAE_AttributeRelativeError: + if (!AttrChosen) { + AName = "c_attribute_relative_error"; + AttrChosen = 1; + } + + InternalAttribute->AttributeValue.FloatVal = + (float)atof(ExternalAttribute->Value); + PRN_MSG("%-32s: \tattribute %s = %g \n", "attrExternal2InternalAttr", AName, + InternalAttribute->AttributeValue.FloatVal); + break; + + case FAE_AttributeDomainExclusion: + AName = "c_attribute_domain_exclusion"; + InternalAttribute->AttributeValue.IntVal = + atoi(ExternalAttribute->Value); + PRN_MSG("%-32s: \tattribute %s = %d \n", "attrExternal2InternalAttr", AName, + InternalAttribute->AttributeValue.IntVal); + break; + + case FAE_AttributeBitwiseConsistency: + AName = "c_attribute_bitwise_consistency"; + AttrChosen = 1; + case FAE_AttributeValidStatusBits: + if (!AttrChosen) { + AName = "c_attribute_valid_status_bits"; + } + InternalAttribute->AttributeValue.IntVal = + (!strcmp(ExternalAttribute->Value, "true")) + ? 1 + : 0; // assuming false even if garbage input + PRN_MSG("%-32s: \tattribute %s = %d \n", "attrExternal2InternalAttr", AName, + InternalAttribute->AttributeValue.IntVal); + break; + + case FAE_AttributePrecision: + InternalAttribute->AttributeValue.StringVal = ExternalAttribute->Value; + PRN_MSG("%-32s: \tattribute c_attribute_precision = \"%s\" \n", + "attrExternal2InternalAttr", + InternalAttribute->AttributeValue.StringVal); + break; + + default: // not supported internal_attribute + break; + } + + return 0; +} + +// This function checks which attribute is being set and what kind of value is +// being assigned to it. Function fills in the function_description structure +// accordingly. +static int +attrUpdateFuncDescription(FunctionDescriptionType *FunctionDescription, + FunctionAttributeType *InternalAttribute) { + float ErrorValue; + float HaThreshold, LaThreshold, EpThreshold; + + // store function precision + PrecisionEnum WorkingPrecision = FunctionDescription->Precision; + + // store current internal_attribute name + FunctionAttributeEnum CurrentAttributeName = InternalAttribute->AttributeName; + + // set the relative error thresholds + HaThreshold = 0.6f; + LaThreshold = 4.0f; + + // AE_AccuracyEnhancedPerformance gives 11 and 26 correct bits for + // single/double precisions. Other precisions do not have this mode, + // so we place 5.0ulp just to have more than 4.0 LA. + switch (WorkingPrecision) { + case PE_PrecisionSingle: + EpThreshold = attrBits2Ulps(11, WorkingPrecision); + break; + case PE_PrecisionDouble: + EpThreshold = attrBits2Ulps(26, WorkingPrecision); + break; + default: + EpThreshold = 5.0f; + } + + // precision internal_attribute is different and is processed separately + if (CurrentAttributeName == FAE_AttributePrecision) { + if (!strcmp(InternalAttribute->AttributeValue.StringVal, "high")) { + // between high and low, so that high is selected + InternalAttribute->AttributeValue.FloatVal = + (LaThreshold + HaThreshold) / 2.0f; + } else if (!strcmp(InternalAttribute->AttributeValue.StringVal, "medium")) { + InternalAttribute->AttributeValue.FloatVal = LaThreshold; + } else if (!strcmp(InternalAttribute->AttributeValue.StringVal, "low")) { + InternalAttribute->AttributeValue.FloatVal = EpThreshold; + // low precision setting also must cause restricted domain + // this is not documented. commenting out. + // function_description->DomainExclusion = -1; + } else // unsupported input + { + PRN_MSG("%-32s: [warning] InternalAttribute c_attribute_precision " + "value: \"%s\" is unsupported and ignored\n", + "attrUpdateFuncDescription", + InternalAttribute->AttributeValue.StringVal); + return 0; + } + + // proceed with general scheme for relative error processing + CurrentAttributeName = FAE_AttributeRelativeError; + } + + // search internal_attribute value within allowed for a particular + // AttributeName + switch (CurrentAttributeName) { + case FAE_AttributeConfiguration: + // check if requested configuration is supported + // and update function_description accordingly. + if ((InternalAttribute->AttributeValue.IntVal >= + SUPPORTED_CONFIGURATIONS_NUMBER) || + (InternalAttribute->AttributeValue.IntVal < 0)) { + // set generic configuration if requested configuration is invalid + FunctionDescription->Configuration = CE_ConfigurationAll; + } else { + FunctionDescription->Configuration = + (ConfigurationsEnum)InternalAttribute->AttributeValue.IntVal; + } + break; + + case FAE_AttributeAccurateBits32: + case FAE_AttributeAccurateBits64: + case FAE_AttributeAccurateBits80: + case FAE_AttributeAccurateBits128: + if ( + // guard against precision mismatch + ((CurrentAttributeName == FAE_AttributeAccurateBits32) && + (WorkingPrecision != PE_PrecisionSingle) && + (WorkingPrecision != PE_PrecisionSingleComplex)) || + ((CurrentAttributeName == FAE_AttributeAccurateBits64) && + (WorkingPrecision != PE_PrecisionDouble) && + (WorkingPrecision != PE_PrecisionDoubleComplex)) || + ((CurrentAttributeName == FAE_AttributeAccurateBits80) && + (WorkingPrecision != PE_PrecisionLongDouble) && + (WorkingPrecision != PE_PrecisionLongDoubleComplex)) || + ((CurrentAttributeName == FAE_AttributeAccurateBits128) && + (WorkingPrecision != PE_PrecisionQuad) && + (WorkingPrecision != PE_PrecisionQuadComplex))) { + PRN_MSG("%-32s: [warning] InternalAttribute ignored due to function " + "precision mismatch\n", + "attrUpdateFuncDescription"); + break; + } + + case FAE_AttributeAccurateBits: // proceed with general scheme for accurate + // bits + // store number of accurate bits for future processing + FunctionDescription->AccurateBits = + InternalAttribute->AttributeValue.FloatVal; + + // Note the name change: we convert internal_attribute from + // bits to relative error. + InternalAttribute->AttributeName = FAE_AttributeRelativeError; + // convert bits into relative error + InternalAttribute->AttributeValue.FloatVal = + attrBits2Ulps(InternalAttribute->AttributeValue.FloatVal, + WorkingPrecision); + PRN_MSG("%-32s: %.1g accurate bits converted to %g ulp value\n", + "attrUpdateFuncDescription", FunctionDescription->AccurateBits, + InternalAttribute->AttributeValue.FloatVal); + + case FAE_AttributeRelativeError: // proceed with relative error + // Guard against changing accuracy in case + // FAE_AttributeBitwiseConsistency was previously + // set to 1. + if (FunctionDescription->ArchConsistency == 1) { + PRN_MSG("%-32s: requested accuracy change is ignored due to previous " + "bitwise consistency request\n", + "attrUpdateFuncDescription"); + break; + } + + // based on requested relative error and function + // precision we decide which accuracy flavor + // is appropriate + + ErrorValue = InternalAttribute->AttributeValue.FloatVal; + +// isnan check implemented to avoid 3-rd party dependency +#define ImlAttrIsNanf(x) \ + ((((*((unsigned int *)&(x))) & 0x7fffffff) > 0x7f800000) ? 1 : 0) + + if (ImlAttrIsNanf(ErrorValue) || (ErrorValue < 0.0f)) { + // NaN value or negative + PRN_MSG("%-32s: [EERROR] requested accuracy is either NaN or negative\n", + "attrUpdateFuncDescription"); + break; + } + + // store requested relative error value for possible future + // processing + FunctionDescription->UlpError = ErrorValue; + + // classify requested relative error according to available + // HA/LA/EP variations + if ((ErrorValue >= 0.0f) && (ErrorValue < HaThreshold)) { + // correctly rounded + PRN_MSG("%-32s: \t[warning] requested " + "%f ulp accuracy which may be not possible, " + "selecting AE_AccuracyCorrectlyRounded instead\n", + "attrUpdateFuncDescription", ErrorValue); + FunctionDescription->Accuracy = AE_AccuracyCorrectlyRounded; + } else if (ErrorValue >= HaThreshold && ErrorValue < LaThreshold) { + // high accuracy + FunctionDescription->Accuracy = AE_AccuracyHigh; + } else if ((ErrorValue >= LaThreshold) && (ErrorValue < EpThreshold)) { + // low accuracy + FunctionDescription->Accuracy = AE_AccuracyLow; + } else if (ErrorValue >= EpThreshold) { + // very low accuracy + FunctionDescription->Accuracy = AE_AccuracyEnhancedPerformance; + } else { + // should not get here + PRN_MSG("%-32s: [ERROR] requested %f ulp accuracy not detected\n", + "attrUpdateFuncDescription", ErrorValue); + } + break; + + case FAE_AttributeBitwiseConsistency: + FunctionDescription->ArchConsistency = + InternalAttribute->AttributeValue.IntVal; + + if (InternalAttribute->AttributeValue.IntVal == 1) { + FunctionDescription->Accuracy = AE_AccuracyBitwiseReproducible; + } + break; + + case FAE_AttributeDomainExclusion: + FunctionDescription->DomainExclusion = + InternalAttribute->AttributeValue.IntVal; + break; + + case FAE_AttributeValidStatusBits: + FunctionDescription->ValidStatusBits = + InternalAttribute->AttributeValue.IntVal; + break; + + case FAE_AttributeAbsoluteError: + // Guard against changing accuracy in case + // FAE_AttributeBitwiseConsistency was previously + // set to 1. + if (FunctionDescription->ArchConsistency == 1) { + PRN_MSG("%-32s: requested accuracy change is ignored due to previous " + "bitwise consistency request\n", + "attrUpdateFuncDescription"); + break; + } + + ErrorValue = InternalAttribute->AttributeValue.FloatVal; + // store requested absolute error value for possible future + // processing. here we ignore this internal_attribute + FunctionDescription->AbsoluteError = ErrorValue; + + default: // not supported internal_attribute + PRN_MSG("%-32s: [ERROR] internal_attribute not supported\n", + "attrUpdateFuncDescription"); + break; + } + + return 0; +} + +// This function accesses LibmDescriptionTable and based on input +// function ID returns pointer to a string containing function precision +static const char *inlineGetFuncPrecisionString(int FunctionId) { + return InlineFuncPrecisionStr(FunctionId); +} + +// This function looks up the function precision in the +// LibmDescriptionTable and translates it into enumeration +static PrecisionEnum inlineGetFuncPrecision(int FunctionId) { + const char *StringPrecision = inlineGetFuncPrecisionString(FunctionId); + return attrMapPrecisionStr2Enum(StringPrecision); +} + +// this function performs a binary search over the column of strings +// and returns the index if the value is found +static int inlineGetNameIndex(const char *Name) { + int Left, Right, StrIdx, Direction; + if (!strcmp(Name, "")) { + PRN_MSG("%-32s: [ERROR] empty search token\n", "inlineGetNameIndex"); + return -1; + } + Left = 0; + Right = InlineFunctionsNum - 1; + while ((Right - Left) > 1) { + StrIdx = (Left + Right) / 2; + Direction = strcmp(Name, InlineFuncNameStr(StrIdx)); + if (Direction < 0) { + Right = StrIdx; + } else if (Direction > 0) { + Left = StrIdx; + } else if (Direction == 0) { + return StrIdx; + } + } + if (!strcmp(Name, InlineFuncNameStr(Left))) { + return Left; + } + if (!strcmp(Name, InlineFuncNameStr(Right))) { + return Right; + } + return -3; +} + +// This function accesses LibmDescriptionTable and based on input +// function ID returns pointer to a string containing function precision +static const char *libmGetFuncPrecisionString(int FunctionId) { + return LibmFuncPrecisionStr(FunctionId); +} + +// this function performs a binary search over the !sorted! column of strings +// and returns the index if the value is found +static int libmGetNameIndex(const char *Name) { + int Left, Right, StrIdx, Direction; + + if (!strcmp(Name, "")) { + PRN_MSG("%-32s: [ERROR] empty search token\n", "libmGetNameIndex"); + return -1; + } + +#ifdef DEBUG + { + // user should not suffer the penalty of this extra check + for (StrIdx = 0; StrIdx < LibmFunctionsNum - 1; StrIdx++) { + if (strcmp(LibmFuncNameStr(StrIdx), + LibmFuncNameStr(StrIdx + 1)) >= 0) { + PRN_MSG("%-32s: [ERROR] search space unsorted\n", "libmGetNameIndex"); + PRN_MSG("%-32s: [ERROR] %s >= %s\n", "libmGetNameIndex", + LibmFuncNameStr(StrIdx), LibmFuncNameStr(StrIdx + 1)); + return -2; + } + } + } +#endif + + Left = 0; + Right = LibmFunctionsNum - 1; + while ((Right - Left) > 1) { + StrIdx = (Left + Right) / 2; + Direction = strcmp(Name, LibmFuncNameStr(StrIdx)); + if (Direction < 0) { + Right = StrIdx; + } else if (Direction > 0) { + Left = StrIdx; + } else if (Direction == 0) { + return StrIdx; + } + } + + if (!strcmp(Name, LibmFuncNameStr(Left))) { + return Left; + } + if (!strcmp(Name, LibmFuncNameStr(Right))) { + return Right; + } + + // TODO: maybe insert unsorted search: just in case... + PRN_MSG("%-32s: [failure] token \"%s\" not found\n", "libmGetNameIndex", + Name); + return -3; +} + +// This function accesses LibmDescriptionTable and based on input +// function ID and function variant number returns pointer to a string +// containing appropriate function variant name +static const char *libmGetVariantName(int FunctionId, int Variant) { + const char *Pstr = nullptr; + + // Guard against wrong queries + if ((FunctionId < 0 || FunctionId >= LibmFunctionsNum) || + (Variant < 0 || Variant >= SUPPORTED_VARIANTS_NUMBER)) { + PRN_MSG("%-32s: [ERROR] invalid query (id = %d, variant = %d)\n", + "libmGetVariantName", FunctionId, Variant); + return nullptr; + } + + Pstr = LibmFuncVariantStr(FunctionId, Variant); + + // If the variant string is empty, return nullptr + if (!strcmp(Pstr, "")) { + return nullptr; + } + + return Pstr; +} + +// This function looks up the function precision in the +// LibmDescriptionTable and translates it into enumeration +static PrecisionEnum libmGetFuncPrecision(int FunctionId) { + const char *StringPrecision = libmGetFuncPrecisionString(FunctionId); + return attrMapPrecisionStr2Enum(StringPrecision); +} + +static int svmlGetFuncVariantsNum(const char *FuncBaseName, + const FunctionDescriptionType *FunctionsList, + int FunctionsListLength, int *Length) { + int i, j; + *Length = -1; + + if (0 == strcmp(FuncBaseName, "")) { + PRN_MSG("%-32s: [ERROR] empty search token\n", "svmlGetFuncVariantsNum"); + return -1; + } + + for (i = 0; i < FunctionsListLength; i++) { + if (0 == strcmp(FuncBaseName, FunctionsList[i].ParentFunctionName)) { + for (j = i + 1; j < FunctionsListLength; j++) { + if (0 != + strcmp( + FuncBaseName, + FunctionsList[j].ParentFunctionName)) { // FunctionsList[j] + // has different base + // name + break; + } + } + *Length = j - i; + PRN_MSG( + "%-32s: Base name found at position = %d, numberf of variants = %d\n", + "svmlGetFuncVariantsNum", i, *Length); + return i; + } + } + + PRN_MSG("%-32s: [failure] token \"%s\" not found\n", "svmlGetFuncVariantsNum", + FuncBaseName); + return -2; +} + +static int svmlGetFuncVariantsList(FunctionDescriptionType **FunctionsList, + const char *FuncBaseName, + FunctionDescriptionType *FunctionsTable, + int FunctionsTableLength) { + int Start = -1; + int Length = -1; + + Start = svmlGetFuncVariantsNum(FuncBaseName, FunctionsTable, + FunctionsTableLength, &Length); + if ((Start >= 0) && (Length > 0)) { + *FunctionsList = (FunctionDescriptionType *)FunctionsTable + Start; + return Length; + } + + PRN_MSG("%-32s: [failure] token \"%s\" not found\n", + "svmlGetFuncVariantsList", FuncBaseName); + return -1; +} + +// This function returns 1 or 0 meaning "yes" or "no". It answers the question: +// whether the compiler may use an instructions sequence with certain +// properties described by function_description_compiler +// under conditions specified by function_description_user. +static int svmlMatchFuncDescriptions( + const FunctionDescriptionType FunctionDescriptionUser, + const FunctionDescriptionType FunctionDescriptionCompiler) { + // Here we will walk over all function description fields and + // do the matching. + + // this is dummy for now + PRN_MSG("%-32s: \tconfiguration check : requested \"%s\", suggested \"%s\": ", + "svmlMatchFuncDescriptions", + attrGetConfigName(FunctionDescriptionUser.Configuration), + attrGetConfigName(FunctionDescriptionCompiler.Configuration)); + + if (FunctionDescriptionUser.Configuration > + FunctionDescriptionCompiler.Configuration) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } + +#if 0 + PRN_MSG("%-32s: \taccuracy check : requested \"%s\" (%d), suggested \"%s\"\ + (%d): ","svmlMatchFuncDescriptions", + attrGetAccuracyName(FunctionDescriptionUser.Accuracy), + AccuracyVector[FunctionDescriptionUser.Accuracy], + attrGetAccuracyName(FunctionDescriptionCompiler.Accuracy), + AccuracyVector[FunctionDescriptionCompiler.Accuracy]); + + if (AccuracyVector[FunctionDescriptionUser.Accuracy] > + AccuracyVector[FunctionDescriptionCompiler.Accuracy]) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } +#endif + +#if 0 + // + // Temporarily disable this part since we don't initialize this variable if + // only a "max-error" attribute comes (no bits attributes). + // + PRN_MSG("%-32s: \taccurate bits check : requested %f, suggested %f: ",\ + "svmlMatchFuncDescriptions", FunctionDescriptionUser.AccurateBits, + FunctionDescriptionCompiler.AccurateBits); + + if (FunctionDescriptionUser.AccurateBits > + FunctionDescriptionCompiler.AccurateBits) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } +#endif + + // relative and absolute error + PRN_MSG("%-32s: \trelative error check : requested %f, suggested %f: ", + "svmlMatchFuncDescriptions", FunctionDescriptionUser.UlpError, + FunctionDescriptionCompiler.UlpError); + if (FunctionDescriptionUser.UlpError < + FunctionDescriptionCompiler.UlpError) { + PRN_MSG("[failure]\n"); + +#if 0 + if (FunctionDescriptionCompiler.AbsoluteError < 0.0f) { + PRN_MSG("\t\t\t\t\n"); + PRN_MSG("\t\t\t\t\n"); + PRN_MSG("\t\t\t\t\n"); + return 0; + } + + PRN_MSG("%-32s: \tadditional absolute error check : requested %f,\ + suggested %f: ","svmlMatchFuncDescriptions", + FunctionDescriptionUser.AbsoluteError, + FunctionDescriptionCompiler.AbsoluteError); + + if (FunctionDescriptionUser.AbsoluteError < + FunctionDescriptionCompiler.AbsoluteError) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } +#else + return 0; +#endif + } + + PRN_MSG("[success]\n"); + + PRN_MSG("%-32s: \trestricted domain requirement check : requested %d, " + "suggested %d: ", "svmlMatchFuncDescriptions", + FunctionDescriptionUser.DomainExclusion, + FunctionDescriptionCompiler.DomainExclusion); + + if ((FunctionDescriptionUser.DomainExclusion | + FunctionDescriptionCompiler.DomainExclusion) != + FunctionDescriptionUser.DomainExclusion) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } + + PRN_MSG("%-32s: \tarch consistency requirement check : requested %d, " + "suggested %d: ", + "svmlMatchFuncDescriptions", + FunctionDescriptionUser.ArchConsistency, + FunctionDescriptionCompiler.ArchConsistency); + if (FunctionDescriptionUser.ArchConsistency > + FunctionDescriptionCompiler.ArchConsistency) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } + + PRN_MSG("%-32s: \tcorrectly set status bits requirement check : requested " + "%d, suggested %d: ", + "svmlMatchFuncDescriptions", + FunctionDescriptionUser.ValidStatusBits, + FunctionDescriptionCompiler.ValidStatusBits); + if (FunctionDescriptionUser.ValidStatusBits > + FunctionDescriptionCompiler.ValidStatusBits) { + PRN_MSG("[failure]\n"); + return 0; + } else { + PRN_MSG("[success]\n"); + } + + PRN_MSG("%-32s: ***** ALL REQUIREMENTS MATCH [success]\n", + "svmlMatchFuncDescriptions"); + return 1; +} + +//*****************************************************************************/ +//*****************************************************************************/ +//*****************************************************************************/ +// This function returns the name of the library function to call +// given the specified constraints. +// +// func_base_name +// is the name of the math function of interest, e.g. sin, expf +// +// external_attributes +// define desired constrains for the function. Attributes array is +// terminated by a pair with the nullptr attribute name. +//*****************************************************************************/ +//*****************************************************************************/ +//*****************************************************************************/ +const char *getLibraryFunctionName(const char *FuncBaseName, + const ImfAttr *ExternalAttributes) { + int i; + int IsSvml = 0; + int FunctionDescriptionCompilerVariantsNum = 0; + const char *ResultStringPointer = nullptr; + FunctionAttributeType InternalAttribute; // Storage for internal + // representation of current + // attribute + FunctionDescriptionType + FunctionDescriptionUser; // Storage for current function information + FunctionDescriptionType *FunctionDescriptionCompilerVariant; + + PRN_MSG("\n=================================\n"); + PRN_MSG("%-32s: [START] entered function\n", "getLibraryFunctionName"); + + if (FuncBaseName == nullptr) // Bad argument check + { + PRN_MSG("%-32s: [ERROR] FuncBaseName is NULL\n", "getLibraryFunctionName"); + return nullptr; + } else { + PRN_MSG("%-32s: FuncBaseName = \"%s\"\n", "getLibraryFunctionName", + FuncBaseName); + } + +/* Currently new table is only for non-LRB configs */ +// TODO: replace GFX macro with run-time target check, which can be inside the +// #if (!defined IML_OCLSVML_BUILD) check. +//#if (!defined GFX) && (!defined IML_OCLSVML_BUILD) + if (strstr(FuncBaseName, "svml")) { + IsSvml = 1; + } +//#endif + + // fill in the default values into the function description structure + attrInitFuncDescription(&FunctionDescriptionUser); + + if (IsSvml == 0) { + // Index in LibmDescriptionTable and find out the function number + FunctionDescriptionUser.Index = libmGetNameIndex(FuncBaseName); + if (FunctionDescriptionUser.Index < 0) { + PRN_MSG("%-32s: [ERROR] function name is invalid - not found in table " + "(id = %d)\n", + "getLibraryFunctionName", FunctionDescriptionUser.Index); + return nullptr; + } else { + PRN_MSG("%-32s: Function index = %d\n", "getLibraryFunctionName", + FunctionDescriptionUser.Index); + } + + // Read the function precision property from the LibmDescriptionTable + FunctionDescriptionUser.Precision = + libmGetFuncPrecision(FunctionDescriptionUser.Index); + } else { + // read the table and create an array of function descriptions + FunctionDescriptionCompilerVariantsNum = + svmlGetFuncVariantsList(&FunctionDescriptionCompilerVariant, + FuncBaseName, FunctionDescriptionTable, SvmlFunctionsNum); + + if (FunctionDescriptionCompilerVariantsNum < 1) { + PRN_MSG("%-32s: [FAILURE] function wasn't chosen\n", + "getLibraryFunctionName"); + PRN_MSG("=================================\n\n"); + return nullptr; + } + + FunctionDescriptionUser.Precision = + FunctionDescriptionCompilerVariant[0].Precision; + } + + // ========================================================================= + // If the function is integer, processing attributes doesn't make sense now, + // and default mechanizm will not initialize accuracy field correctly. + // We set accuracy variant to default (low) and proceed with the attributes + // processing just in case future attributes will apply. + // ========================================================================= + if ((FunctionDescriptionUser.Precision == PE_PrecisionSignedInt) || + (FunctionDescriptionUser.Precision == PE_PrecisionUnsignedInt)) { + FunctionDescriptionUser.Accuracy = AE_AccuracyLow; + PRN_MSG("%-32s: Function is integer, setting its accuracy to low %d\n", + "getLibraryFunctionName", FunctionDescriptionUser.Accuracy); + } + + PRN_MSG("%-32s: Func precision = %s\n", "getLibraryFunctionName", + ValidPrecisionNames[FunctionDescriptionUser.Precision + 1]); + + PRN_MSG("%-32s: User requested attributes:\n", "getLibraryFunctionName"); + // ========================================================================= + // Loop over external_attributes, convert external representation into + // internal enumerations, update the requested function description + // based on incoming attribute. + // ========================================================================= + while (ExternalAttributes != nullptr) { + attrExternal2InternalAttr(&InternalAttribute, ExternalAttributes); + attrUpdateFuncDescription(&FunctionDescriptionUser, &InternalAttribute); + ExternalAttributes = + ExternalAttributes->Next; // get next external attribute pointer + } + + if (IsSvml == 0) { + // ========================================================================= + // Here we presumably finished collecting user requests and classified them + // into the appropriate fields of the structure. Now we are ready to compute + // the index in T-tab and lookup the target function name. + // ========================================================================= + ResultStringPointer = + libmGetVariantName(FunctionDescriptionUser.Index, + FunctionDescriptionUser.Accuracy); + + PRN_MSG("%-32s: [SUCCESS] return \"%s\" function name\n", + "getLibraryFunctionName", ResultStringPointer); + PRN_MSG("=================================\n\n"); + return ResultStringPointer; + } else { + // loop over function descriptions and choose the fastest acceptable + // implementation + for (i = 0; i < FunctionDescriptionCompilerVariantsNum; i++) { + PRN_MSG("%-32s: Looking at \"%s\" variant:\n", "getLibraryFunctionName", + FunctionDescriptionCompilerVariant[i].VariantFunctionName); + if (svmlMatchFuncDescriptions( + FunctionDescriptionUser, + FunctionDescriptionCompilerVariant[i])) { // Assumption: the + // first matching + // implementation is + // the fastest + ResultStringPointer = + FunctionDescriptionCompilerVariant[i].VariantFunctionName; + + PRN_MSG("%-32s: [SUCCESS] return \"%s\" function name\n", + "getLibraryFunctionName", ResultStringPointer); + PRN_MSG("=================================\n\n"); + return ResultStringPointer; + } + } + + PRN_MSG("%-32s: [ERROR] function wasn't chosen\n", + "getLibraryFunctionName"); + PRN_MSG("=================================\n\n"); + + return nullptr; + } +} + +//*****************************************************************************/ +//*****************************************************************************/ +//*****************************************************************************/ +// This function returns 1 or 0 meaning "yes" or "no". It answers the question: +// whether the compiler may use an instructions sequence with certain +// properties described by ExternalAttributes_compiler list given the +// conditions specified by ExternalAttributes_user list. +// +// func_base_name +// is the name of the math function of interest, e.g. sin, expf. Actually +// it shall be used for the only purpose - determine precision property. +// +// ExternalAttributes_user +// define desired constrains for the function. Attributes array is +// terminated by a pair with the nullptr attribute name. +// +// ExternalAttributes_compiler +// define properties of some function implementation (presumably known to +// the compiler). Attributes array is terminated by a pair with the nullptr +// attribute name. +//*****************************************************************************/ +//*****************************************************************************/ +//*****************************************************************************/ +int mayIUseInlineImplementation(const char *FuncBaseName, + const ImfAttr *ExternalAttributesUser, + const ImfAttr *ExternalAttributesCompiler) { + // ========================================================================= + // ========================================================================= + + int i; + int Flag = 0; + int FunctionDescriptionCompilerVariantsNum = 0; + + // Storage for current function information + FunctionDescriptionType FunctionDescriptionUser; + FunctionDescriptionType FunctionDescriptionCompiler; + FunctionDescriptionType *FunctionDescription = nullptr; + + // Storage for internal representation of attributes + FunctionAttributeType InternalAttributesUser; + FunctionAttributeType InternalAttributesCompiler; + FunctionAttributeType *InternalAttribute; + + FunctionDescriptionType *FunctionDescriptionCompilerVariant; + + // Pointer to walk over attributes list + const ImfAttr *ExternalAttributes; + + PRN_MSG("\n=================================\n"); + PRN_MSG("%-32s: [START] entered function\n", "mayIUseInlineImplementation"); + + // Bad arguments check + if (FuncBaseName == nullptr) { + PRN_MSG("%-32s: [ERROR] FuncBaseName is NULL\n", + "mayIUseInlineImplementation"); + return 0; + } else { + PRN_MSG("%-32s: Func_base_name = \"%s\"\n", + "mayIUseInlineImplementation", FuncBaseName); + } + + // fill in the default values into the function description structures + attrInitFuncDescription(&FunctionDescriptionUser); + attrInitFuncDescription(&FunctionDescriptionCompiler); + + /* Search in LIBM table */ + Flag = libmGetNameIndex(FuncBaseName); + if (Flag >= 0) { + FunctionDescriptionUser.Index = Flag; + FunctionDescriptionCompiler.Index = Flag; + FunctionDescriptionUser.Precision = + libmGetFuncPrecision(FunctionDescriptionUser.Index); + FunctionDescriptionCompiler.Precision = + libmGetFuncPrecision(FunctionDescriptionCompiler.Index); + PRN_MSG("%-32s: Function \"%s\" found in LIBM table [success]\n", + "mayIUseInlineImplementation", FuncBaseName); + } else { + /* Search in Inline table */ + Flag = inlineGetNameIndex(FuncBaseName); + if (Flag >= 0) { + FunctionDescriptionUser.Index = Flag; + FunctionDescriptionCompiler.Index = Flag; + FunctionDescriptionUser.Precision = + inlineGetFuncPrecision(FunctionDescriptionUser.Index); + FunctionDescriptionCompiler.Precision = + inlineGetFuncPrecision(FunctionDescriptionCompiler.Index); + PRN_MSG("%-32s: Function \"%s\" found in Inline table [success]\n", + "mayIUseInlineImplementation", FuncBaseName); + } else { + /* Search in SVML table */ + FunctionDescriptionCompilerVariantsNum = + svmlGetFuncVariantsList(&FunctionDescriptionCompilerVariant, + FuncBaseName, FunctionDescriptionTable, + SvmlFunctionsNum); + if (FunctionDescriptionCompilerVariantsNum > 0) { + FunctionDescriptionUser.Precision = + FunctionDescriptionCompilerVariant[0].Precision; + FunctionDescriptionCompiler.Precision = + FunctionDescriptionCompilerVariant[0].Precision; + PRN_MSG("%-32s: Function \"%s\" found in SVML table [success]\n", + "mayIUseInlineImplementation", FuncBaseName); + } else { + PRN_MSG( + "%-32s: [ERROR] \"%s\" wasn't found in Inline/LIBM/SVML tables\n", + "mayIUseInlineImplementation", FuncBaseName); + PRN_MSG("=================================\n\n"); + return 0; + } + } + } + + PRN_MSG("%-32s: User's func precision = %s\n", + "mayIUseInlineImplementation", + ValidPrecisionNames[FunctionDescriptionUser.Precision + 1]); + PRN_MSG("%-32s: Compiler's func precision = %s\n", + "mayIUseInlineImplementation", + ValidPrecisionNames[FunctionDescriptionCompiler.Precision + 1]); + + // ========================================================================= + // Walk over "compiler" and "user" attributes sets. + // We organize the two passes in a loop of 2 iterations to not duplicate the + // code. We use pointers to substitute "compiler" and "user" entities. + // ========================================================================= + + // start with "compiler" attributes + InternalAttribute = &InternalAttributesCompiler; + ExternalAttributes = ExternalAttributesCompiler; + FunctionDescription = &FunctionDescriptionCompiler; + + for (i = 0; i < 2; i++) { + // ===================================================================== + // Loop over ExternalAttributes, convert external representation into + // internal enumerations, update the requested function description + // based on incoming attribute. + // ===================================================================== + if (i == 0) { + PRN_MSG("%-32s: Compiler suggested attributes:\n", + "mayIUseInlineImplementation"); + } else { + PRN_MSG("%-32s: User requested attributes:\n", + "mayIUseInlineImplementation"); + } + + while (ExternalAttributes != nullptr) { + Flag = attrExternal2InternalAttr(InternalAttribute, ExternalAttributes); + Flag = attrUpdateFuncDescription(FunctionDescription, InternalAttribute); + // get next external attribute pointer + ExternalAttributes = ExternalAttributes->Next; + } + + // move pointers to "user" attributes + InternalAttribute = &InternalAttributesUser; + ExternalAttributes = ExternalAttributesUser; + FunctionDescription = &FunctionDescriptionUser; + } + + PRN_MSG("%-32s: Comparing user and compiler attributes:\n", + "mayIUseInlineImplementation"); + // ========================================================================= + // Here we have prepared two function descriptions based on user and + // compiler attributes. Now we need to match them up and decide whether + // the compiler request fits into user defined requirements. + // ========================================================================= + Flag = svmlMatchFuncDescriptions(FunctionDescriptionUser, + FunctionDescriptionCompiler); + + if (Flag) { + PRN_MSG("%-32s: [SUCCESS] \"%s\" function may be inlined\n", + "mayIUseInlineImplementation", FuncBaseName); + PRN_MSG("=================================\n\n"); + } else { + PRN_MSG("%-32s: [FAILURE] \"%s\" function may not be inlined\n", + "mayIUseInlineImplementation", FuncBaseName); + PRN_MSG("=================================\n\n"); + } + + return Flag; +} + +#if defined __cplusplus +} +#endif // __cplusplus Index: lib/Transforms/IntrinToMathLib/ImlTableInline.inc =================================================================== --- lib/Transforms/IntrinToMathLib/ImlTableInline.inc +++ lib/Transforms/IntrinToMathLib/ImlTableInline.inc @@ -0,0 +1,30 @@ +//==------ ImlTableInline.inc - Inline-able libm functions -*- C++ -*-------==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Defines the set of possible libm functions that can be replaced with an +/// inlined sequence of instructions. +// +// ===--------------------------------------------------------------------=== // + + { "__cdivd", "z" }, + { "__cdivf", "c" }, + { "__divd", "d" }, + { "__divf", "s" }, + { "__divl", "l" }, + { "__rcpd", "d" }, + { "__rcpf", "s" }, + { "__svml_div8", "d" }, + { "__svml_div8_mask", "d" }, + { "__svml_divf16", "s" }, + { "__svml_divf16_mask", "s" }, + { "__svml_rcp8", "d" }, + { "__svml_rcp8_mask", "d" }, + { "__svml_rcpf16", "s" }, + { "__svml_rcpf16_mask", "s" }, Index: lib/Transforms/IntrinToMathLib/ImlTableSvmlIA32.inc =================================================================== --- lib/Transforms/IntrinToMathLib/ImlTableSvmlIA32.inc +++ lib/Transforms/IntrinToMathLib/ImlTableSvmlIA32.inc @@ -0,0 +1,32747 @@ +//==--------- ImlTableSvmlIA32.inc - SVML function table -*- C++ -*---------==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Defines the set of X86 SVML functions and variants that are selected based +/// on IMF (Intel Math Function) attributes. IMF attributes describe the +/// precision requirements of the function. +// +// ===--------------------------------------------------------------------=== // + +/* Begin of libiml_attr table */ +{ +"__svml_acos2", //const char * parent_function_name; +"__svml_acos2_ep", //const char * variant_function_name; +0, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2", //const char * parent_function_name; +"__svml_acos2", //const char * variant_function_name; +1, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2", //const char * parent_function_name; +"__svml_acos2_ha", //const char * variant_function_name; +2, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2", //const char * parent_function_name; +"__svml_acos2_br", //const char * variant_function_name; +3, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2_mask", //const char * parent_function_name; +"__svml_acos2_ep_mask", //const char * variant_function_name; +4, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2_mask", //const char * parent_function_name; +"__svml_acos2_mask", //const char * variant_function_name; +5, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2_mask", //const char * parent_function_name; +"__svml_acos2_ha_mask", //const char * variant_function_name; +6, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos2_mask", //const char * parent_function_name; +"__svml_acos2_br_mask", //const char * variant_function_name; +7, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4", //const char * parent_function_name; +"__svml_acos4_ep", //const char * variant_function_name; +8, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4", //const char * parent_function_name; +"__svml_acos4", //const char * variant_function_name; +9, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4", //const char * parent_function_name; +"__svml_acos4_ha", //const char * variant_function_name; +10, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4", //const char * parent_function_name; +"__svml_acos4_br", //const char * variant_function_name; +11, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4_mask", //const char * parent_function_name; +"__svml_acos4_ep_mask", //const char * variant_function_name; +12, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4_mask", //const char * parent_function_name; +"__svml_acos4_mask", //const char * variant_function_name; +13, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4_mask", //const char * parent_function_name; +"__svml_acos4_ha_mask", //const char * variant_function_name; +14, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos4_mask", //const char * parent_function_name; +"__svml_acos4_br_mask", //const char * variant_function_name; +15, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8", //const char * parent_function_name; +"__svml_acos8_ep", //const char * variant_function_name; +16, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8", //const char * parent_function_name; +"__svml_acos8", //const char * variant_function_name; +17, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8", //const char * parent_function_name; +"__svml_acos8_ha", //const char * variant_function_name; +18, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8", //const char * parent_function_name; +"__svml_acos8_br", //const char * variant_function_name; +19, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8_mask", //const char * parent_function_name; +"__svml_acos8_ep_mask", //const char * variant_function_name; +20, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8_mask", //const char * parent_function_name; +"__svml_acos8_mask", //const char * variant_function_name; +21, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8_mask", //const char * parent_function_name; +"__svml_acos8_ha_mask", //const char * variant_function_name; +22, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acos8_mask", //const char * parent_function_name; +"__svml_acos8_br_mask", //const char * variant_function_name; +23, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16", //const char * parent_function_name; +"__svml_acosf16_ep", //const char * variant_function_name; +24, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16", //const char * parent_function_name; +"__svml_acosf16", //const char * variant_function_name; +25, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16", //const char * parent_function_name; +"__svml_acosf16_ha", //const char * variant_function_name; +26, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16", //const char * parent_function_name; +"__svml_acosf16_br", //const char * variant_function_name; +27, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16_mask", //const char * parent_function_name; +"__svml_acosf16_ep_mask", //const char * variant_function_name; +28, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16_mask", //const char * parent_function_name; +"__svml_acosf16_mask", //const char * variant_function_name; +29, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16_mask", //const char * parent_function_name; +"__svml_acosf16_ha_mask", //const char * variant_function_name; +30, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf16_mask", //const char * parent_function_name; +"__svml_acosf16_br_mask", //const char * variant_function_name; +31, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4", //const char * parent_function_name; +"__svml_acosf4_ep", //const char * variant_function_name; +32, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4", //const char * parent_function_name; +"__svml_acosf4", //const char * variant_function_name; +33, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4", //const char * parent_function_name; +"__svml_acosf4_ha", //const char * variant_function_name; +34, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4", //const char * parent_function_name; +"__svml_acosf4_br", //const char * variant_function_name; +35, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4_mask", //const char * parent_function_name; +"__svml_acosf4_ep_mask", //const char * variant_function_name; +36, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4_mask", //const char * parent_function_name; +"__svml_acosf4_mask", //const char * variant_function_name; +37, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4_mask", //const char * parent_function_name; +"__svml_acosf4_ha_mask", //const char * variant_function_name; +38, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf4_mask", //const char * parent_function_name; +"__svml_acosf4_br_mask", //const char * variant_function_name; +39, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8", //const char * parent_function_name; +"__svml_acosf8_ep", //const char * variant_function_name; +40, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8", //const char * parent_function_name; +"__svml_acosf8", //const char * variant_function_name; +41, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8", //const char * parent_function_name; +"__svml_acosf8_ha", //const char * variant_function_name; +42, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8", //const char * parent_function_name; +"__svml_acosf8_br", //const char * variant_function_name; +43, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8_mask", //const char * parent_function_name; +"__svml_acosf8_ep_mask", //const char * variant_function_name; +44, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8_mask", //const char * parent_function_name; +"__svml_acosf8_mask", //const char * variant_function_name; +45, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8_mask", //const char * parent_function_name; +"__svml_acosf8_ha_mask", //const char * variant_function_name; +46, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosf8_mask", //const char * parent_function_name; +"__svml_acosf8_br_mask", //const char * variant_function_name; +47, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2", //const char * parent_function_name; +"__svml_acosh2_ep", //const char * variant_function_name; +48, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2", //const char * parent_function_name; +"__svml_acosh2", //const char * variant_function_name; +49, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2", //const char * parent_function_name; +"__svml_acosh2_ha", //const char * variant_function_name; +50, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2_mask", //const char * parent_function_name; +"__svml_acosh2_ep_mask", //const char * variant_function_name; +51, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2_mask", //const char * parent_function_name; +"__svml_acosh2_mask", //const char * variant_function_name; +52, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh2_mask", //const char * parent_function_name; +"__svml_acosh2_ha_mask", //const char * variant_function_name; +53, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4", //const char * parent_function_name; +"__svml_acosh4_ep", //const char * variant_function_name; +54, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4", //const char * parent_function_name; +"__svml_acosh4", //const char * variant_function_name; +55, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4", //const char * parent_function_name; +"__svml_acosh4_ha", //const char * variant_function_name; +56, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4", //const char * parent_function_name; +"__svml_acosh4_br", //const char * variant_function_name; +57, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4_mask", //const char * parent_function_name; +"__svml_acosh4_ep_mask", //const char * variant_function_name; +58, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4_mask", //const char * parent_function_name; +"__svml_acosh4_mask", //const char * variant_function_name; +59, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4_mask", //const char * parent_function_name; +"__svml_acosh4_ha_mask", //const char * variant_function_name; +60, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh4_mask", //const char * parent_function_name; +"__svml_acosh4_br_mask", //const char * variant_function_name; +61, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8", //const char * parent_function_name; +"__svml_acosh8_ep", //const char * variant_function_name; +62, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8", //const char * parent_function_name; +"__svml_acosh8", //const char * variant_function_name; +63, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8", //const char * parent_function_name; +"__svml_acosh8_ha", //const char * variant_function_name; +64, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8_mask", //const char * parent_function_name; +"__svml_acosh8_ep_mask", //const char * variant_function_name; +65, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8_mask", //const char * parent_function_name; +"__svml_acosh8_mask", //const char * variant_function_name; +66, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acosh8_mask", //const char * parent_function_name; +"__svml_acosh8_ha_mask", //const char * variant_function_name; +67, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16", //const char * parent_function_name; +"__svml_acoshf16_ep", //const char * variant_function_name; +68, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16", //const char * parent_function_name; +"__svml_acoshf16", //const char * variant_function_name; +69, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16", //const char * parent_function_name; +"__svml_acoshf16_ha", //const char * variant_function_name; +70, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16_mask", //const char * parent_function_name; +"__svml_acoshf16_ep_mask", //const char * variant_function_name; +71, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16_mask", //const char * parent_function_name; +"__svml_acoshf16_mask", //const char * variant_function_name; +72, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf16_mask", //const char * parent_function_name; +"__svml_acoshf16_ha_mask", //const char * variant_function_name; +73, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4", //const char * parent_function_name; +"__svml_acoshf4_ep", //const char * variant_function_name; +74, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4", //const char * parent_function_name; +"__svml_acoshf4", //const char * variant_function_name; +75, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4", //const char * parent_function_name; +"__svml_acoshf4_ha", //const char * variant_function_name; +76, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4_mask", //const char * parent_function_name; +"__svml_acoshf4_ep_mask", //const char * variant_function_name; +77, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4_mask", //const char * parent_function_name; +"__svml_acoshf4_mask", //const char * variant_function_name; +78, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf4_mask", //const char * parent_function_name; +"__svml_acoshf4_ha_mask", //const char * variant_function_name; +79, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8", //const char * parent_function_name; +"__svml_acoshf8_ep", //const char * variant_function_name; +80, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8", //const char * parent_function_name; +"__svml_acoshf8", //const char * variant_function_name; +81, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8", //const char * parent_function_name; +"__svml_acoshf8_ha", //const char * variant_function_name; +82, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8", //const char * parent_function_name; +"__svml_acoshf8_br", //const char * variant_function_name; +83, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8_mask", //const char * parent_function_name; +"__svml_acoshf8_ep_mask", //const char * variant_function_name; +84, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8_mask", //const char * parent_function_name; +"__svml_acoshf8_mask", //const char * variant_function_name; +85, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8_mask", //const char * parent_function_name; +"__svml_acoshf8_ha_mask", //const char * variant_function_name; +86, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_acoshf8_mask", //const char * parent_function_name; +"__svml_acoshf8_br_mask", //const char * variant_function_name; +87, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2", //const char * parent_function_name; +"__svml_asin2_ep", //const char * variant_function_name; +88, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2", //const char * parent_function_name; +"__svml_asin2", //const char * variant_function_name; +89, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2", //const char * parent_function_name; +"__svml_asin2_ha", //const char * variant_function_name; +90, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2", //const char * parent_function_name; +"__svml_asin2_br", //const char * variant_function_name; +91, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2_mask", //const char * parent_function_name; +"__svml_asin2_ep_mask", //const char * variant_function_name; +92, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2_mask", //const char * parent_function_name; +"__svml_asin2_mask", //const char * variant_function_name; +93, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2_mask", //const char * parent_function_name; +"__svml_asin2_ha_mask", //const char * variant_function_name; +94, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin2_mask", //const char * parent_function_name; +"__svml_asin2_br_mask", //const char * variant_function_name; +95, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4", //const char * parent_function_name; +"__svml_asin4_ep", //const char * variant_function_name; +96, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4", //const char * parent_function_name; +"__svml_asin4", //const char * variant_function_name; +97, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4", //const char * parent_function_name; +"__svml_asin4_ha", //const char * variant_function_name; +98, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4", //const char * parent_function_name; +"__svml_asin4_br", //const char * variant_function_name; +99, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4_mask", //const char * parent_function_name; +"__svml_asin4_ep_mask", //const char * variant_function_name; +100, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4_mask", //const char * parent_function_name; +"__svml_asin4_mask", //const char * variant_function_name; +101, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4_mask", //const char * parent_function_name; +"__svml_asin4_ha_mask", //const char * variant_function_name; +102, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin4_mask", //const char * parent_function_name; +"__svml_asin4_br_mask", //const char * variant_function_name; +103, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8", //const char * parent_function_name; +"__svml_asin8_ep", //const char * variant_function_name; +104, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8", //const char * parent_function_name; +"__svml_asin8", //const char * variant_function_name; +105, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8", //const char * parent_function_name; +"__svml_asin8_ha", //const char * variant_function_name; +106, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8", //const char * parent_function_name; +"__svml_asin8_br", //const char * variant_function_name; +107, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8_mask", //const char * parent_function_name; +"__svml_asin8_ep_mask", //const char * variant_function_name; +108, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8_mask", //const char * parent_function_name; +"__svml_asin8_mask", //const char * variant_function_name; +109, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8_mask", //const char * parent_function_name; +"__svml_asin8_ha_mask", //const char * variant_function_name; +110, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asin8_mask", //const char * parent_function_name; +"__svml_asin8_br_mask", //const char * variant_function_name; +111, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16", //const char * parent_function_name; +"__svml_asinf16_ep", //const char * variant_function_name; +112, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16", //const char * parent_function_name; +"__svml_asinf16", //const char * variant_function_name; +113, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16", //const char * parent_function_name; +"__svml_asinf16_ha", //const char * variant_function_name; +114, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16", //const char * parent_function_name; +"__svml_asinf16_br", //const char * variant_function_name; +115, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16_mask", //const char * parent_function_name; +"__svml_asinf16_ep_mask", //const char * variant_function_name; +116, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16_mask", //const char * parent_function_name; +"__svml_asinf16_mask", //const char * variant_function_name; +117, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16_mask", //const char * parent_function_name; +"__svml_asinf16_ha_mask", //const char * variant_function_name; +118, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf16_mask", //const char * parent_function_name; +"__svml_asinf16_br_mask", //const char * variant_function_name; +119, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4", //const char * parent_function_name; +"__svml_asinf4_ep", //const char * variant_function_name; +120, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4", //const char * parent_function_name; +"__svml_asinf4", //const char * variant_function_name; +121, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4", //const char * parent_function_name; +"__svml_asinf4_ha", //const char * variant_function_name; +122, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4", //const char * parent_function_name; +"__svml_asinf4_br", //const char * variant_function_name; +123, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4_mask", //const char * parent_function_name; +"__svml_asinf4_ep_mask", //const char * variant_function_name; +124, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4_mask", //const char * parent_function_name; +"__svml_asinf4_mask", //const char * variant_function_name; +125, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4_mask", //const char * parent_function_name; +"__svml_asinf4_ha_mask", //const char * variant_function_name; +126, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf4_mask", //const char * parent_function_name; +"__svml_asinf4_br_mask", //const char * variant_function_name; +127, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8", //const char * parent_function_name; +"__svml_asinf8_ep", //const char * variant_function_name; +128, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8", //const char * parent_function_name; +"__svml_asinf8", //const char * variant_function_name; +129, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8", //const char * parent_function_name; +"__svml_asinf8_ha", //const char * variant_function_name; +130, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8", //const char * parent_function_name; +"__svml_asinf8_br", //const char * variant_function_name; +131, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8_mask", //const char * parent_function_name; +"__svml_asinf8_ep_mask", //const char * variant_function_name; +132, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8_mask", //const char * parent_function_name; +"__svml_asinf8_mask", //const char * variant_function_name; +133, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8_mask", //const char * parent_function_name; +"__svml_asinf8_ha_mask", //const char * variant_function_name; +134, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinf8_mask", //const char * parent_function_name; +"__svml_asinf8_br_mask", //const char * variant_function_name; +135, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2", //const char * parent_function_name; +"__svml_asinh2_ep", //const char * variant_function_name; +136, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2", //const char * parent_function_name; +"__svml_asinh2", //const char * variant_function_name; +137, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2", //const char * parent_function_name; +"__svml_asinh2_ha", //const char * variant_function_name; +138, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2_mask", //const char * parent_function_name; +"__svml_asinh2_ep_mask", //const char * variant_function_name; +139, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2_mask", //const char * parent_function_name; +"__svml_asinh2_mask", //const char * variant_function_name; +140, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh2_mask", //const char * parent_function_name; +"__svml_asinh2_ha_mask", //const char * variant_function_name; +141, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4", //const char * parent_function_name; +"__svml_asinh4_ep", //const char * variant_function_name; +142, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4", //const char * parent_function_name; +"__svml_asinh4", //const char * variant_function_name; +143, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4", //const char * parent_function_name; +"__svml_asinh4_ha", //const char * variant_function_name; +144, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4", //const char * parent_function_name; +"__svml_asinh4_br", //const char * variant_function_name; +145, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4_mask", //const char * parent_function_name; +"__svml_asinh4_ep_mask", //const char * variant_function_name; +146, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4_mask", //const char * parent_function_name; +"__svml_asinh4_mask", //const char * variant_function_name; +147, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4_mask", //const char * parent_function_name; +"__svml_asinh4_ha_mask", //const char * variant_function_name; +148, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh4_mask", //const char * parent_function_name; +"__svml_asinh4_br_mask", //const char * variant_function_name; +149, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8", //const char * parent_function_name; +"__svml_asinh8_ep", //const char * variant_function_name; +150, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8", //const char * parent_function_name; +"__svml_asinh8", //const char * variant_function_name; +151, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8", //const char * parent_function_name; +"__svml_asinh8_ha", //const char * variant_function_name; +152, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8_mask", //const char * parent_function_name; +"__svml_asinh8_ep_mask", //const char * variant_function_name; +153, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8_mask", //const char * parent_function_name; +"__svml_asinh8_mask", //const char * variant_function_name; +154, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinh8_mask", //const char * parent_function_name; +"__svml_asinh8_ha_mask", //const char * variant_function_name; +155, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16", //const char * parent_function_name; +"__svml_asinhf16_ep", //const char * variant_function_name; +156, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16", //const char * parent_function_name; +"__svml_asinhf16", //const char * variant_function_name; +157, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16", //const char * parent_function_name; +"__svml_asinhf16_ha", //const char * variant_function_name; +158, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16_mask", //const char * parent_function_name; +"__svml_asinhf16_ep_mask", //const char * variant_function_name; +159, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16_mask", //const char * parent_function_name; +"__svml_asinhf16_mask", //const char * variant_function_name; +160, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf16_mask", //const char * parent_function_name; +"__svml_asinhf16_ha_mask", //const char * variant_function_name; +161, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4", //const char * parent_function_name; +"__svml_asinhf4_ep", //const char * variant_function_name; +162, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4", //const char * parent_function_name; +"__svml_asinhf4", //const char * variant_function_name; +163, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4", //const char * parent_function_name; +"__svml_asinhf4_ha", //const char * variant_function_name; +164, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4_mask", //const char * parent_function_name; +"__svml_asinhf4_ep_mask", //const char * variant_function_name; +165, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4_mask", //const char * parent_function_name; +"__svml_asinhf4_mask", //const char * variant_function_name; +166, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf4_mask", //const char * parent_function_name; +"__svml_asinhf4_ha_mask", //const char * variant_function_name; +167, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8", //const char * parent_function_name; +"__svml_asinhf8_ep", //const char * variant_function_name; +168, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8", //const char * parent_function_name; +"__svml_asinhf8", //const char * variant_function_name; +169, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8", //const char * parent_function_name; +"__svml_asinhf8_ha", //const char * variant_function_name; +170, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8", //const char * parent_function_name; +"__svml_asinhf8_br", //const char * variant_function_name; +171, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8_mask", //const char * parent_function_name; +"__svml_asinhf8_ep_mask", //const char * variant_function_name; +172, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8_mask", //const char * parent_function_name; +"__svml_asinhf8_mask", //const char * variant_function_name; +173, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8_mask", //const char * parent_function_name; +"__svml_asinhf8_ha_mask", //const char * variant_function_name; +174, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_asinhf8_mask", //const char * parent_function_name; +"__svml_asinhf8_br_mask", //const char * variant_function_name; +175, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2", //const char * parent_function_name; +"__svml_atan2_ep", //const char * variant_function_name; +176, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2", //const char * parent_function_name; +"__svml_atan2", //const char * variant_function_name; +177, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2", //const char * parent_function_name; +"__svml_atan2_ha", //const char * variant_function_name; +178, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2", //const char * parent_function_name; +"__svml_atan2_br", //const char * variant_function_name; +179, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22", //const char * parent_function_name; +"__svml_atan22_ep", //const char * variant_function_name; +180, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22", //const char * parent_function_name; +"__svml_atan22", //const char * variant_function_name; +181, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22", //const char * parent_function_name; +"__svml_atan22_ha", //const char * variant_function_name; +182, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22", //const char * parent_function_name; +"__svml_atan22_br", //const char * variant_function_name; +183, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22_mask", //const char * parent_function_name; +"__svml_atan22_ep_mask", //const char * variant_function_name; +184, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22_mask", //const char * parent_function_name; +"__svml_atan22_mask", //const char * variant_function_name; +185, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22_mask", //const char * parent_function_name; +"__svml_atan22_ha_mask", //const char * variant_function_name; +186, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan22_mask", //const char * parent_function_name; +"__svml_atan22_br_mask", //const char * variant_function_name; +187, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24", //const char * parent_function_name; +"__svml_atan24_ep", //const char * variant_function_name; +188, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24", //const char * parent_function_name; +"__svml_atan24", //const char * variant_function_name; +189, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24", //const char * parent_function_name; +"__svml_atan24_ha", //const char * variant_function_name; +190, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24", //const char * parent_function_name; +"__svml_atan24_br", //const char * variant_function_name; +191, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24_mask", //const char * parent_function_name; +"__svml_atan24_ep_mask", //const char * variant_function_name; +192, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24_mask", //const char * parent_function_name; +"__svml_atan24_mask", //const char * variant_function_name; +193, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24_mask", //const char * parent_function_name; +"__svml_atan24_ha_mask", //const char * variant_function_name; +194, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan24_mask", //const char * parent_function_name; +"__svml_atan24_br_mask", //const char * variant_function_name; +195, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28", //const char * parent_function_name; +"__svml_atan28_ep", //const char * variant_function_name; +196, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28", //const char * parent_function_name; +"__svml_atan28", //const char * variant_function_name; +197, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28", //const char * parent_function_name; +"__svml_atan28_ha", //const char * variant_function_name; +198, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28", //const char * parent_function_name; +"__svml_atan28_br", //const char * variant_function_name; +199, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28_mask", //const char * parent_function_name; +"__svml_atan28_ep_mask", //const char * variant_function_name; +200, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28_mask", //const char * parent_function_name; +"__svml_atan28_mask", //const char * variant_function_name; +201, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28_mask", //const char * parent_function_name; +"__svml_atan28_ha_mask", //const char * variant_function_name; +202, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan28_mask", //const char * parent_function_name; +"__svml_atan28_br_mask", //const char * variant_function_name; +203, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2_mask", //const char * parent_function_name; +"__svml_atan2_ep_mask", //const char * variant_function_name; +204, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2_mask", //const char * parent_function_name; +"__svml_atan2_mask", //const char * variant_function_name; +205, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2_mask", //const char * parent_function_name; +"__svml_atan2_ha_mask", //const char * variant_function_name; +206, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2_mask", //const char * parent_function_name; +"__svml_atan2_br_mask", //const char * variant_function_name; +207, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16", //const char * parent_function_name; +"__svml_atan2f16_ep", //const char * variant_function_name; +208, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16", //const char * parent_function_name; +"__svml_atan2f16", //const char * variant_function_name; +209, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16", //const char * parent_function_name; +"__svml_atan2f16_ha", //const char * variant_function_name; +210, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16", //const char * parent_function_name; +"__svml_atan2f16_br", //const char * variant_function_name; +211, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16_mask", //const char * parent_function_name; +"__svml_atan2f16_ep_mask", //const char * variant_function_name; +212, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16_mask", //const char * parent_function_name; +"__svml_atan2f16_mask", //const char * variant_function_name; +213, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16_mask", //const char * parent_function_name; +"__svml_atan2f16_ha_mask", //const char * variant_function_name; +214, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f16_mask", //const char * parent_function_name; +"__svml_atan2f16_br_mask", //const char * variant_function_name; +215, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4", //const char * parent_function_name; +"__svml_atan2f4_ep", //const char * variant_function_name; +216, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4", //const char * parent_function_name; +"__svml_atan2f4", //const char * variant_function_name; +217, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4", //const char * parent_function_name; +"__svml_atan2f4_ha", //const char * variant_function_name; +218, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4", //const char * parent_function_name; +"__svml_atan2f4_br", //const char * variant_function_name; +219, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4_mask", //const char * parent_function_name; +"__svml_atan2f4_ep_mask", //const char * variant_function_name; +220, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4_mask", //const char * parent_function_name; +"__svml_atan2f4_mask", //const char * variant_function_name; +221, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4_mask", //const char * parent_function_name; +"__svml_atan2f4_ha_mask", //const char * variant_function_name; +222, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f4_mask", //const char * parent_function_name; +"__svml_atan2f4_br_mask", //const char * variant_function_name; +223, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8", //const char * parent_function_name; +"__svml_atan2f8_ep", //const char * variant_function_name; +224, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8", //const char * parent_function_name; +"__svml_atan2f8", //const char * variant_function_name; +225, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8", //const char * parent_function_name; +"__svml_atan2f8_ha", //const char * variant_function_name; +226, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8", //const char * parent_function_name; +"__svml_atan2f8_br", //const char * variant_function_name; +227, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8_mask", //const char * parent_function_name; +"__svml_atan2f8_ep_mask", //const char * variant_function_name; +228, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8_mask", //const char * parent_function_name; +"__svml_atan2f8_mask", //const char * variant_function_name; +229, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8_mask", //const char * parent_function_name; +"__svml_atan2f8_ha_mask", //const char * variant_function_name; +230, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan2f8_mask", //const char * parent_function_name; +"__svml_atan2f8_br_mask", //const char * variant_function_name; +231, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4", //const char * parent_function_name; +"__svml_atan4_ep", //const char * variant_function_name; +232, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4", //const char * parent_function_name; +"__svml_atan4", //const char * variant_function_name; +233, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4", //const char * parent_function_name; +"__svml_atan4_ha", //const char * variant_function_name; +234, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4", //const char * parent_function_name; +"__svml_atan4_br", //const char * variant_function_name; +235, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4_mask", //const char * parent_function_name; +"__svml_atan4_ep_mask", //const char * variant_function_name; +236, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4_mask", //const char * parent_function_name; +"__svml_atan4_mask", //const char * variant_function_name; +237, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4_mask", //const char * parent_function_name; +"__svml_atan4_ha_mask", //const char * variant_function_name; +238, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan4_mask", //const char * parent_function_name; +"__svml_atan4_br_mask", //const char * variant_function_name; +239, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8", //const char * parent_function_name; +"__svml_atan8_ep", //const char * variant_function_name; +240, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8", //const char * parent_function_name; +"__svml_atan8", //const char * variant_function_name; +241, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8", //const char * parent_function_name; +"__svml_atan8_ha", //const char * variant_function_name; +242, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8", //const char * parent_function_name; +"__svml_atan8_br", //const char * variant_function_name; +243, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8_mask", //const char * parent_function_name; +"__svml_atan8_ep_mask", //const char * variant_function_name; +244, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8_mask", //const char * parent_function_name; +"__svml_atan8_mask", //const char * variant_function_name; +245, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8_mask", //const char * parent_function_name; +"__svml_atan8_ha_mask", //const char * variant_function_name; +246, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atan8_mask", //const char * parent_function_name; +"__svml_atan8_br_mask", //const char * variant_function_name; +247, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16", //const char * parent_function_name; +"__svml_atanf16_ep", //const char * variant_function_name; +248, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16", //const char * parent_function_name; +"__svml_atanf16", //const char * variant_function_name; +249, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16", //const char * parent_function_name; +"__svml_atanf16_ha", //const char * variant_function_name; +250, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16", //const char * parent_function_name; +"__svml_atanf16_br", //const char * variant_function_name; +251, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16_mask", //const char * parent_function_name; +"__svml_atanf16_ep_mask", //const char * variant_function_name; +252, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16_mask", //const char * parent_function_name; +"__svml_atanf16_mask", //const char * variant_function_name; +253, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16_mask", //const char * parent_function_name; +"__svml_atanf16_ha_mask", //const char * variant_function_name; +254, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf16_mask", //const char * parent_function_name; +"__svml_atanf16_br_mask", //const char * variant_function_name; +255, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4", //const char * parent_function_name; +"__svml_atanf4_ep", //const char * variant_function_name; +256, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4", //const char * parent_function_name; +"__svml_atanf4", //const char * variant_function_name; +257, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4", //const char * parent_function_name; +"__svml_atanf4_ha", //const char * variant_function_name; +258, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4", //const char * parent_function_name; +"__svml_atanf4_br", //const char * variant_function_name; +259, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4_mask", //const char * parent_function_name; +"__svml_atanf4_ep_mask", //const char * variant_function_name; +260, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4_mask", //const char * parent_function_name; +"__svml_atanf4_mask", //const char * variant_function_name; +261, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4_mask", //const char * parent_function_name; +"__svml_atanf4_ha_mask", //const char * variant_function_name; +262, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf4_mask", //const char * parent_function_name; +"__svml_atanf4_br_mask", //const char * variant_function_name; +263, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8", //const char * parent_function_name; +"__svml_atanf8_ep", //const char * variant_function_name; +264, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8", //const char * parent_function_name; +"__svml_atanf8", //const char * variant_function_name; +265, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8", //const char * parent_function_name; +"__svml_atanf8_ha", //const char * variant_function_name; +266, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8", //const char * parent_function_name; +"__svml_atanf8_br", //const char * variant_function_name; +267, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8_mask", //const char * parent_function_name; +"__svml_atanf8_ep_mask", //const char * variant_function_name; +268, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8_mask", //const char * parent_function_name; +"__svml_atanf8_mask", //const char * variant_function_name; +269, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8_mask", //const char * parent_function_name; +"__svml_atanf8_ha_mask", //const char * variant_function_name; +270, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanf8_mask", //const char * parent_function_name; +"__svml_atanf8_br_mask", //const char * variant_function_name; +271, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2", //const char * parent_function_name; +"__svml_atanh2_ep", //const char * variant_function_name; +272, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2", //const char * parent_function_name; +"__svml_atanh2", //const char * variant_function_name; +273, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2", //const char * parent_function_name; +"__svml_atanh2_ha", //const char * variant_function_name; +274, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2_mask", //const char * parent_function_name; +"__svml_atanh2_ep_mask", //const char * variant_function_name; +275, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2_mask", //const char * parent_function_name; +"__svml_atanh2_mask", //const char * variant_function_name; +276, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh2_mask", //const char * parent_function_name; +"__svml_atanh2_ha_mask", //const char * variant_function_name; +277, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4", //const char * parent_function_name; +"__svml_atanh4_ep", //const char * variant_function_name; +278, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4", //const char * parent_function_name; +"__svml_atanh4", //const char * variant_function_name; +279, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4", //const char * parent_function_name; +"__svml_atanh4_ha", //const char * variant_function_name; +280, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4", //const char * parent_function_name; +"__svml_atanh4_br", //const char * variant_function_name; +281, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4_mask", //const char * parent_function_name; +"__svml_atanh4_ep_mask", //const char * variant_function_name; +282, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4_mask", //const char * parent_function_name; +"__svml_atanh4_mask", //const char * variant_function_name; +283, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4_mask", //const char * parent_function_name; +"__svml_atanh4_ha_mask", //const char * variant_function_name; +284, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh4_mask", //const char * parent_function_name; +"__svml_atanh4_br_mask", //const char * variant_function_name; +285, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8", //const char * parent_function_name; +"__svml_atanh8_ep", //const char * variant_function_name; +286, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8", //const char * parent_function_name; +"__svml_atanh8", //const char * variant_function_name; +287, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8", //const char * parent_function_name; +"__svml_atanh8_ha", //const char * variant_function_name; +288, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8_mask", //const char * parent_function_name; +"__svml_atanh8_ep_mask", //const char * variant_function_name; +289, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8_mask", //const char * parent_function_name; +"__svml_atanh8_mask", //const char * variant_function_name; +290, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanh8_mask", //const char * parent_function_name; +"__svml_atanh8_ha_mask", //const char * variant_function_name; +291, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16", //const char * parent_function_name; +"__svml_atanhf16_ep", //const char * variant_function_name; +292, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16", //const char * parent_function_name; +"__svml_atanhf16", //const char * variant_function_name; +293, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16", //const char * parent_function_name; +"__svml_atanhf16_ha", //const char * variant_function_name; +294, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16_mask", //const char * parent_function_name; +"__svml_atanhf16_ep_mask", //const char * variant_function_name; +295, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16_mask", //const char * parent_function_name; +"__svml_atanhf16_mask", //const char * variant_function_name; +296, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf16_mask", //const char * parent_function_name; +"__svml_atanhf16_ha_mask", //const char * variant_function_name; +297, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4", //const char * parent_function_name; +"__svml_atanhf4_ep", //const char * variant_function_name; +298, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4", //const char * parent_function_name; +"__svml_atanhf4", //const char * variant_function_name; +299, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4", //const char * parent_function_name; +"__svml_atanhf4_ha", //const char * variant_function_name; +300, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4_mask", //const char * parent_function_name; +"__svml_atanhf4_ep_mask", //const char * variant_function_name; +301, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4_mask", //const char * parent_function_name; +"__svml_atanhf4_mask", //const char * variant_function_name; +302, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf4_mask", //const char * parent_function_name; +"__svml_atanhf4_ha_mask", //const char * variant_function_name; +303, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8", //const char * parent_function_name; +"__svml_atanhf8_ep", //const char * variant_function_name; +304, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8", //const char * parent_function_name; +"__svml_atanhf8", //const char * variant_function_name; +305, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8", //const char * parent_function_name; +"__svml_atanhf8_ha", //const char * variant_function_name; +306, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8", //const char * parent_function_name; +"__svml_atanhf8_br", //const char * variant_function_name; +307, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8_mask", //const char * parent_function_name; +"__svml_atanhf8_ep_mask", //const char * variant_function_name; +308, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8_mask", //const char * parent_function_name; +"__svml_atanhf8_mask", //const char * variant_function_name; +309, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8_mask", //const char * parent_function_name; +"__svml_atanhf8_ha_mask", //const char * variant_function_name; +310, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_atanhf8_mask", //const char * parent_function_name; +"__svml_atanhf8_br_mask", //const char * variant_function_name; +311, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2", //const char * parent_function_name; +"__svml_cabs2_ep", //const char * variant_function_name; +312, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2", //const char * parent_function_name; +"__svml_cabs2", //const char * variant_function_name; +313, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2", //const char * parent_function_name; +"__svml_cabs2_ha", //const char * variant_function_name; +314, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2", //const char * parent_function_name; +"__svml_cabs2_br", //const char * variant_function_name; +315, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2_mask", //const char * parent_function_name; +"__svml_cabs2_ep_mask", //const char * variant_function_name; +316, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2_mask", //const char * parent_function_name; +"__svml_cabs2_mask", //const char * variant_function_name; +317, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2_mask", //const char * parent_function_name; +"__svml_cabs2_ha_mask", //const char * variant_function_name; +318, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs2_mask", //const char * parent_function_name; +"__svml_cabs2_br_mask", //const char * variant_function_name; +319, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4", //const char * parent_function_name; +"__svml_cabs4_ep", //const char * variant_function_name; +320, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4", //const char * parent_function_name; +"__svml_cabs4", //const char * variant_function_name; +321, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4", //const char * parent_function_name; +"__svml_cabs4_ha", //const char * variant_function_name; +322, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4", //const char * parent_function_name; +"__svml_cabs4_br", //const char * variant_function_name; +323, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4_mask", //const char * parent_function_name; +"__svml_cabs4_ep_mask", //const char * variant_function_name; +324, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4_mask", //const char * parent_function_name; +"__svml_cabs4_mask", //const char * variant_function_name; +325, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4_mask", //const char * parent_function_name; +"__svml_cabs4_ha_mask", //const char * variant_function_name; +326, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs4_mask", //const char * parent_function_name; +"__svml_cabs4_br_mask", //const char * variant_function_name; +327, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8", //const char * parent_function_name; +"__svml_cabs8_ep", //const char * variant_function_name; +328, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8", //const char * parent_function_name; +"__svml_cabs8", //const char * variant_function_name; +329, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8", //const char * parent_function_name; +"__svml_cabs8_ha", //const char * variant_function_name; +330, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8", //const char * parent_function_name; +"__svml_cabs8_br", //const char * variant_function_name; +331, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8_mask", //const char * parent_function_name; +"__svml_cabs8_ep_mask", //const char * variant_function_name; +332, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8_mask", //const char * parent_function_name; +"__svml_cabs8_mask", //const char * variant_function_name; +333, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8_mask", //const char * parent_function_name; +"__svml_cabs8_ha_mask", //const char * variant_function_name; +334, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabs8_mask", //const char * parent_function_name; +"__svml_cabs8_br_mask", //const char * variant_function_name; +335, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16", //const char * parent_function_name; +"__svml_cabsf16_ep", //const char * variant_function_name; +336, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16", //const char * parent_function_name; +"__svml_cabsf16", //const char * variant_function_name; +337, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16", //const char * parent_function_name; +"__svml_cabsf16_ha", //const char * variant_function_name; +338, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16", //const char * parent_function_name; +"__svml_cabsf16_br", //const char * variant_function_name; +339, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16_mask", //const char * parent_function_name; +"__svml_cabsf16_ep_mask", //const char * variant_function_name; +340, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16_mask", //const char * parent_function_name; +"__svml_cabsf16_mask", //const char * variant_function_name; +341, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16_mask", //const char * parent_function_name; +"__svml_cabsf16_ha_mask", //const char * variant_function_name; +342, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf16_mask", //const char * parent_function_name; +"__svml_cabsf16_br_mask", //const char * variant_function_name; +343, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4", //const char * parent_function_name; +"__svml_cabsf4_ep", //const char * variant_function_name; +344, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4", //const char * parent_function_name; +"__svml_cabsf4", //const char * variant_function_name; +345, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4", //const char * parent_function_name; +"__svml_cabsf4_ha", //const char * variant_function_name; +346, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4", //const char * parent_function_name; +"__svml_cabsf4_br", //const char * variant_function_name; +347, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4_mask", //const char * parent_function_name; +"__svml_cabsf4_ep_mask", //const char * variant_function_name; +348, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4_mask", //const char * parent_function_name; +"__svml_cabsf4_mask", //const char * variant_function_name; +349, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4_mask", //const char * parent_function_name; +"__svml_cabsf4_ha_mask", //const char * variant_function_name; +350, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf4_mask", //const char * parent_function_name; +"__svml_cabsf4_br_mask", //const char * variant_function_name; +351, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8", //const char * parent_function_name; +"__svml_cabsf8_ep", //const char * variant_function_name; +352, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8", //const char * parent_function_name; +"__svml_cabsf8", //const char * variant_function_name; +353, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8", //const char * parent_function_name; +"__svml_cabsf8_ha", //const char * variant_function_name; +354, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8", //const char * parent_function_name; +"__svml_cabsf8_br", //const char * variant_function_name; +355, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8_mask", //const char * parent_function_name; +"__svml_cabsf8_ep_mask", //const char * variant_function_name; +356, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8_mask", //const char * parent_function_name; +"__svml_cabsf8_mask", //const char * variant_function_name; +357, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8_mask", //const char * parent_function_name; +"__svml_cabsf8_ha_mask", //const char * variant_function_name; +358, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsf8_mask", //const char * parent_function_name; +"__svml_cabsf8_br_mask", //const char * variant_function_name; +359, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2", //const char * parent_function_name; +"__svml_cabsh2_ep", //const char * variant_function_name; +360, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2", //const char * parent_function_name; +"__svml_cabsh2", //const char * variant_function_name; +361, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2", //const char * parent_function_name; +"__svml_cabsh2_ha", //const char * variant_function_name; +362, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2", //const char * parent_function_name; +"__svml_cabsh2_br", //const char * variant_function_name; +363, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2_mask", //const char * parent_function_name; +"__svml_cabsh2_ep_mask", //const char * variant_function_name; +364, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2_mask", //const char * parent_function_name; +"__svml_cabsh2_mask", //const char * variant_function_name; +365, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2_mask", //const char * parent_function_name; +"__svml_cabsh2_ha_mask", //const char * variant_function_name; +366, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh2_mask", //const char * parent_function_name; +"__svml_cabsh2_br_mask", //const char * variant_function_name; +367, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4", //const char * parent_function_name; +"__svml_cabsh4_ep", //const char * variant_function_name; +368, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4", //const char * parent_function_name; +"__svml_cabsh4", //const char * variant_function_name; +369, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4", //const char * parent_function_name; +"__svml_cabsh4_ha", //const char * variant_function_name; +370, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4", //const char * parent_function_name; +"__svml_cabsh4_br", //const char * variant_function_name; +371, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4_mask", //const char * parent_function_name; +"__svml_cabsh4_ep_mask", //const char * variant_function_name; +372, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4_mask", //const char * parent_function_name; +"__svml_cabsh4_mask", //const char * variant_function_name; +373, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4_mask", //const char * parent_function_name; +"__svml_cabsh4_ha_mask", //const char * variant_function_name; +374, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabsh4_mask", //const char * parent_function_name; +"__svml_cabsh4_br_mask", //const char * variant_function_name; +375, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2", //const char * parent_function_name; +"__svml_cabshf2_ep", //const char * variant_function_name; +376, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2", //const char * parent_function_name; +"__svml_cabshf2", //const char * variant_function_name; +377, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2", //const char * parent_function_name; +"__svml_cabshf2_ha", //const char * variant_function_name; +378, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2", //const char * parent_function_name; +"__svml_cabshf2_br", //const char * variant_function_name; +379, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2_mask", //const char * parent_function_name; +"__svml_cabshf2_ep_mask", //const char * variant_function_name; +380, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2_mask", //const char * parent_function_name; +"__svml_cabshf2_mask", //const char * variant_function_name; +381, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2_mask", //const char * parent_function_name; +"__svml_cabshf2_ha_mask", //const char * variant_function_name; +382, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf2_mask", //const char * parent_function_name; +"__svml_cabshf2_br_mask", //const char * variant_function_name; +383, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4", //const char * parent_function_name; +"__svml_cabshf4_ep", //const char * variant_function_name; +384, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4", //const char * parent_function_name; +"__svml_cabshf4", //const char * variant_function_name; +385, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4", //const char * parent_function_name; +"__svml_cabshf4_ha", //const char * variant_function_name; +386, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4", //const char * parent_function_name; +"__svml_cabshf4_br", //const char * variant_function_name; +387, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4_mask", //const char * parent_function_name; +"__svml_cabshf4_ep_mask", //const char * variant_function_name; +388, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4_mask", //const char * parent_function_name; +"__svml_cabshf4_mask", //const char * variant_function_name; +389, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4_mask", //const char * parent_function_name; +"__svml_cabshf4_ha_mask", //const char * variant_function_name; +390, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf4_mask", //const char * parent_function_name; +"__svml_cabshf4_br_mask", //const char * variant_function_name; +391, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8", //const char * parent_function_name; +"__svml_cabshf8_ep", //const char * variant_function_name; +392, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8", //const char * parent_function_name; +"__svml_cabshf8", //const char * variant_function_name; +393, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8", //const char * parent_function_name; +"__svml_cabshf8_ha", //const char * variant_function_name; +394, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8", //const char * parent_function_name; +"__svml_cabshf8_br", //const char * variant_function_name; +395, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8_mask", //const char * parent_function_name; +"__svml_cabshf8_ep_mask", //const char * variant_function_name; +396, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8_mask", //const char * parent_function_name; +"__svml_cabshf8_mask", //const char * variant_function_name; +397, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8_mask", //const char * parent_function_name; +"__svml_cabshf8_ha_mask", //const char * variant_function_name; +398, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cabshf8_mask", //const char * parent_function_name; +"__svml_cabshf8_br_mask", //const char * variant_function_name; +399, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf2", //const char * parent_function_name; +"__svml_cacosf2", //const char * variant_function_name; +400, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf2", //const char * parent_function_name; +"__svml_cacosf2", //const char * variant_function_name; +401, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf2_mask", //const char * parent_function_name; +"__svml_cacosf2_mask", //const char * variant_function_name; +402, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf2_mask", //const char * parent_function_name; +"__svml_cacosf2_mask", //const char * variant_function_name; +403, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf4", //const char * parent_function_name; +"__svml_cacosf4", //const char * variant_function_name; +404, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf4", //const char * parent_function_name; +"__svml_cacosf4", //const char * variant_function_name; +405, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf4_mask", //const char * parent_function_name; +"__svml_cacosf4_mask", //const char * variant_function_name; +406, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacosf4_mask", //const char * parent_function_name; +"__svml_cacosf4_mask", //const char * variant_function_name; +407, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf2", //const char * parent_function_name; +"__svml_cacoshf2", //const char * variant_function_name; +408, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf2", //const char * parent_function_name; +"__svml_cacoshf2", //const char * variant_function_name; +409, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf2_mask", //const char * parent_function_name; +"__svml_cacoshf2_mask", //const char * variant_function_name; +410, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf2_mask", //const char * parent_function_name; +"__svml_cacoshf2_mask", //const char * variant_function_name; +411, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf4", //const char * parent_function_name; +"__svml_cacoshf4", //const char * variant_function_name; +412, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf4", //const char * parent_function_name; +"__svml_cacoshf4", //const char * variant_function_name; +413, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf4_mask", //const char * parent_function_name; +"__svml_cacoshf4_mask", //const char * variant_function_name; +414, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cacoshf4_mask", //const char * parent_function_name; +"__svml_cacoshf4_mask", //const char * variant_function_name; +415, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf2", //const char * parent_function_name; +"__svml_casinf2", //const char * variant_function_name; +416, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf2", //const char * parent_function_name; +"__svml_casinf2", //const char * variant_function_name; +417, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf2_mask", //const char * parent_function_name; +"__svml_casinf2_mask", //const char * variant_function_name; +418, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf2_mask", //const char * parent_function_name; +"__svml_casinf2_mask", //const char * variant_function_name; +419, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf4", //const char * parent_function_name; +"__svml_casinf4", //const char * variant_function_name; +420, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf4", //const char * parent_function_name; +"__svml_casinf4", //const char * variant_function_name; +421, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf4_mask", //const char * parent_function_name; +"__svml_casinf4_mask", //const char * variant_function_name; +422, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinf4_mask", //const char * parent_function_name; +"__svml_casinf4_mask", //const char * variant_function_name; +423, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf2", //const char * parent_function_name; +"__svml_casinhf2", //const char * variant_function_name; +424, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf2", //const char * parent_function_name; +"__svml_casinhf2", //const char * variant_function_name; +425, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf2_mask", //const char * parent_function_name; +"__svml_casinhf2_mask", //const char * variant_function_name; +426, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf2_mask", //const char * parent_function_name; +"__svml_casinhf2_mask", //const char * variant_function_name; +427, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf4", //const char * parent_function_name; +"__svml_casinhf4", //const char * variant_function_name; +428, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf4", //const char * parent_function_name; +"__svml_casinhf4", //const char * variant_function_name; +429, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf4_mask", //const char * parent_function_name; +"__svml_casinhf4_mask", //const char * variant_function_name; +430, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_casinhf4_mask", //const char * parent_function_name; +"__svml_casinhf4_mask", //const char * variant_function_name; +431, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf2", //const char * parent_function_name; +"__svml_catanf2", //const char * variant_function_name; +432, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf2", //const char * parent_function_name; +"__svml_catanf2", //const char * variant_function_name; +433, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf2_mask", //const char * parent_function_name; +"__svml_catanf2_mask", //const char * variant_function_name; +434, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf2_mask", //const char * parent_function_name; +"__svml_catanf2_mask", //const char * variant_function_name; +435, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf4", //const char * parent_function_name; +"__svml_catanf4", //const char * variant_function_name; +436, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf4", //const char * parent_function_name; +"__svml_catanf4", //const char * variant_function_name; +437, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf4_mask", //const char * parent_function_name; +"__svml_catanf4_mask", //const char * variant_function_name; +438, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanf4_mask", //const char * parent_function_name; +"__svml_catanf4_mask", //const char * variant_function_name; +439, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf2", //const char * parent_function_name; +"__svml_catanhf2", //const char * variant_function_name; +440, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf2", //const char * parent_function_name; +"__svml_catanhf2", //const char * variant_function_name; +441, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf2_mask", //const char * parent_function_name; +"__svml_catanhf2_mask", //const char * variant_function_name; +442, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf2_mask", //const char * parent_function_name; +"__svml_catanhf2_mask", //const char * variant_function_name; +443, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf4", //const char * parent_function_name; +"__svml_catanhf4", //const char * variant_function_name; +444, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf4", //const char * parent_function_name; +"__svml_catanhf4", //const char * variant_function_name; +445, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf4_mask", //const char * parent_function_name; +"__svml_catanhf4_mask", //const char * variant_function_name; +446, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_catanhf4_mask", //const char * parent_function_name; +"__svml_catanhf4_mask", //const char * variant_function_name; +447, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2", //const char * parent_function_name; +"__svml_cbrt2_ep", //const char * variant_function_name; +448, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2", //const char * parent_function_name; +"__svml_cbrt2", //const char * variant_function_name; +449, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2", //const char * parent_function_name; +"__svml_cbrt2_ha", //const char * variant_function_name; +450, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2_mask", //const char * parent_function_name; +"__svml_cbrt2_ep_mask", //const char * variant_function_name; +451, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2_mask", //const char * parent_function_name; +"__svml_cbrt2_mask", //const char * variant_function_name; +452, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt2_mask", //const char * parent_function_name; +"__svml_cbrt2_ha_mask", //const char * variant_function_name; +453, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4", //const char * parent_function_name; +"__svml_cbrt4_ep", //const char * variant_function_name; +454, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4", //const char * parent_function_name; +"__svml_cbrt4", //const char * variant_function_name; +455, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4", //const char * parent_function_name; +"__svml_cbrt4_ha", //const char * variant_function_name; +456, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4", //const char * parent_function_name; +"__svml_cbrt4_br", //const char * variant_function_name; +457, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4_mask", //const char * parent_function_name; +"__svml_cbrt4_ep_mask", //const char * variant_function_name; +458, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4_mask", //const char * parent_function_name; +"__svml_cbrt4_mask", //const char * variant_function_name; +459, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4_mask", //const char * parent_function_name; +"__svml_cbrt4_ha_mask", //const char * variant_function_name; +460, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt4_mask", //const char * parent_function_name; +"__svml_cbrt4_br_mask", //const char * variant_function_name; +461, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8", //const char * parent_function_name; +"__svml_cbrt8_ep", //const char * variant_function_name; +462, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8", //const char * parent_function_name; +"__svml_cbrt8", //const char * variant_function_name; +463, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8", //const char * parent_function_name; +"__svml_cbrt8_ha", //const char * variant_function_name; +464, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8_mask", //const char * parent_function_name; +"__svml_cbrt8_ep_mask", //const char * variant_function_name; +465, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8_mask", //const char * parent_function_name; +"__svml_cbrt8_mask", //const char * variant_function_name; +466, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrt8_mask", //const char * parent_function_name; +"__svml_cbrt8_ha_mask", //const char * variant_function_name; +467, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16", //const char * parent_function_name; +"__svml_cbrtf16_ep", //const char * variant_function_name; +468, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16", //const char * parent_function_name; +"__svml_cbrtf16", //const char * variant_function_name; +469, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16", //const char * parent_function_name; +"__svml_cbrtf16_ha", //const char * variant_function_name; +470, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16_mask", //const char * parent_function_name; +"__svml_cbrtf16_ep_mask", //const char * variant_function_name; +471, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16_mask", //const char * parent_function_name; +"__svml_cbrtf16_mask", //const char * variant_function_name; +472, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf16_mask", //const char * parent_function_name; +"__svml_cbrtf16_ha_mask", //const char * variant_function_name; +473, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4", //const char * parent_function_name; +"__svml_cbrtf4_ep", //const char * variant_function_name; +474, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4", //const char * parent_function_name; +"__svml_cbrtf4", //const char * variant_function_name; +475, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4", //const char * parent_function_name; +"__svml_cbrtf4_ha", //const char * variant_function_name; +476, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4_mask", //const char * parent_function_name; +"__svml_cbrtf4_ep_mask", //const char * variant_function_name; +477, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4_mask", //const char * parent_function_name; +"__svml_cbrtf4_mask", //const char * variant_function_name; +478, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf4_mask", //const char * parent_function_name; +"__svml_cbrtf4_ha_mask", //const char * variant_function_name; +479, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8", //const char * parent_function_name; +"__svml_cbrtf8_ep", //const char * variant_function_name; +480, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8", //const char * parent_function_name; +"__svml_cbrtf8", //const char * variant_function_name; +481, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8", //const char * parent_function_name; +"__svml_cbrtf8_ha", //const char * variant_function_name; +482, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8", //const char * parent_function_name; +"__svml_cbrtf8_br", //const char * variant_function_name; +483, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8_mask", //const char * parent_function_name; +"__svml_cbrtf8_ep_mask", //const char * variant_function_name; +484, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8_mask", //const char * parent_function_name; +"__svml_cbrtf8_mask", //const char * variant_function_name; +485, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8_mask", //const char * parent_function_name; +"__svml_cbrtf8_ha_mask", //const char * variant_function_name; +486, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cbrtf8_mask", //const char * parent_function_name; +"__svml_cbrtf8_br_mask", //const char * variant_function_name; +487, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf2", //const char * parent_function_name; +"__svml_ccosf2", //const char * variant_function_name; +488, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf2", //const char * parent_function_name; +"__svml_ccosf2", //const char * variant_function_name; +489, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf2_mask", //const char * parent_function_name; +"__svml_ccosf2_mask", //const char * variant_function_name; +490, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf2_mask", //const char * parent_function_name; +"__svml_ccosf2_mask", //const char * variant_function_name; +491, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf4", //const char * parent_function_name; +"__svml_ccosf4", //const char * variant_function_name; +492, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf4", //const char * parent_function_name; +"__svml_ccosf4", //const char * variant_function_name; +493, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf4_mask", //const char * parent_function_name; +"__svml_ccosf4_mask", //const char * variant_function_name; +494, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccosf4_mask", //const char * parent_function_name; +"__svml_ccosf4_mask", //const char * variant_function_name; +495, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf2", //const char * parent_function_name; +"__svml_ccoshf2", //const char * variant_function_name; +496, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf2", //const char * parent_function_name; +"__svml_ccoshf2", //const char * variant_function_name; +497, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf2_mask", //const char * parent_function_name; +"__svml_ccoshf2_mask", //const char * variant_function_name; +498, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf2_mask", //const char * parent_function_name; +"__svml_ccoshf2_mask", //const char * variant_function_name; +499, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf4", //const char * parent_function_name; +"__svml_ccoshf4", //const char * variant_function_name; +500, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf4", //const char * parent_function_name; +"__svml_ccoshf4", //const char * variant_function_name; +501, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf4_mask", //const char * parent_function_name; +"__svml_ccoshf4_mask", //const char * variant_function_name; +502, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ccoshf4_mask", //const char * parent_function_name; +"__svml_ccoshf4_mask", //const char * variant_function_name; +503, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2", //const char * parent_function_name; +"__svml_cdfnorm2_ep", //const char * variant_function_name; +504, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2", //const char * parent_function_name; +"__svml_cdfnorm2", //const char * variant_function_name; +505, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2", //const char * parent_function_name; +"__svml_cdfnorm2_ha", //const char * variant_function_name; +506, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2_mask", //const char * parent_function_name; +"__svml_cdfnorm2_ep_mask", //const char * variant_function_name; +507, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2_mask", //const char * parent_function_name; +"__svml_cdfnorm2_mask", //const char * variant_function_name; +508, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm2_mask", //const char * parent_function_name; +"__svml_cdfnorm2_ha_mask", //const char * variant_function_name; +509, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4", //const char * parent_function_name; +"__svml_cdfnorm4_ep", //const char * variant_function_name; +510, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4", //const char * parent_function_name; +"__svml_cdfnorm4", //const char * variant_function_name; +511, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4", //const char * parent_function_name; +"__svml_cdfnorm4_ha", //const char * variant_function_name; +512, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4", //const char * parent_function_name; +"__svml_cdfnorm4_br", //const char * variant_function_name; +513, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4_mask", //const char * parent_function_name; +"__svml_cdfnorm4_ep_mask", //const char * variant_function_name; +514, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4_mask", //const char * parent_function_name; +"__svml_cdfnorm4_mask", //const char * variant_function_name; +515, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4_mask", //const char * parent_function_name; +"__svml_cdfnorm4_ha_mask", //const char * variant_function_name; +516, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm4_mask", //const char * parent_function_name; +"__svml_cdfnorm4_br_mask", //const char * variant_function_name; +517, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8", //const char * parent_function_name; +"__svml_cdfnorm8_ep", //const char * variant_function_name; +518, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8", //const char * parent_function_name; +"__svml_cdfnorm8", //const char * variant_function_name; +519, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8", //const char * parent_function_name; +"__svml_cdfnorm8_ha", //const char * variant_function_name; +520, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8_mask", //const char * parent_function_name; +"__svml_cdfnorm8_ep_mask", //const char * variant_function_name; +521, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8_mask", //const char * parent_function_name; +"__svml_cdfnorm8_mask", //const char * variant_function_name; +522, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorm8_mask", //const char * parent_function_name; +"__svml_cdfnorm8_ha_mask", //const char * variant_function_name; +523, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16", //const char * parent_function_name; +"__svml_cdfnormf16_ep", //const char * variant_function_name; +524, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16", //const char * parent_function_name; +"__svml_cdfnormf16", //const char * variant_function_name; +525, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16", //const char * parent_function_name; +"__svml_cdfnormf16_ha", //const char * variant_function_name; +526, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16_mask", //const char * parent_function_name; +"__svml_cdfnormf16_ep_mask", //const char * variant_function_name; +527, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16_mask", //const char * parent_function_name; +"__svml_cdfnormf16_mask", //const char * variant_function_name; +528, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf16_mask", //const char * parent_function_name; +"__svml_cdfnormf16_ha_mask", //const char * variant_function_name; +529, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4", //const char * parent_function_name; +"__svml_cdfnormf4_ep", //const char * variant_function_name; +530, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4", //const char * parent_function_name; +"__svml_cdfnormf4", //const char * variant_function_name; +531, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4", //const char * parent_function_name; +"__svml_cdfnormf4_ha", //const char * variant_function_name; +532, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4_mask", //const char * parent_function_name; +"__svml_cdfnormf4_ep_mask", //const char * variant_function_name; +533, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4_mask", //const char * parent_function_name; +"__svml_cdfnormf4_mask", //const char * variant_function_name; +534, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf4_mask", //const char * parent_function_name; +"__svml_cdfnormf4_ha_mask", //const char * variant_function_name; +535, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8", //const char * parent_function_name; +"__svml_cdfnormf8_ep", //const char * variant_function_name; +536, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8", //const char * parent_function_name; +"__svml_cdfnormf8", //const char * variant_function_name; +537, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8", //const char * parent_function_name; +"__svml_cdfnormf8_ha", //const char * variant_function_name; +538, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8", //const char * parent_function_name; +"__svml_cdfnormf8_br", //const char * variant_function_name; +539, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8_mask", //const char * parent_function_name; +"__svml_cdfnormf8_ep_mask", //const char * variant_function_name; +540, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8_mask", //const char * parent_function_name; +"__svml_cdfnormf8_mask", //const char * variant_function_name; +541, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8_mask", //const char * parent_function_name; +"__svml_cdfnormf8_ha_mask", //const char * variant_function_name; +542, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnormf8_mask", //const char * parent_function_name; +"__svml_cdfnormf8_br_mask", //const char * variant_function_name; +543, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2", //const char * parent_function_name; +"__svml_cdfnorminv2_ep", //const char * variant_function_name; +544, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2", //const char * parent_function_name; +"__svml_cdfnorminv2", //const char * variant_function_name; +545, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2", //const char * parent_function_name; +"__svml_cdfnorminv2_ha", //const char * variant_function_name; +546, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2_mask", //const char * parent_function_name; +"__svml_cdfnorminv2_ep_mask", //const char * variant_function_name; +547, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2_mask", //const char * parent_function_name; +"__svml_cdfnorminv2_mask", //const char * variant_function_name; +548, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv2_mask", //const char * parent_function_name; +"__svml_cdfnorminv2_ha_mask", //const char * variant_function_name; +549, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4", //const char * parent_function_name; +"__svml_cdfnorminv4_ep", //const char * variant_function_name; +550, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4", //const char * parent_function_name; +"__svml_cdfnorminv4", //const char * variant_function_name; +551, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4", //const char * parent_function_name; +"__svml_cdfnorminv4_ha", //const char * variant_function_name; +552, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4", //const char * parent_function_name; +"__svml_cdfnorminv4_br", //const char * variant_function_name; +553, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4_mask", //const char * parent_function_name; +"__svml_cdfnorminv4_ep_mask", //const char * variant_function_name; +554, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4_mask", //const char * parent_function_name; +"__svml_cdfnorminv4_mask", //const char * variant_function_name; +555, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4_mask", //const char * parent_function_name; +"__svml_cdfnorminv4_ha_mask", //const char * variant_function_name; +556, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv4_mask", //const char * parent_function_name; +"__svml_cdfnorminv4_br_mask", //const char * variant_function_name; +557, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8", //const char * parent_function_name; +"__svml_cdfnorminv8_ep", //const char * variant_function_name; +558, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8", //const char * parent_function_name; +"__svml_cdfnorminv8", //const char * variant_function_name; +559, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8", //const char * parent_function_name; +"__svml_cdfnorminv8_ha", //const char * variant_function_name; +560, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8_mask", //const char * parent_function_name; +"__svml_cdfnorminv8_ep_mask", //const char * variant_function_name; +561, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8_mask", //const char * parent_function_name; +"__svml_cdfnorminv8_mask", //const char * variant_function_name; +562, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminv8_mask", //const char * parent_function_name; +"__svml_cdfnorminv8_ha_mask", //const char * variant_function_name; +563, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16", //const char * parent_function_name; +"__svml_cdfnorminvf16_ep", //const char * variant_function_name; +564, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16", //const char * parent_function_name; +"__svml_cdfnorminvf16", //const char * variant_function_name; +565, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16", //const char * parent_function_name; +"__svml_cdfnorminvf16_ha", //const char * variant_function_name; +566, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16_mask", //const char * parent_function_name; +"__svml_cdfnorminvf16_ep_mask", //const char * variant_function_name; +567, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16_mask", //const char * parent_function_name; +"__svml_cdfnorminvf16_mask", //const char * variant_function_name; +568, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf16_mask", //const char * parent_function_name; +"__svml_cdfnorminvf16_ha_mask", //const char * variant_function_name; +569, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4", //const char * parent_function_name; +"__svml_cdfnorminvf4_ep", //const char * variant_function_name; +570, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4", //const char * parent_function_name; +"__svml_cdfnorminvf4", //const char * variant_function_name; +571, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4", //const char * parent_function_name; +"__svml_cdfnorminvf4_ha", //const char * variant_function_name; +572, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4_mask", //const char * parent_function_name; +"__svml_cdfnorminvf4_ep_mask", //const char * variant_function_name; +573, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4_mask", //const char * parent_function_name; +"__svml_cdfnorminvf4_mask", //const char * variant_function_name; +574, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf4_mask", //const char * parent_function_name; +"__svml_cdfnorminvf4_ha_mask", //const char * variant_function_name; +575, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8", //const char * parent_function_name; +"__svml_cdfnorminvf8_ep", //const char * variant_function_name; +576, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8", //const char * parent_function_name; +"__svml_cdfnorminvf8", //const char * variant_function_name; +577, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8", //const char * parent_function_name; +"__svml_cdfnorminvf8_ha", //const char * variant_function_name; +578, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8", //const char * parent_function_name; +"__svml_cdfnorminvf8_br", //const char * variant_function_name; +579, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8_mask", //const char * parent_function_name; +"__svml_cdfnorminvf8_ep_mask", //const char * variant_function_name; +580, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8_mask", //const char * parent_function_name; +"__svml_cdfnorminvf8_mask", //const char * variant_function_name; +581, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8_mask", //const char * parent_function_name; +"__svml_cdfnorminvf8_ha_mask", //const char * variant_function_name; +582, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdfnorminvf8_mask", //const char * parent_function_name; +"__svml_cdfnorminvf8_br_mask", //const char * variant_function_name; +583, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2", //const char * parent_function_name; +"__svml_cdiv2_ep", //const char * variant_function_name; +584, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2", //const char * parent_function_name; +"__svml_cdiv2", //const char * variant_function_name; +585, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2", //const char * parent_function_name; +"__svml_cdiv2_ha", //const char * variant_function_name; +586, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2", //const char * parent_function_name; +"__svml_cdiv2_br", //const char * variant_function_name; +587, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2_mask", //const char * parent_function_name; +"__svml_cdiv2_ep_mask", //const char * variant_function_name; +588, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2_mask", //const char * parent_function_name; +"__svml_cdiv2_mask", //const char * variant_function_name; +589, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2_mask", //const char * parent_function_name; +"__svml_cdiv2_ha_mask", //const char * variant_function_name; +590, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv2_mask", //const char * parent_function_name; +"__svml_cdiv2_br_mask", //const char * variant_function_name; +591, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4", //const char * parent_function_name; +"__svml_cdiv4_ep", //const char * variant_function_name; +592, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4", //const char * parent_function_name; +"__svml_cdiv4", //const char * variant_function_name; +593, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4", //const char * parent_function_name; +"__svml_cdiv4_ha", //const char * variant_function_name; +594, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4", //const char * parent_function_name; +"__svml_cdiv4_br", //const char * variant_function_name; +595, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4_mask", //const char * parent_function_name; +"__svml_cdiv4_ep_mask", //const char * variant_function_name; +596, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4_mask", //const char * parent_function_name; +"__svml_cdiv4_mask", //const char * variant_function_name; +597, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4_mask", //const char * parent_function_name; +"__svml_cdiv4_ha_mask", //const char * variant_function_name; +598, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv4_mask", //const char * parent_function_name; +"__svml_cdiv4_br_mask", //const char * variant_function_name; +599, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8", //const char * parent_function_name; +"__svml_cdiv8_ep", //const char * variant_function_name; +600, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8", //const char * parent_function_name; +"__svml_cdiv8", //const char * variant_function_name; +601, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8", //const char * parent_function_name; +"__svml_cdiv8_ha", //const char * variant_function_name; +602, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8", //const char * parent_function_name; +"__svml_cdiv8_br", //const char * variant_function_name; +603, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8_mask", //const char * parent_function_name; +"__svml_cdiv8_ep_mask", //const char * variant_function_name; +604, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8_mask", //const char * parent_function_name; +"__svml_cdiv8_mask", //const char * variant_function_name; +605, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8_mask", //const char * parent_function_name; +"__svml_cdiv8_ha_mask", //const char * variant_function_name; +606, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdiv8_mask", //const char * parent_function_name; +"__svml_cdiv8_br_mask", //const char * variant_function_name; +607, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16", //const char * parent_function_name; +"__svml_cdivf16_ep", //const char * variant_function_name; +608, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16", //const char * parent_function_name; +"__svml_cdivf16", //const char * variant_function_name; +609, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16", //const char * parent_function_name; +"__svml_cdivf16_ha", //const char * variant_function_name; +610, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16", //const char * parent_function_name; +"__svml_cdivf16_br", //const char * variant_function_name; +611, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16_mask", //const char * parent_function_name; +"__svml_cdivf16_ep_mask", //const char * variant_function_name; +612, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16_mask", //const char * parent_function_name; +"__svml_cdivf16_mask", //const char * variant_function_name; +613, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16_mask", //const char * parent_function_name; +"__svml_cdivf16_ha_mask", //const char * variant_function_name; +614, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf16_mask", //const char * parent_function_name; +"__svml_cdivf16_br_mask", //const char * variant_function_name; +615, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4", //const char * parent_function_name; +"__svml_cdivf4_ep", //const char * variant_function_name; +616, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4", //const char * parent_function_name; +"__svml_cdivf4", //const char * variant_function_name; +617, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4", //const char * parent_function_name; +"__svml_cdivf4_ha", //const char * variant_function_name; +618, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4", //const char * parent_function_name; +"__svml_cdivf4_br", //const char * variant_function_name; +619, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4_mask", //const char * parent_function_name; +"__svml_cdivf4_ep_mask", //const char * variant_function_name; +620, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4_mask", //const char * parent_function_name; +"__svml_cdivf4_mask", //const char * variant_function_name; +621, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4_mask", //const char * parent_function_name; +"__svml_cdivf4_ha_mask", //const char * variant_function_name; +622, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf4_mask", //const char * parent_function_name; +"__svml_cdivf4_br_mask", //const char * variant_function_name; +623, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8", //const char * parent_function_name; +"__svml_cdivf8_ep", //const char * variant_function_name; +624, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8", //const char * parent_function_name; +"__svml_cdivf8", //const char * variant_function_name; +625, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8", //const char * parent_function_name; +"__svml_cdivf8_ha", //const char * variant_function_name; +626, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8", //const char * parent_function_name; +"__svml_cdivf8_br", //const char * variant_function_name; +627, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8_mask", //const char * parent_function_name; +"__svml_cdivf8_ep_mask", //const char * variant_function_name; +628, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8_mask", //const char * parent_function_name; +"__svml_cdivf8_mask", //const char * variant_function_name; +629, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8_mask", //const char * parent_function_name; +"__svml_cdivf8_ha_mask", //const char * variant_function_name; +630, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivf8_mask", //const char * parent_function_name; +"__svml_cdivf8_br_mask", //const char * variant_function_name; +631, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2", //const char * parent_function_name; +"__svml_cdivh2_ep", //const char * variant_function_name; +632, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2", //const char * parent_function_name; +"__svml_cdivh2", //const char * variant_function_name; +633, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2", //const char * parent_function_name; +"__svml_cdivh2_ha", //const char * variant_function_name; +634, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2", //const char * parent_function_name; +"__svml_cdivh2_br", //const char * variant_function_name; +635, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2_mask", //const char * parent_function_name; +"__svml_cdivh2_ep_mask", //const char * variant_function_name; +636, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2_mask", //const char * parent_function_name; +"__svml_cdivh2_mask", //const char * variant_function_name; +637, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2_mask", //const char * parent_function_name; +"__svml_cdivh2_ha_mask", //const char * variant_function_name; +638, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh2_mask", //const char * parent_function_name; +"__svml_cdivh2_br_mask", //const char * variant_function_name; +639, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4", //const char * parent_function_name; +"__svml_cdivh4_ep", //const char * variant_function_name; +640, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4", //const char * parent_function_name; +"__svml_cdivh4", //const char * variant_function_name; +641, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4", //const char * parent_function_name; +"__svml_cdivh4_ha", //const char * variant_function_name; +642, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4", //const char * parent_function_name; +"__svml_cdivh4_br", //const char * variant_function_name; +643, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4_mask", //const char * parent_function_name; +"__svml_cdivh4_ep_mask", //const char * variant_function_name; +644, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4_mask", //const char * parent_function_name; +"__svml_cdivh4_mask", //const char * variant_function_name; +645, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4_mask", //const char * parent_function_name; +"__svml_cdivh4_ha_mask", //const char * variant_function_name; +646, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivh4_mask", //const char * parent_function_name; +"__svml_cdivh4_br_mask", //const char * variant_function_name; +647, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2", //const char * parent_function_name; +"__svml_cdivhf2_ep", //const char * variant_function_name; +648, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2", //const char * parent_function_name; +"__svml_cdivhf2", //const char * variant_function_name; +649, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2", //const char * parent_function_name; +"__svml_cdivhf2_ha", //const char * variant_function_name; +650, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2", //const char * parent_function_name; +"__svml_cdivhf2_br", //const char * variant_function_name; +651, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2_mask", //const char * parent_function_name; +"__svml_cdivhf2_ep_mask", //const char * variant_function_name; +652, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2_mask", //const char * parent_function_name; +"__svml_cdivhf2_mask", //const char * variant_function_name; +653, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2_mask", //const char * parent_function_name; +"__svml_cdivhf2_ha_mask", //const char * variant_function_name; +654, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf2_mask", //const char * parent_function_name; +"__svml_cdivhf2_br_mask", //const char * variant_function_name; +655, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4", //const char * parent_function_name; +"__svml_cdivhf4_ep", //const char * variant_function_name; +656, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4", //const char * parent_function_name; +"__svml_cdivhf4", //const char * variant_function_name; +657, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4", //const char * parent_function_name; +"__svml_cdivhf4_ha", //const char * variant_function_name; +658, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4", //const char * parent_function_name; +"__svml_cdivhf4_br", //const char * variant_function_name; +659, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4_mask", //const char * parent_function_name; +"__svml_cdivhf4_ep_mask", //const char * variant_function_name; +660, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4_mask", //const char * parent_function_name; +"__svml_cdivhf4_mask", //const char * variant_function_name; +661, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4_mask", //const char * parent_function_name; +"__svml_cdivhf4_ha_mask", //const char * variant_function_name; +662, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf4_mask", //const char * parent_function_name; +"__svml_cdivhf4_br_mask", //const char * variant_function_name; +663, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8", //const char * parent_function_name; +"__svml_cdivhf8_ep", //const char * variant_function_name; +664, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8", //const char * parent_function_name; +"__svml_cdivhf8", //const char * variant_function_name; +665, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8", //const char * parent_function_name; +"__svml_cdivhf8_ha", //const char * variant_function_name; +666, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8", //const char * parent_function_name; +"__svml_cdivhf8_br", //const char * variant_function_name; +667, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8_mask", //const char * parent_function_name; +"__svml_cdivhf8_ep_mask", //const char * variant_function_name; +668, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8_mask", //const char * parent_function_name; +"__svml_cdivhf8_mask", //const char * variant_function_name; +669, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8_mask", //const char * parent_function_name; +"__svml_cdivhf8_ha_mask", //const char * variant_function_name; +670, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cdivhf8_mask", //const char * parent_function_name; +"__svml_cdivhf8_br_mask", //const char * variant_function_name; +671, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil2", //const char * parent_function_name; +"__svml_ceil2", //const char * variant_function_name; +672, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil2_mask", //const char * parent_function_name; +"__svml_ceil2_mask", //const char * variant_function_name; +673, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil4", //const char * parent_function_name; +"__svml_ceil4", //const char * variant_function_name; +674, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil4_mask", //const char * parent_function_name; +"__svml_ceil4_mask", //const char * variant_function_name; +675, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil8", //const char * parent_function_name; +"__svml_ceil8", //const char * variant_function_name; +676, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceil8_mask", //const char * parent_function_name; +"__svml_ceil8_mask", //const char * variant_function_name; +677, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf16", //const char * parent_function_name; +"__svml_ceilf16", //const char * variant_function_name; +678, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf16_mask", //const char * parent_function_name; +"__svml_ceilf16_mask", //const char * variant_function_name; +679, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf4", //const char * parent_function_name; +"__svml_ceilf4", //const char * variant_function_name; +680, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf4_mask", //const char * parent_function_name; +"__svml_ceilf4_mask", //const char * variant_function_name; +681, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf8", //const char * parent_function_name; +"__svml_ceilf8", //const char * variant_function_name; +682, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ceilf8_mask", //const char * parent_function_name; +"__svml_ceilf8_mask", //const char * variant_function_name; +683, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp2", //const char * parent_function_name; +"__svml_cexp2", //const char * variant_function_name; +684, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp2", //const char * parent_function_name; +"__svml_cexp2", //const char * variant_function_name; +685, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp2_mask", //const char * parent_function_name; +"__svml_cexp2_mask", //const char * variant_function_name; +686, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp2_mask", //const char * parent_function_name; +"__svml_cexp2_mask", //const char * variant_function_name; +687, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp4", //const char * parent_function_name; +"__svml_cexp4", //const char * variant_function_name; +688, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp4", //const char * parent_function_name; +"__svml_cexp4", //const char * variant_function_name; +689, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp4_mask", //const char * parent_function_name; +"__svml_cexp4_mask", //const char * variant_function_name; +690, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexp4_mask", //const char * parent_function_name; +"__svml_cexp4_mask", //const char * variant_function_name; +691, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2", //const char * parent_function_name; +"__svml_cexpf2", //const char * variant_function_name; +692, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2", //const char * parent_function_name; +"__svml_cexpf2", //const char * variant_function_name; +693, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2", //const char * parent_function_name; +"__svml_cexpf2_ha", //const char * variant_function_name; +694, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2_mask", //const char * parent_function_name; +"__svml_cexpf2_mask", //const char * variant_function_name; +695, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2_mask", //const char * parent_function_name; +"__svml_cexpf2_mask", //const char * variant_function_name; +696, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf2_mask", //const char * parent_function_name; +"__svml_cexpf2_ha_mask", //const char * variant_function_name; +697, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4", //const char * parent_function_name; +"__svml_cexpf4", //const char * variant_function_name; +698, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4", //const char * parent_function_name; +"__svml_cexpf4", //const char * variant_function_name; +699, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4", //const char * parent_function_name; +"__svml_cexpf4_ha", //const char * variant_function_name; +700, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4_mask", //const char * parent_function_name; +"__svml_cexpf4_mask", //const char * variant_function_name; +701, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4_mask", //const char * parent_function_name; +"__svml_cexpf4_mask", //const char * variant_function_name; +702, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf4_mask", //const char * parent_function_name; +"__svml_cexpf4_ha_mask", //const char * variant_function_name; +703, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8", //const char * parent_function_name; +"__svml_cexpf8", //const char * variant_function_name; +704, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8", //const char * parent_function_name; +"__svml_cexpf8", //const char * variant_function_name; +705, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8", //const char * parent_function_name; +"__svml_cexpf8_ha", //const char * variant_function_name; +706, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8_mask", //const char * parent_function_name; +"__svml_cexpf8_mask", //const char * variant_function_name; +707, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8_mask", //const char * parent_function_name; +"__svml_cexpf8_mask", //const char * variant_function_name; +708, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cexpf8_mask", //const char * parent_function_name; +"__svml_cexpf8_ha_mask", //const char * variant_function_name; +709, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f2", //const char * parent_function_name; +"__svml_clog10f2", //const char * variant_function_name; +710, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f2", //const char * parent_function_name; +"__svml_clog10f2", //const char * variant_function_name; +711, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f2_mask", //const char * parent_function_name; +"__svml_clog10f2_mask", //const char * variant_function_name; +712, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f2_mask", //const char * parent_function_name; +"__svml_clog10f2_mask", //const char * variant_function_name; +713, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f4", //const char * parent_function_name; +"__svml_clog10f4", //const char * variant_function_name; +714, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f4", //const char * parent_function_name; +"__svml_clog10f4", //const char * variant_function_name; +715, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f4_mask", //const char * parent_function_name; +"__svml_clog10f4_mask", //const char * variant_function_name; +716, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog10f4_mask", //const char * parent_function_name; +"__svml_clog10f4_mask", //const char * variant_function_name; +717, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2", //const char * parent_function_name; +"__svml_clog2", //const char * variant_function_name; +718, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2", //const char * parent_function_name; +"__svml_clog2", //const char * variant_function_name; +719, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2", //const char * parent_function_name; +"__svml_clog2_ha", //const char * variant_function_name; +720, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2_mask", //const char * parent_function_name; +"__svml_clog2_mask", //const char * variant_function_name; +721, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2_mask", //const char * parent_function_name; +"__svml_clog2_mask", //const char * variant_function_name; +722, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2_mask", //const char * parent_function_name; +"__svml_clog2_ha_mask", //const char * variant_function_name; +723, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f2", //const char * parent_function_name; +"__svml_clog2f2", //const char * variant_function_name; +724, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f2", //const char * parent_function_name; +"__svml_clog2f2", //const char * variant_function_name; +725, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f2_mask", //const char * parent_function_name; +"__svml_clog2f2_mask", //const char * variant_function_name; +726, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f2_mask", //const char * parent_function_name; +"__svml_clog2f2_mask", //const char * variant_function_name; +727, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f4", //const char * parent_function_name; +"__svml_clog2f4", //const char * variant_function_name; +728, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f4", //const char * parent_function_name; +"__svml_clog2f4", //const char * variant_function_name; +729, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f4_mask", //const char * parent_function_name; +"__svml_clog2f4_mask", //const char * variant_function_name; +730, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog2f4_mask", //const char * parent_function_name; +"__svml_clog2f4_mask", //const char * variant_function_name; +731, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4", //const char * parent_function_name; +"__svml_clog4", //const char * variant_function_name; +732, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4", //const char * parent_function_name; +"__svml_clog4", //const char * variant_function_name; +733, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4", //const char * parent_function_name; +"__svml_clog4_ha", //const char * variant_function_name; +734, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4_mask", //const char * parent_function_name; +"__svml_clog4_mask", //const char * variant_function_name; +735, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4_mask", //const char * parent_function_name; +"__svml_clog4_mask", //const char * variant_function_name; +736, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clog4_mask", //const char * parent_function_name; +"__svml_clog4_ha_mask", //const char * variant_function_name; +737, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2", //const char * parent_function_name; +"__svml_clogf2_ep", //const char * variant_function_name; +738, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2", //const char * parent_function_name; +"__svml_clogf2", //const char * variant_function_name; +739, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2", //const char * parent_function_name; +"__svml_clogf2_ha", //const char * variant_function_name; +740, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2_mask", //const char * parent_function_name; +"__svml_clogf2_ep_mask", //const char * variant_function_name; +741, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2_mask", //const char * parent_function_name; +"__svml_clogf2_mask", //const char * variant_function_name; +742, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf2_mask", //const char * parent_function_name; +"__svml_clogf2_ha_mask", //const char * variant_function_name; +743, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4", //const char * parent_function_name; +"__svml_clogf4_ep", //const char * variant_function_name; +744, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4", //const char * parent_function_name; +"__svml_clogf4", //const char * variant_function_name; +745, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4", //const char * parent_function_name; +"__svml_clogf4_ha", //const char * variant_function_name; +746, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4_mask", //const char * parent_function_name; +"__svml_clogf4_ep_mask", //const char * variant_function_name; +747, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4_mask", //const char * parent_function_name; +"__svml_clogf4_mask", //const char * variant_function_name; +748, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf4_mask", //const char * parent_function_name; +"__svml_clogf4_ha_mask", //const char * variant_function_name; +749, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8", //const char * parent_function_name; +"__svml_clogf8_ep", //const char * variant_function_name; +750, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8", //const char * parent_function_name; +"__svml_clogf8", //const char * variant_function_name; +751, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8", //const char * parent_function_name; +"__svml_clogf8_ha", //const char * variant_function_name; +752, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8_mask", //const char * parent_function_name; +"__svml_clogf8_ep_mask", //const char * variant_function_name; +753, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8_mask", //const char * parent_function_name; +"__svml_clogf8_mask", //const char * variant_function_name; +754, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_clogf8_mask", //const char * parent_function_name; +"__svml_clogf8_ha_mask", //const char * variant_function_name; +755, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2", //const char * parent_function_name; +"__svml_cos2_ep", //const char * variant_function_name; +756, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2", //const char * parent_function_name; +"__svml_cos2", //const char * variant_function_name; +757, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2", //const char * parent_function_name; +"__svml_cos2_ha", //const char * variant_function_name; +758, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2_mask", //const char * parent_function_name; +"__svml_cos2_ep_mask", //const char * variant_function_name; +759, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2_mask", //const char * parent_function_name; +"__svml_cos2_mask", //const char * variant_function_name; +760, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos2_mask", //const char * parent_function_name; +"__svml_cos2_ha_mask", //const char * variant_function_name; +761, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4", //const char * parent_function_name; +"__svml_cos4_ep", //const char * variant_function_name; +762, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4", //const char * parent_function_name; +"__svml_cos4", //const char * variant_function_name; +763, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4", //const char * parent_function_name; +"__svml_cos4_ha", //const char * variant_function_name; +764, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4", //const char * parent_function_name; +"__svml_cos4_br", //const char * variant_function_name; +765, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4_mask", //const char * parent_function_name; +"__svml_cos4_ep_mask", //const char * variant_function_name; +766, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4_mask", //const char * parent_function_name; +"__svml_cos4_mask", //const char * variant_function_name; +767, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4_mask", //const char * parent_function_name; +"__svml_cos4_ha_mask", //const char * variant_function_name; +768, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos4_mask", //const char * parent_function_name; +"__svml_cos4_br_mask", //const char * variant_function_name; +769, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8", //const char * parent_function_name; +"__svml_cos8_ep", //const char * variant_function_name; +770, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8", //const char * parent_function_name; +"__svml_cos8", //const char * variant_function_name; +771, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8", //const char * parent_function_name; +"__svml_cos8_ha", //const char * variant_function_name; +772, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8_mask", //const char * parent_function_name; +"__svml_cos8_ep_mask", //const char * variant_function_name; +773, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8_mask", //const char * parent_function_name; +"__svml_cos8_mask", //const char * variant_function_name; +774, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cos8_mask", //const char * parent_function_name; +"__svml_cos8_ha_mask", //const char * variant_function_name; +775, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2", //const char * parent_function_name; +"__svml_cosd2_ep", //const char * variant_function_name; +776, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2", //const char * parent_function_name; +"__svml_cosd2", //const char * variant_function_name; +777, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2", //const char * parent_function_name; +"__svml_cosd2_ha", //const char * variant_function_name; +778, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2_mask", //const char * parent_function_name; +"__svml_cosd2_ep_mask", //const char * variant_function_name; +779, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2_mask", //const char * parent_function_name; +"__svml_cosd2_mask", //const char * variant_function_name; +780, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd2_mask", //const char * parent_function_name; +"__svml_cosd2_ha_mask", //const char * variant_function_name; +781, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4", //const char * parent_function_name; +"__svml_cosd4_ep", //const char * variant_function_name; +782, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4", //const char * parent_function_name; +"__svml_cosd4", //const char * variant_function_name; +783, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4", //const char * parent_function_name; +"__svml_cosd4_ha", //const char * variant_function_name; +784, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4", //const char * parent_function_name; +"__svml_cosd4_br", //const char * variant_function_name; +785, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4_mask", //const char * parent_function_name; +"__svml_cosd4_ep_mask", //const char * variant_function_name; +786, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4_mask", //const char * parent_function_name; +"__svml_cosd4_mask", //const char * variant_function_name; +787, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4_mask", //const char * parent_function_name; +"__svml_cosd4_ha_mask", //const char * variant_function_name; +788, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd4_mask", //const char * parent_function_name; +"__svml_cosd4_br_mask", //const char * variant_function_name; +789, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8", //const char * parent_function_name; +"__svml_cosd8_ep", //const char * variant_function_name; +790, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8", //const char * parent_function_name; +"__svml_cosd8", //const char * variant_function_name; +791, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8", //const char * parent_function_name; +"__svml_cosd8_ha", //const char * variant_function_name; +792, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8_mask", //const char * parent_function_name; +"__svml_cosd8_ep_mask", //const char * variant_function_name; +793, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8_mask", //const char * parent_function_name; +"__svml_cosd8_mask", //const char * variant_function_name; +794, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosd8_mask", //const char * parent_function_name; +"__svml_cosd8_ha_mask", //const char * variant_function_name; +795, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16", //const char * parent_function_name; +"__svml_cosdf16_ep", //const char * variant_function_name; +796, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16", //const char * parent_function_name; +"__svml_cosdf16", //const char * variant_function_name; +797, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16", //const char * parent_function_name; +"__svml_cosdf16_ha", //const char * variant_function_name; +798, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16_mask", //const char * parent_function_name; +"__svml_cosdf16_ep_mask", //const char * variant_function_name; +799, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16_mask", //const char * parent_function_name; +"__svml_cosdf16_mask", //const char * variant_function_name; +800, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf16_mask", //const char * parent_function_name; +"__svml_cosdf16_ha_mask", //const char * variant_function_name; +801, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4", //const char * parent_function_name; +"__svml_cosdf4_ep", //const char * variant_function_name; +802, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4", //const char * parent_function_name; +"__svml_cosdf4", //const char * variant_function_name; +803, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4", //const char * parent_function_name; +"__svml_cosdf4_ha", //const char * variant_function_name; +804, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4_mask", //const char * parent_function_name; +"__svml_cosdf4_ep_mask", //const char * variant_function_name; +805, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4_mask", //const char * parent_function_name; +"__svml_cosdf4_mask", //const char * variant_function_name; +806, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf4_mask", //const char * parent_function_name; +"__svml_cosdf4_ha_mask", //const char * variant_function_name; +807, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8", //const char * parent_function_name; +"__svml_cosdf8_ep", //const char * variant_function_name; +808, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8", //const char * parent_function_name; +"__svml_cosdf8", //const char * variant_function_name; +809, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8", //const char * parent_function_name; +"__svml_cosdf8_ha", //const char * variant_function_name; +810, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8", //const char * parent_function_name; +"__svml_cosdf8_br", //const char * variant_function_name; +811, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8_mask", //const char * parent_function_name; +"__svml_cosdf8_ep_mask", //const char * variant_function_name; +812, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8_mask", //const char * parent_function_name; +"__svml_cosdf8_mask", //const char * variant_function_name; +813, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8_mask", //const char * parent_function_name; +"__svml_cosdf8_ha_mask", //const char * variant_function_name; +814, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosdf8_mask", //const char * parent_function_name; +"__svml_cosdf8_br_mask", //const char * variant_function_name; +815, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16", //const char * parent_function_name; +"__svml_cosf16_ep", //const char * variant_function_name; +816, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16", //const char * parent_function_name; +"__svml_cosf16", //const char * variant_function_name; +817, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16", //const char * parent_function_name; +"__svml_cosf16_ha", //const char * variant_function_name; +818, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16_mask", //const char * parent_function_name; +"__svml_cosf16_ep_mask", //const char * variant_function_name; +819, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16_mask", //const char * parent_function_name; +"__svml_cosf16_mask", //const char * variant_function_name; +820, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf16_mask", //const char * parent_function_name; +"__svml_cosf16_ha_mask", //const char * variant_function_name; +821, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4", //const char * parent_function_name; +"__svml_cosf4_ep", //const char * variant_function_name; +822, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4", //const char * parent_function_name; +"__svml_cosf4", //const char * variant_function_name; +823, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4", //const char * parent_function_name; +"__svml_cosf4_ha", //const char * variant_function_name; +824, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4_mask", //const char * parent_function_name; +"__svml_cosf4_ep_mask", //const char * variant_function_name; +825, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4_mask", //const char * parent_function_name; +"__svml_cosf4_mask", //const char * variant_function_name; +826, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf4_mask", //const char * parent_function_name; +"__svml_cosf4_ha_mask", //const char * variant_function_name; +827, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8", //const char * parent_function_name; +"__svml_cosf8_ep", //const char * variant_function_name; +828, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8", //const char * parent_function_name; +"__svml_cosf8", //const char * variant_function_name; +829, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8", //const char * parent_function_name; +"__svml_cosf8_ha", //const char * variant_function_name; +830, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8", //const char * parent_function_name; +"__svml_cosf8_br", //const char * variant_function_name; +831, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8_mask", //const char * parent_function_name; +"__svml_cosf8_ep_mask", //const char * variant_function_name; +832, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8_mask", //const char * parent_function_name; +"__svml_cosf8_mask", //const char * variant_function_name; +833, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8_mask", //const char * parent_function_name; +"__svml_cosf8_ha_mask", //const char * variant_function_name; +834, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosf8_mask", //const char * parent_function_name; +"__svml_cosf8_br_mask", //const char * variant_function_name; +835, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2", //const char * parent_function_name; +"__svml_cosh2_ep", //const char * variant_function_name; +836, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2", //const char * parent_function_name; +"__svml_cosh2", //const char * variant_function_name; +837, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2", //const char * parent_function_name; +"__svml_cosh2_ha", //const char * variant_function_name; +838, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2_mask", //const char * parent_function_name; +"__svml_cosh2_ep_mask", //const char * variant_function_name; +839, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2_mask", //const char * parent_function_name; +"__svml_cosh2_mask", //const char * variant_function_name; +840, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh2_mask", //const char * parent_function_name; +"__svml_cosh2_ha_mask", //const char * variant_function_name; +841, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4", //const char * parent_function_name; +"__svml_cosh4_ep", //const char * variant_function_name; +842, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4", //const char * parent_function_name; +"__svml_cosh4", //const char * variant_function_name; +843, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4", //const char * parent_function_name; +"__svml_cosh4_ha", //const char * variant_function_name; +844, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4", //const char * parent_function_name; +"__svml_cosh4_br", //const char * variant_function_name; +845, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4_mask", //const char * parent_function_name; +"__svml_cosh4_ep_mask", //const char * variant_function_name; +846, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4_mask", //const char * parent_function_name; +"__svml_cosh4_mask", //const char * variant_function_name; +847, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4_mask", //const char * parent_function_name; +"__svml_cosh4_ha_mask", //const char * variant_function_name; +848, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh4_mask", //const char * parent_function_name; +"__svml_cosh4_br_mask", //const char * variant_function_name; +849, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8", //const char * parent_function_name; +"__svml_cosh8_ep", //const char * variant_function_name; +850, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8", //const char * parent_function_name; +"__svml_cosh8", //const char * variant_function_name; +851, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8", //const char * parent_function_name; +"__svml_cosh8_ha", //const char * variant_function_name; +852, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8_mask", //const char * parent_function_name; +"__svml_cosh8_ep_mask", //const char * variant_function_name; +853, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8_mask", //const char * parent_function_name; +"__svml_cosh8_mask", //const char * variant_function_name; +854, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cosh8_mask", //const char * parent_function_name; +"__svml_cosh8_ha_mask", //const char * variant_function_name; +855, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16", //const char * parent_function_name; +"__svml_coshf16_ep", //const char * variant_function_name; +856, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16", //const char * parent_function_name; +"__svml_coshf16", //const char * variant_function_name; +857, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16", //const char * parent_function_name; +"__svml_coshf16_ha", //const char * variant_function_name; +858, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16_mask", //const char * parent_function_name; +"__svml_coshf16_ep_mask", //const char * variant_function_name; +859, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16_mask", //const char * parent_function_name; +"__svml_coshf16_mask", //const char * variant_function_name; +860, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf16_mask", //const char * parent_function_name; +"__svml_coshf16_ha_mask", //const char * variant_function_name; +861, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4", //const char * parent_function_name; +"__svml_coshf4_ep", //const char * variant_function_name; +862, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4", //const char * parent_function_name; +"__svml_coshf4", //const char * variant_function_name; +863, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4", //const char * parent_function_name; +"__svml_coshf4_ha", //const char * variant_function_name; +864, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4_mask", //const char * parent_function_name; +"__svml_coshf4_ep_mask", //const char * variant_function_name; +865, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4_mask", //const char * parent_function_name; +"__svml_coshf4_mask", //const char * variant_function_name; +866, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf4_mask", //const char * parent_function_name; +"__svml_coshf4_ha_mask", //const char * variant_function_name; +867, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8", //const char * parent_function_name; +"__svml_coshf8_ep", //const char * variant_function_name; +868, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8", //const char * parent_function_name; +"__svml_coshf8", //const char * variant_function_name; +869, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8", //const char * parent_function_name; +"__svml_coshf8_ha", //const char * variant_function_name; +870, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8", //const char * parent_function_name; +"__svml_coshf8_br", //const char * variant_function_name; +871, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8_mask", //const char * parent_function_name; +"__svml_coshf8_ep_mask", //const char * variant_function_name; +872, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8_mask", //const char * parent_function_name; +"__svml_coshf8_mask", //const char * variant_function_name; +873, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8_mask", //const char * parent_function_name; +"__svml_coshf8_ha_mask", //const char * variant_function_name; +874, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_coshf8_mask", //const char * parent_function_name; +"__svml_coshf8_br_mask", //const char * variant_function_name; +875, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf2", //const char * parent_function_name; +"__svml_cpowf2", //const char * variant_function_name; +876, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf2", //const char * parent_function_name; +"__svml_cpowf2", //const char * variant_function_name; +877, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf2_mask", //const char * parent_function_name; +"__svml_cpowf2_mask", //const char * variant_function_name; +878, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf2_mask", //const char * parent_function_name; +"__svml_cpowf2_mask", //const char * variant_function_name; +879, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf4", //const char * parent_function_name; +"__svml_cpowf4", //const char * variant_function_name; +880, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf4", //const char * parent_function_name; +"__svml_cpowf4", //const char * variant_function_name; +881, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf4_mask", //const char * parent_function_name; +"__svml_cpowf4_mask", //const char * variant_function_name; +882, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_cpowf4_mask", //const char * parent_function_name; +"__svml_cpowf4_mask", //const char * variant_function_name; +883, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf2", //const char * parent_function_name; +"__svml_csinf2", //const char * variant_function_name; +884, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf2", //const char * parent_function_name; +"__svml_csinf2", //const char * variant_function_name; +885, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf2_mask", //const char * parent_function_name; +"__svml_csinf2_mask", //const char * variant_function_name; +886, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf2_mask", //const char * parent_function_name; +"__svml_csinf2_mask", //const char * variant_function_name; +887, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf4", //const char * parent_function_name; +"__svml_csinf4", //const char * variant_function_name; +888, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf4", //const char * parent_function_name; +"__svml_csinf4", //const char * variant_function_name; +889, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf4_mask", //const char * parent_function_name; +"__svml_csinf4_mask", //const char * variant_function_name; +890, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinf4_mask", //const char * parent_function_name; +"__svml_csinf4_mask", //const char * variant_function_name; +891, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf2", //const char * parent_function_name; +"__svml_csinhf2", //const char * variant_function_name; +892, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf2", //const char * parent_function_name; +"__svml_csinhf2", //const char * variant_function_name; +893, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf2_mask", //const char * parent_function_name; +"__svml_csinhf2_mask", //const char * variant_function_name; +894, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf2_mask", //const char * parent_function_name; +"__svml_csinhf2_mask", //const char * variant_function_name; +895, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf4", //const char * parent_function_name; +"__svml_csinhf4", //const char * variant_function_name; +896, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf4", //const char * parent_function_name; +"__svml_csinhf4", //const char * variant_function_name; +897, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf4_mask", //const char * parent_function_name; +"__svml_csinhf4_mask", //const char * variant_function_name; +898, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csinhf4_mask", //const char * parent_function_name; +"__svml_csinhf4_mask", //const char * variant_function_name; +899, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt2", //const char * parent_function_name; +"__svml_csqrt2", //const char * variant_function_name; +900, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt2", //const char * parent_function_name; +"__svml_csqrt2", //const char * variant_function_name; +901, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt2_mask", //const char * parent_function_name; +"__svml_csqrt2_mask", //const char * variant_function_name; +902, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt2_mask", //const char * parent_function_name; +"__svml_csqrt2_mask", //const char * variant_function_name; +903, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt4", //const char * parent_function_name; +"__svml_csqrt4", //const char * variant_function_name; +904, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt4", //const char * parent_function_name; +"__svml_csqrt4", //const char * variant_function_name; +905, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt4_mask", //const char * parent_function_name; +"__svml_csqrt4_mask", //const char * variant_function_name; +906, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrt4_mask", //const char * parent_function_name; +"__svml_csqrt4_mask", //const char * variant_function_name; +907, //int Index; +PE_PrecisionDoubleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2", //const char * parent_function_name; +"__svml_csqrtf2", //const char * variant_function_name; +908, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2", //const char * parent_function_name; +"__svml_csqrtf2", //const char * variant_function_name; +909, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2", //const char * parent_function_name; +"__svml_csqrtf2_ha", //const char * variant_function_name; +910, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2_mask", //const char * parent_function_name; +"__svml_csqrtf2_mask", //const char * variant_function_name; +911, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2_mask", //const char * parent_function_name; +"__svml_csqrtf2_mask", //const char * variant_function_name; +912, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf2_mask", //const char * parent_function_name; +"__svml_csqrtf2_ha_mask", //const char * variant_function_name; +913, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4", //const char * parent_function_name; +"__svml_csqrtf4", //const char * variant_function_name; +914, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4", //const char * parent_function_name; +"__svml_csqrtf4", //const char * variant_function_name; +915, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4", //const char * parent_function_name; +"__svml_csqrtf4_ha", //const char * variant_function_name; +916, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4_mask", //const char * parent_function_name; +"__svml_csqrtf4_mask", //const char * variant_function_name; +917, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4_mask", //const char * parent_function_name; +"__svml_csqrtf4_mask", //const char * variant_function_name; +918, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf4_mask", //const char * parent_function_name; +"__svml_csqrtf4_ha_mask", //const char * variant_function_name; +919, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8", //const char * parent_function_name; +"__svml_csqrtf8", //const char * variant_function_name; +920, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8", //const char * parent_function_name; +"__svml_csqrtf8", //const char * variant_function_name; +921, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8", //const char * parent_function_name; +"__svml_csqrtf8_ha", //const char * variant_function_name; +922, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8_mask", //const char * parent_function_name; +"__svml_csqrtf8_mask", //const char * variant_function_name; +923, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8_mask", //const char * parent_function_name; +"__svml_csqrtf8_mask", //const char * variant_function_name; +924, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_csqrtf8_mask", //const char * parent_function_name; +"__svml_csqrtf8_ha_mask", //const char * variant_function_name; +925, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf2", //const char * parent_function_name; +"__svml_ctanf2", //const char * variant_function_name; +926, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf2", //const char * parent_function_name; +"__svml_ctanf2", //const char * variant_function_name; +927, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf2_mask", //const char * parent_function_name; +"__svml_ctanf2_mask", //const char * variant_function_name; +928, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf2_mask", //const char * parent_function_name; +"__svml_ctanf2_mask", //const char * variant_function_name; +929, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf4", //const char * parent_function_name; +"__svml_ctanf4", //const char * variant_function_name; +930, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf4", //const char * parent_function_name; +"__svml_ctanf4", //const char * variant_function_name; +931, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf4_mask", //const char * parent_function_name; +"__svml_ctanf4_mask", //const char * variant_function_name; +932, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanf4_mask", //const char * parent_function_name; +"__svml_ctanf4_mask", //const char * variant_function_name; +933, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf2", //const char * parent_function_name; +"__svml_ctanhf2", //const char * variant_function_name; +934, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf2", //const char * parent_function_name; +"__svml_ctanhf2", //const char * variant_function_name; +935, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf2_mask", //const char * parent_function_name; +"__svml_ctanhf2_mask", //const char * variant_function_name; +936, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf2_mask", //const char * parent_function_name; +"__svml_ctanhf2_mask", //const char * variant_function_name; +937, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf4", //const char * parent_function_name; +"__svml_ctanhf4", //const char * variant_function_name; +938, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf4", //const char * parent_function_name; +"__svml_ctanhf4", //const char * variant_function_name; +939, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf4_mask", //const char * parent_function_name; +"__svml_ctanhf4_mask", //const char * variant_function_name; +940, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_ctanhf4_mask", //const char * parent_function_name; +"__svml_ctanhf4_mask", //const char * variant_function_name; +941, //int Index; +PE_PrecisionSingleComplex, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2", //const char * parent_function_name; +"__svml_erf2_ep", //const char * variant_function_name; +942, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2", //const char * parent_function_name; +"__svml_erf2", //const char * variant_function_name; +943, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2", //const char * parent_function_name; +"__svml_erf2_ha", //const char * variant_function_name; +944, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2_mask", //const char * parent_function_name; +"__svml_erf2_ep_mask", //const char * variant_function_name; +945, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2_mask", //const char * parent_function_name; +"__svml_erf2_mask", //const char * variant_function_name; +946, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf2_mask", //const char * parent_function_name; +"__svml_erf2_ha_mask", //const char * variant_function_name; +947, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4", //const char * parent_function_name; +"__svml_erf4_ep", //const char * variant_function_name; +948, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4", //const char * parent_function_name; +"__svml_erf4", //const char * variant_function_name; +949, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4", //const char * parent_function_name; +"__svml_erf4_ha", //const char * variant_function_name; +950, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4", //const char * parent_function_name; +"__svml_erf4_br", //const char * variant_function_name; +951, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4_mask", //const char * parent_function_name; +"__svml_erf4_ep_mask", //const char * variant_function_name; +952, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4_mask", //const char * parent_function_name; +"__svml_erf4_mask", //const char * variant_function_name; +953, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4_mask", //const char * parent_function_name; +"__svml_erf4_ha_mask", //const char * variant_function_name; +954, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf4_mask", //const char * parent_function_name; +"__svml_erf4_br_mask", //const char * variant_function_name; +955, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8", //const char * parent_function_name; +"__svml_erf8_ep", //const char * variant_function_name; +956, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8", //const char * parent_function_name; +"__svml_erf8", //const char * variant_function_name; +957, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8", //const char * parent_function_name; +"__svml_erf8_ha", //const char * variant_function_name; +958, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8_mask", //const char * parent_function_name; +"__svml_erf8_ep_mask", //const char * variant_function_name; +959, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8_mask", //const char * parent_function_name; +"__svml_erf8_mask", //const char * variant_function_name; +960, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erf8_mask", //const char * parent_function_name; +"__svml_erf8_ha_mask", //const char * variant_function_name; +961, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2", //const char * parent_function_name; +"__svml_erfc2_ep", //const char * variant_function_name; +962, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2", //const char * parent_function_name; +"__svml_erfc2", //const char * variant_function_name; +963, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2", //const char * parent_function_name; +"__svml_erfc2_ha", //const char * variant_function_name; +964, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2_mask", //const char * parent_function_name; +"__svml_erfc2_ep_mask", //const char * variant_function_name; +965, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2_mask", //const char * parent_function_name; +"__svml_erfc2_mask", //const char * variant_function_name; +966, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc2_mask", //const char * parent_function_name; +"__svml_erfc2_ha_mask", //const char * variant_function_name; +967, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4", //const char * parent_function_name; +"__svml_erfc4_ep", //const char * variant_function_name; +968, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4", //const char * parent_function_name; +"__svml_erfc4", //const char * variant_function_name; +969, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4", //const char * parent_function_name; +"__svml_erfc4_ha", //const char * variant_function_name; +970, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4", //const char * parent_function_name; +"__svml_erfc4_br", //const char * variant_function_name; +971, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4_mask", //const char * parent_function_name; +"__svml_erfc4_ep_mask", //const char * variant_function_name; +972, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4_mask", //const char * parent_function_name; +"__svml_erfc4_mask", //const char * variant_function_name; +973, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4_mask", //const char * parent_function_name; +"__svml_erfc4_ha_mask", //const char * variant_function_name; +974, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc4_mask", //const char * parent_function_name; +"__svml_erfc4_br_mask", //const char * variant_function_name; +975, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8", //const char * parent_function_name; +"__svml_erfc8_ep", //const char * variant_function_name; +976, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8", //const char * parent_function_name; +"__svml_erfc8", //const char * variant_function_name; +977, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8", //const char * parent_function_name; +"__svml_erfc8_ha", //const char * variant_function_name; +978, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8_mask", //const char * parent_function_name; +"__svml_erfc8_ep_mask", //const char * variant_function_name; +979, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8_mask", //const char * parent_function_name; +"__svml_erfc8_mask", //const char * variant_function_name; +980, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfc8_mask", //const char * parent_function_name; +"__svml_erfc8_ha_mask", //const char * variant_function_name; +981, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16", //const char * parent_function_name; +"__svml_erfcf16_ep", //const char * variant_function_name; +982, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16", //const char * parent_function_name; +"__svml_erfcf16", //const char * variant_function_name; +983, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16", //const char * parent_function_name; +"__svml_erfcf16_ha", //const char * variant_function_name; +984, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16_mask", //const char * parent_function_name; +"__svml_erfcf16_ep_mask", //const char * variant_function_name; +985, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16_mask", //const char * parent_function_name; +"__svml_erfcf16_mask", //const char * variant_function_name; +986, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf16_mask", //const char * parent_function_name; +"__svml_erfcf16_ha_mask", //const char * variant_function_name; +987, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4", //const char * parent_function_name; +"__svml_erfcf4_ep", //const char * variant_function_name; +988, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4", //const char * parent_function_name; +"__svml_erfcf4", //const char * variant_function_name; +989, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4", //const char * parent_function_name; +"__svml_erfcf4_ha", //const char * variant_function_name; +990, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4_mask", //const char * parent_function_name; +"__svml_erfcf4_ep_mask", //const char * variant_function_name; +991, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4_mask", //const char * parent_function_name; +"__svml_erfcf4_mask", //const char * variant_function_name; +992, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf4_mask", //const char * parent_function_name; +"__svml_erfcf4_ha_mask", //const char * variant_function_name; +993, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8", //const char * parent_function_name; +"__svml_erfcf8_ep", //const char * variant_function_name; +994, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8", //const char * parent_function_name; +"__svml_erfcf8", //const char * variant_function_name; +995, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8", //const char * parent_function_name; +"__svml_erfcf8_ha", //const char * variant_function_name; +996, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8", //const char * parent_function_name; +"__svml_erfcf8_br", //const char * variant_function_name; +997, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8_mask", //const char * parent_function_name; +"__svml_erfcf8_ep_mask", //const char * variant_function_name; +998, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8_mask", //const char * parent_function_name; +"__svml_erfcf8_mask", //const char * variant_function_name; +999, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8_mask", //const char * parent_function_name; +"__svml_erfcf8_ha_mask", //const char * variant_function_name; +1000, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcf8_mask", //const char * parent_function_name; +"__svml_erfcf8_br_mask", //const char * variant_function_name; +1001, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2", //const char * parent_function_name; +"__svml_erfcinv2_ep", //const char * variant_function_name; +1002, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2", //const char * parent_function_name; +"__svml_erfcinv2", //const char * variant_function_name; +1003, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2", //const char * parent_function_name; +"__svml_erfcinv2_ha", //const char * variant_function_name; +1004, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2_mask", //const char * parent_function_name; +"__svml_erfcinv2_ep_mask", //const char * variant_function_name; +1005, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2_mask", //const char * parent_function_name; +"__svml_erfcinv2_mask", //const char * variant_function_name; +1006, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv2_mask", //const char * parent_function_name; +"__svml_erfcinv2_ha_mask", //const char * variant_function_name; +1007, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4", //const char * parent_function_name; +"__svml_erfcinv4_ep", //const char * variant_function_name; +1008, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4", //const char * parent_function_name; +"__svml_erfcinv4", //const char * variant_function_name; +1009, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4", //const char * parent_function_name; +"__svml_erfcinv4_ha", //const char * variant_function_name; +1010, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4", //const char * parent_function_name; +"__svml_erfcinv4_br", //const char * variant_function_name; +1011, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4_mask", //const char * parent_function_name; +"__svml_erfcinv4_ep_mask", //const char * variant_function_name; +1012, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4_mask", //const char * parent_function_name; +"__svml_erfcinv4_mask", //const char * variant_function_name; +1013, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4_mask", //const char * parent_function_name; +"__svml_erfcinv4_ha_mask", //const char * variant_function_name; +1014, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv4_mask", //const char * parent_function_name; +"__svml_erfcinv4_br_mask", //const char * variant_function_name; +1015, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8", //const char * parent_function_name; +"__svml_erfcinv8_ep", //const char * variant_function_name; +1016, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8", //const char * parent_function_name; +"__svml_erfcinv8", //const char * variant_function_name; +1017, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8", //const char * parent_function_name; +"__svml_erfcinv8_ha", //const char * variant_function_name; +1018, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8_mask", //const char * parent_function_name; +"__svml_erfcinv8_ep_mask", //const char * variant_function_name; +1019, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8_mask", //const char * parent_function_name; +"__svml_erfcinv8_mask", //const char * variant_function_name; +1020, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinv8_mask", //const char * parent_function_name; +"__svml_erfcinv8_ha_mask", //const char * variant_function_name; +1021, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16", //const char * parent_function_name; +"__svml_erfcinvf16_ep", //const char * variant_function_name; +1022, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16", //const char * parent_function_name; +"__svml_erfcinvf16", //const char * variant_function_name; +1023, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16", //const char * parent_function_name; +"__svml_erfcinvf16_ha", //const char * variant_function_name; +1024, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16_mask", //const char * parent_function_name; +"__svml_erfcinvf16_ep_mask", //const char * variant_function_name; +1025, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16_mask", //const char * parent_function_name; +"__svml_erfcinvf16_mask", //const char * variant_function_name; +1026, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf16_mask", //const char * parent_function_name; +"__svml_erfcinvf16_ha_mask", //const char * variant_function_name; +1027, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4", //const char * parent_function_name; +"__svml_erfcinvf4_ep", //const char * variant_function_name; +1028, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4", //const char * parent_function_name; +"__svml_erfcinvf4", //const char * variant_function_name; +1029, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4", //const char * parent_function_name; +"__svml_erfcinvf4_ha", //const char * variant_function_name; +1030, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4_mask", //const char * parent_function_name; +"__svml_erfcinvf4_ep_mask", //const char * variant_function_name; +1031, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4_mask", //const char * parent_function_name; +"__svml_erfcinvf4_mask", //const char * variant_function_name; +1032, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf4_mask", //const char * parent_function_name; +"__svml_erfcinvf4_ha_mask", //const char * variant_function_name; +1033, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8", //const char * parent_function_name; +"__svml_erfcinvf8_ep", //const char * variant_function_name; +1034, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8", //const char * parent_function_name; +"__svml_erfcinvf8", //const char * variant_function_name; +1035, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8", //const char * parent_function_name; +"__svml_erfcinvf8_ha", //const char * variant_function_name; +1036, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8", //const char * parent_function_name; +"__svml_erfcinvf8_br", //const char * variant_function_name; +1037, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8_mask", //const char * parent_function_name; +"__svml_erfcinvf8_ep_mask", //const char * variant_function_name; +1038, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8_mask", //const char * parent_function_name; +"__svml_erfcinvf8_mask", //const char * variant_function_name; +1039, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8_mask", //const char * parent_function_name; +"__svml_erfcinvf8_ha_mask", //const char * variant_function_name; +1040, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfcinvf8_mask", //const char * parent_function_name; +"__svml_erfcinvf8_br_mask", //const char * variant_function_name; +1041, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16", //const char * parent_function_name; +"__svml_erff16_ep", //const char * variant_function_name; +1042, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16", //const char * parent_function_name; +"__svml_erff16", //const char * variant_function_name; +1043, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16", //const char * parent_function_name; +"__svml_erff16_ha", //const char * variant_function_name; +1044, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16_mask", //const char * parent_function_name; +"__svml_erff16_ep_mask", //const char * variant_function_name; +1045, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16_mask", //const char * parent_function_name; +"__svml_erff16_mask", //const char * variant_function_name; +1046, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff16_mask", //const char * parent_function_name; +"__svml_erff16_ha_mask", //const char * variant_function_name; +1047, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4", //const char * parent_function_name; +"__svml_erff4_ep", //const char * variant_function_name; +1048, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4", //const char * parent_function_name; +"__svml_erff4", //const char * variant_function_name; +1049, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4", //const char * parent_function_name; +"__svml_erff4_ha", //const char * variant_function_name; +1050, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4_mask", //const char * parent_function_name; +"__svml_erff4_ep_mask", //const char * variant_function_name; +1051, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4_mask", //const char * parent_function_name; +"__svml_erff4_mask", //const char * variant_function_name; +1052, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff4_mask", //const char * parent_function_name; +"__svml_erff4_ha_mask", //const char * variant_function_name; +1053, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8", //const char * parent_function_name; +"__svml_erff8_ep", //const char * variant_function_name; +1054, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8", //const char * parent_function_name; +"__svml_erff8", //const char * variant_function_name; +1055, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8", //const char * parent_function_name; +"__svml_erff8_ha", //const char * variant_function_name; +1056, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8", //const char * parent_function_name; +"__svml_erff8_br", //const char * variant_function_name; +1057, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8_mask", //const char * parent_function_name; +"__svml_erff8_ep_mask", //const char * variant_function_name; +1058, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8_mask", //const char * parent_function_name; +"__svml_erff8_mask", //const char * variant_function_name; +1059, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8_mask", //const char * parent_function_name; +"__svml_erff8_ha_mask", //const char * variant_function_name; +1060, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erff8_mask", //const char * parent_function_name; +"__svml_erff8_br_mask", //const char * variant_function_name; +1061, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2", //const char * parent_function_name; +"__svml_erfinv2_ep", //const char * variant_function_name; +1062, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2", //const char * parent_function_name; +"__svml_erfinv2", //const char * variant_function_name; +1063, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2", //const char * parent_function_name; +"__svml_erfinv2_ha", //const char * variant_function_name; +1064, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2_mask", //const char * parent_function_name; +"__svml_erfinv2_ep_mask", //const char * variant_function_name; +1065, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2_mask", //const char * parent_function_name; +"__svml_erfinv2_mask", //const char * variant_function_name; +1066, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv2_mask", //const char * parent_function_name; +"__svml_erfinv2_ha_mask", //const char * variant_function_name; +1067, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4", //const char * parent_function_name; +"__svml_erfinv4_ep", //const char * variant_function_name; +1068, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4", //const char * parent_function_name; +"__svml_erfinv4", //const char * variant_function_name; +1069, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4", //const char * parent_function_name; +"__svml_erfinv4_ha", //const char * variant_function_name; +1070, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4", //const char * parent_function_name; +"__svml_erfinv4_br", //const char * variant_function_name; +1071, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4_mask", //const char * parent_function_name; +"__svml_erfinv4_ep_mask", //const char * variant_function_name; +1072, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4_mask", //const char * parent_function_name; +"__svml_erfinv4_mask", //const char * variant_function_name; +1073, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4_mask", //const char * parent_function_name; +"__svml_erfinv4_ha_mask", //const char * variant_function_name; +1074, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv4_mask", //const char * parent_function_name; +"__svml_erfinv4_br_mask", //const char * variant_function_name; +1075, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8", //const char * parent_function_name; +"__svml_erfinv8_ep", //const char * variant_function_name; +1076, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8", //const char * parent_function_name; +"__svml_erfinv8", //const char * variant_function_name; +1077, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8", //const char * parent_function_name; +"__svml_erfinv8_ha", //const char * variant_function_name; +1078, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8_mask", //const char * parent_function_name; +"__svml_erfinv8_ep_mask", //const char * variant_function_name; +1079, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8_mask", //const char * parent_function_name; +"__svml_erfinv8_mask", //const char * variant_function_name; +1080, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinv8_mask", //const char * parent_function_name; +"__svml_erfinv8_ha_mask", //const char * variant_function_name; +1081, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16", //const char * parent_function_name; +"__svml_erfinvf16_ep", //const char * variant_function_name; +1082, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16", //const char * parent_function_name; +"__svml_erfinvf16", //const char * variant_function_name; +1083, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16", //const char * parent_function_name; +"__svml_erfinvf16_ha", //const char * variant_function_name; +1084, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16_mask", //const char * parent_function_name; +"__svml_erfinvf16_ep_mask", //const char * variant_function_name; +1085, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16_mask", //const char * parent_function_name; +"__svml_erfinvf16_mask", //const char * variant_function_name; +1086, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf16_mask", //const char * parent_function_name; +"__svml_erfinvf16_ha_mask", //const char * variant_function_name; +1087, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4", //const char * parent_function_name; +"__svml_erfinvf4_ep", //const char * variant_function_name; +1088, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4", //const char * parent_function_name; +"__svml_erfinvf4", //const char * variant_function_name; +1089, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4", //const char * parent_function_name; +"__svml_erfinvf4_ha", //const char * variant_function_name; +1090, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4_mask", //const char * parent_function_name; +"__svml_erfinvf4_ep_mask", //const char * variant_function_name; +1091, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4_mask", //const char * parent_function_name; +"__svml_erfinvf4_mask", //const char * variant_function_name; +1092, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf4_mask", //const char * parent_function_name; +"__svml_erfinvf4_ha_mask", //const char * variant_function_name; +1093, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8", //const char * parent_function_name; +"__svml_erfinvf8_ep", //const char * variant_function_name; +1094, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8", //const char * parent_function_name; +"__svml_erfinvf8", //const char * variant_function_name; +1095, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8", //const char * parent_function_name; +"__svml_erfinvf8_ha", //const char * variant_function_name; +1096, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8", //const char * parent_function_name; +"__svml_erfinvf8_br", //const char * variant_function_name; +1097, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8_mask", //const char * parent_function_name; +"__svml_erfinvf8_ep_mask", //const char * variant_function_name; +1098, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8_mask", //const char * parent_function_name; +"__svml_erfinvf8_mask", //const char * variant_function_name; +1099, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8_mask", //const char * parent_function_name; +"__svml_erfinvf8_ha_mask", //const char * variant_function_name; +1100, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_erfinvf8_mask", //const char * parent_function_name; +"__svml_erfinvf8_br_mask", //const char * variant_function_name; +1101, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102", //const char * parent_function_name; +"__svml_exp102_ep", //const char * variant_function_name; +1102, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102", //const char * parent_function_name; +"__svml_exp102", //const char * variant_function_name; +1103, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102", //const char * parent_function_name; +"__svml_exp102_ha", //const char * variant_function_name; +1104, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102_mask", //const char * parent_function_name; +"__svml_exp102_ep_mask", //const char * variant_function_name; +1105, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102_mask", //const char * parent_function_name; +"__svml_exp102_mask", //const char * variant_function_name; +1106, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp102_mask", //const char * parent_function_name; +"__svml_exp102_ha_mask", //const char * variant_function_name; +1107, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104", //const char * parent_function_name; +"__svml_exp104_ep", //const char * variant_function_name; +1108, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104", //const char * parent_function_name; +"__svml_exp104", //const char * variant_function_name; +1109, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104", //const char * parent_function_name; +"__svml_exp104_ha", //const char * variant_function_name; +1110, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104", //const char * parent_function_name; +"__svml_exp104_br", //const char * variant_function_name; +1111, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104_mask", //const char * parent_function_name; +"__svml_exp104_ep_mask", //const char * variant_function_name; +1112, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104_mask", //const char * parent_function_name; +"__svml_exp104_mask", //const char * variant_function_name; +1113, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104_mask", //const char * parent_function_name; +"__svml_exp104_ha_mask", //const char * variant_function_name; +1114, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp104_mask", //const char * parent_function_name; +"__svml_exp104_br_mask", //const char * variant_function_name; +1115, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108", //const char * parent_function_name; +"__svml_exp108_ep", //const char * variant_function_name; +1116, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108", //const char * parent_function_name; +"__svml_exp108", //const char * variant_function_name; +1117, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108", //const char * parent_function_name; +"__svml_exp108_ha", //const char * variant_function_name; +1118, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108_mask", //const char * parent_function_name; +"__svml_exp108_ep_mask", //const char * variant_function_name; +1119, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108_mask", //const char * parent_function_name; +"__svml_exp108_mask", //const char * variant_function_name; +1120, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp108_mask", //const char * parent_function_name; +"__svml_exp108_ha_mask", //const char * variant_function_name; +1121, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16", //const char * parent_function_name; +"__svml_exp10f16_ep", //const char * variant_function_name; +1122, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16", //const char * parent_function_name; +"__svml_exp10f16", //const char * variant_function_name; +1123, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16", //const char * parent_function_name; +"__svml_exp10f16_ha", //const char * variant_function_name; +1124, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16_mask", //const char * parent_function_name; +"__svml_exp10f16_ep_mask", //const char * variant_function_name; +1125, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16_mask", //const char * parent_function_name; +"__svml_exp10f16_mask", //const char * variant_function_name; +1126, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f16_mask", //const char * parent_function_name; +"__svml_exp10f16_ha_mask", //const char * variant_function_name; +1127, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4", //const char * parent_function_name; +"__svml_exp10f4_ep", //const char * variant_function_name; +1128, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4", //const char * parent_function_name; +"__svml_exp10f4", //const char * variant_function_name; +1129, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4", //const char * parent_function_name; +"__svml_exp10f4_ha", //const char * variant_function_name; +1130, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4_mask", //const char * parent_function_name; +"__svml_exp10f4_ep_mask", //const char * variant_function_name; +1131, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4_mask", //const char * parent_function_name; +"__svml_exp10f4_mask", //const char * variant_function_name; +1132, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f4_mask", //const char * parent_function_name; +"__svml_exp10f4_ha_mask", //const char * variant_function_name; +1133, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8", //const char * parent_function_name; +"__svml_exp10f8_ep", //const char * variant_function_name; +1134, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8", //const char * parent_function_name; +"__svml_exp10f8", //const char * variant_function_name; +1135, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8", //const char * parent_function_name; +"__svml_exp10f8_ha", //const char * variant_function_name; +1136, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8", //const char * parent_function_name; +"__svml_exp10f8_br", //const char * variant_function_name; +1137, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8_mask", //const char * parent_function_name; +"__svml_exp10f8_ep_mask", //const char * variant_function_name; +1138, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8_mask", //const char * parent_function_name; +"__svml_exp10f8_mask", //const char * variant_function_name; +1139, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8_mask", //const char * parent_function_name; +"__svml_exp10f8_ha_mask", //const char * variant_function_name; +1140, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp10f8_mask", //const char * parent_function_name; +"__svml_exp10f8_br_mask", //const char * variant_function_name; +1141, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2", //const char * parent_function_name; +"__svml_exp2_ep", //const char * variant_function_name; +1142, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2", //const char * parent_function_name; +"__svml_exp2", //const char * variant_function_name; +1143, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2", //const char * parent_function_name; +"__svml_exp2_ha", //const char * variant_function_name; +1144, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22", //const char * parent_function_name; +"__svml_exp22_ep", //const char * variant_function_name; +1145, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22", //const char * parent_function_name; +"__svml_exp22", //const char * variant_function_name; +1146, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22", //const char * parent_function_name; +"__svml_exp22_ha", //const char * variant_function_name; +1147, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22_mask", //const char * parent_function_name; +"__svml_exp22_ep_mask", //const char * variant_function_name; +1148, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22_mask", //const char * parent_function_name; +"__svml_exp22_mask", //const char * variant_function_name; +1149, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp22_mask", //const char * parent_function_name; +"__svml_exp22_ha_mask", //const char * variant_function_name; +1150, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24", //const char * parent_function_name; +"__svml_exp24_ep", //const char * variant_function_name; +1151, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24", //const char * parent_function_name; +"__svml_exp24", //const char * variant_function_name; +1152, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24", //const char * parent_function_name; +"__svml_exp24_ha", //const char * variant_function_name; +1153, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24", //const char * parent_function_name; +"__svml_exp24_br", //const char * variant_function_name; +1154, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24_mask", //const char * parent_function_name; +"__svml_exp24_ep_mask", //const char * variant_function_name; +1155, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24_mask", //const char * parent_function_name; +"__svml_exp24_mask", //const char * variant_function_name; +1156, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24_mask", //const char * parent_function_name; +"__svml_exp24_ha_mask", //const char * variant_function_name; +1157, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp24_mask", //const char * parent_function_name; +"__svml_exp24_br_mask", //const char * variant_function_name; +1158, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28", //const char * parent_function_name; +"__svml_exp28_ep", //const char * variant_function_name; +1159, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28", //const char * parent_function_name; +"__svml_exp28", //const char * variant_function_name; +1160, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28", //const char * parent_function_name; +"__svml_exp28_ha", //const char * variant_function_name; +1161, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28_mask", //const char * parent_function_name; +"__svml_exp28_ep_mask", //const char * variant_function_name; +1162, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28_mask", //const char * parent_function_name; +"__svml_exp28_mask", //const char * variant_function_name; +1163, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp28_mask", //const char * parent_function_name; +"__svml_exp28_ha_mask", //const char * variant_function_name; +1164, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2_mask", //const char * parent_function_name; +"__svml_exp2_ep_mask", //const char * variant_function_name; +1165, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2_mask", //const char * parent_function_name; +"__svml_exp2_mask", //const char * variant_function_name; +1166, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2_mask", //const char * parent_function_name; +"__svml_exp2_ha_mask", //const char * variant_function_name; +1167, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16", //const char * parent_function_name; +"__svml_exp2f16_ep", //const char * variant_function_name; +1168, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16", //const char * parent_function_name; +"__svml_exp2f16", //const char * variant_function_name; +1169, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16", //const char * parent_function_name; +"__svml_exp2f16_ha", //const char * variant_function_name; +1170, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16_mask", //const char * parent_function_name; +"__svml_exp2f16_ep_mask", //const char * variant_function_name; +1171, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16_mask", //const char * parent_function_name; +"__svml_exp2f16_mask", //const char * variant_function_name; +1172, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f16_mask", //const char * parent_function_name; +"__svml_exp2f16_ha_mask", //const char * variant_function_name; +1173, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4", //const char * parent_function_name; +"__svml_exp2f4_ep", //const char * variant_function_name; +1174, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4", //const char * parent_function_name; +"__svml_exp2f4", //const char * variant_function_name; +1175, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4", //const char * parent_function_name; +"__svml_exp2f4_ha", //const char * variant_function_name; +1176, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4_mask", //const char * parent_function_name; +"__svml_exp2f4_ep_mask", //const char * variant_function_name; +1177, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4_mask", //const char * parent_function_name; +"__svml_exp2f4_mask", //const char * variant_function_name; +1178, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f4_mask", //const char * parent_function_name; +"__svml_exp2f4_ha_mask", //const char * variant_function_name; +1179, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8", //const char * parent_function_name; +"__svml_exp2f8_ep", //const char * variant_function_name; +1180, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8", //const char * parent_function_name; +"__svml_exp2f8", //const char * variant_function_name; +1181, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8", //const char * parent_function_name; +"__svml_exp2f8_ha", //const char * variant_function_name; +1182, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8", //const char * parent_function_name; +"__svml_exp2f8_br", //const char * variant_function_name; +1183, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8_mask", //const char * parent_function_name; +"__svml_exp2f8_ep_mask", //const char * variant_function_name; +1184, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8_mask", //const char * parent_function_name; +"__svml_exp2f8_mask", //const char * variant_function_name; +1185, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8_mask", //const char * parent_function_name; +"__svml_exp2f8_ha_mask", //const char * variant_function_name; +1186, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp2f8_mask", //const char * parent_function_name; +"__svml_exp2f8_br_mask", //const char * variant_function_name; +1187, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4", //const char * parent_function_name; +"__svml_exp4_ep", //const char * variant_function_name; +1188, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4", //const char * parent_function_name; +"__svml_exp4", //const char * variant_function_name; +1189, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4", //const char * parent_function_name; +"__svml_exp4_ha", //const char * variant_function_name; +1190, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4", //const char * parent_function_name; +"__svml_exp4_br", //const char * variant_function_name; +1191, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4_mask", //const char * parent_function_name; +"__svml_exp4_ep_mask", //const char * variant_function_name; +1192, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4_mask", //const char * parent_function_name; +"__svml_exp4_mask", //const char * variant_function_name; +1193, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4_mask", //const char * parent_function_name; +"__svml_exp4_ha_mask", //const char * variant_function_name; +1194, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp4_mask", //const char * parent_function_name; +"__svml_exp4_br_mask", //const char * variant_function_name; +1195, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8", //const char * parent_function_name; +"__svml_exp8_ep", //const char * variant_function_name; +1196, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8", //const char * parent_function_name; +"__svml_exp8", //const char * variant_function_name; +1197, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8", //const char * parent_function_name; +"__svml_exp8_ha", //const char * variant_function_name; +1198, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8_mask", //const char * parent_function_name; +"__svml_exp8_ep_mask", //const char * variant_function_name; +1199, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8_mask", //const char * parent_function_name; +"__svml_exp8_mask", //const char * variant_function_name; +1200, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_exp8_mask", //const char * parent_function_name; +"__svml_exp8_ha_mask", //const char * variant_function_name; +1201, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16", //const char * parent_function_name; +"__svml_expf16_ep", //const char * variant_function_name; +1202, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16", //const char * parent_function_name; +"__svml_expf16", //const char * variant_function_name; +1203, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16", //const char * parent_function_name; +"__svml_expf16_ha", //const char * variant_function_name; +1204, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16_mask", //const char * parent_function_name; +"__svml_expf16_ep_mask", //const char * variant_function_name; +1205, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16_mask", //const char * parent_function_name; +"__svml_expf16_mask", //const char * variant_function_name; +1206, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf16_mask", //const char * parent_function_name; +"__svml_expf16_ha_mask", //const char * variant_function_name; +1207, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4", //const char * parent_function_name; +"__svml_expf4_ep", //const char * variant_function_name; +1208, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4", //const char * parent_function_name; +"__svml_expf4", //const char * variant_function_name; +1209, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4", //const char * parent_function_name; +"__svml_expf4_ha", //const char * variant_function_name; +1210, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4_mask", //const char * parent_function_name; +"__svml_expf4_ep_mask", //const char * variant_function_name; +1211, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4_mask", //const char * parent_function_name; +"__svml_expf4_mask", //const char * variant_function_name; +1212, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf4_mask", //const char * parent_function_name; +"__svml_expf4_ha_mask", //const char * variant_function_name; +1213, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8", //const char * parent_function_name; +"__svml_expf8_ep", //const char * variant_function_name; +1214, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8", //const char * parent_function_name; +"__svml_expf8", //const char * variant_function_name; +1215, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8", //const char * parent_function_name; +"__svml_expf8_ha", //const char * variant_function_name; +1216, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8", //const char * parent_function_name; +"__svml_expf8_br", //const char * variant_function_name; +1217, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8_mask", //const char * parent_function_name; +"__svml_expf8_ep_mask", //const char * variant_function_name; +1218, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8_mask", //const char * parent_function_name; +"__svml_expf8_mask", //const char * variant_function_name; +1219, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8_mask", //const char * parent_function_name; +"__svml_expf8_ha_mask", //const char * variant_function_name; +1220, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expf8_mask", //const char * parent_function_name; +"__svml_expf8_br_mask", //const char * variant_function_name; +1221, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12", //const char * parent_function_name; +"__svml_expm12_ep", //const char * variant_function_name; +1222, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12", //const char * parent_function_name; +"__svml_expm12", //const char * variant_function_name; +1223, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12", //const char * parent_function_name; +"__svml_expm12_ha", //const char * variant_function_name; +1224, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12_mask", //const char * parent_function_name; +"__svml_expm12_ep_mask", //const char * variant_function_name; +1225, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12_mask", //const char * parent_function_name; +"__svml_expm12_mask", //const char * variant_function_name; +1226, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm12_mask", //const char * parent_function_name; +"__svml_expm12_ha_mask", //const char * variant_function_name; +1227, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14", //const char * parent_function_name; +"__svml_expm14_ep", //const char * variant_function_name; +1228, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14", //const char * parent_function_name; +"__svml_expm14", //const char * variant_function_name; +1229, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14", //const char * parent_function_name; +"__svml_expm14_ha", //const char * variant_function_name; +1230, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14", //const char * parent_function_name; +"__svml_expm14_br", //const char * variant_function_name; +1231, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14_mask", //const char * parent_function_name; +"__svml_expm14_ep_mask", //const char * variant_function_name; +1232, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14_mask", //const char * parent_function_name; +"__svml_expm14_mask", //const char * variant_function_name; +1233, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14_mask", //const char * parent_function_name; +"__svml_expm14_ha_mask", //const char * variant_function_name; +1234, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm14_mask", //const char * parent_function_name; +"__svml_expm14_br_mask", //const char * variant_function_name; +1235, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18", //const char * parent_function_name; +"__svml_expm18_ep", //const char * variant_function_name; +1236, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18", //const char * parent_function_name; +"__svml_expm18", //const char * variant_function_name; +1237, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18", //const char * parent_function_name; +"__svml_expm18_ha", //const char * variant_function_name; +1238, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18_mask", //const char * parent_function_name; +"__svml_expm18_ep_mask", //const char * variant_function_name; +1239, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18_mask", //const char * parent_function_name; +"__svml_expm18_mask", //const char * variant_function_name; +1240, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm18_mask", //const char * parent_function_name; +"__svml_expm18_ha_mask", //const char * variant_function_name; +1241, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16", //const char * parent_function_name; +"__svml_expm1f16_ep", //const char * variant_function_name; +1242, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16", //const char * parent_function_name; +"__svml_expm1f16", //const char * variant_function_name; +1243, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16", //const char * parent_function_name; +"__svml_expm1f16_ha", //const char * variant_function_name; +1244, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16_mask", //const char * parent_function_name; +"__svml_expm1f16_ep_mask", //const char * variant_function_name; +1245, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16_mask", //const char * parent_function_name; +"__svml_expm1f16_mask", //const char * variant_function_name; +1246, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f16_mask", //const char * parent_function_name; +"__svml_expm1f16_ha_mask", //const char * variant_function_name; +1247, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4", //const char * parent_function_name; +"__svml_expm1f4_ep", //const char * variant_function_name; +1248, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4", //const char * parent_function_name; +"__svml_expm1f4", //const char * variant_function_name; +1249, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4", //const char * parent_function_name; +"__svml_expm1f4_ha", //const char * variant_function_name; +1250, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4_mask", //const char * parent_function_name; +"__svml_expm1f4_ep_mask", //const char * variant_function_name; +1251, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4_mask", //const char * parent_function_name; +"__svml_expm1f4_mask", //const char * variant_function_name; +1252, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f4_mask", //const char * parent_function_name; +"__svml_expm1f4_ha_mask", //const char * variant_function_name; +1253, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8", //const char * parent_function_name; +"__svml_expm1f8_ep", //const char * variant_function_name; +1254, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8", //const char * parent_function_name; +"__svml_expm1f8", //const char * variant_function_name; +1255, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8", //const char * parent_function_name; +"__svml_expm1f8_ha", //const char * variant_function_name; +1256, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8", //const char * parent_function_name; +"__svml_expm1f8_br", //const char * variant_function_name; +1257, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8_mask", //const char * parent_function_name; +"__svml_expm1f8_ep_mask", //const char * variant_function_name; +1258, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8_mask", //const char * parent_function_name; +"__svml_expm1f8_mask", //const char * variant_function_name; +1259, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8_mask", //const char * parent_function_name; +"__svml_expm1f8_ha_mask", //const char * variant_function_name; +1260, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_expm1f8_mask", //const char * parent_function_name; +"__svml_expm1f8_br_mask", //const char * variant_function_name; +1261, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor2", //const char * parent_function_name; +"__svml_floor2", //const char * variant_function_name; +1262, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor2_mask", //const char * parent_function_name; +"__svml_floor2_mask", //const char * variant_function_name; +1263, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor4", //const char * parent_function_name; +"__svml_floor4", //const char * variant_function_name; +1264, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor4_mask", //const char * parent_function_name; +"__svml_floor4_mask", //const char * variant_function_name; +1265, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor8", //const char * parent_function_name; +"__svml_floor8", //const char * variant_function_name; +1266, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floor8_mask", //const char * parent_function_name; +"__svml_floor8_mask", //const char * variant_function_name; +1267, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf16", //const char * parent_function_name; +"__svml_floorf16", //const char * variant_function_name; +1268, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf16_mask", //const char * parent_function_name; +"__svml_floorf16_mask", //const char * variant_function_name; +1269, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf4", //const char * parent_function_name; +"__svml_floorf4", //const char * variant_function_name; +1270, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf4_mask", //const char * parent_function_name; +"__svml_floorf4_mask", //const char * variant_function_name; +1271, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf8", //const char * parent_function_name; +"__svml_floorf8", //const char * variant_function_name; +1272, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_floorf8_mask", //const char * parent_function_name; +"__svml_floorf8_mask", //const char * variant_function_name; +1273, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod2", //const char * parent_function_name; +"__svml_fmod2", //const char * variant_function_name; +1274, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod2", //const char * parent_function_name; +"__svml_fmod2", //const char * variant_function_name; +1275, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod2_mask", //const char * parent_function_name; +"__svml_fmod2_mask", //const char * variant_function_name; +1276, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod2_mask", //const char * parent_function_name; +"__svml_fmod2_mask", //const char * variant_function_name; +1277, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod4", //const char * parent_function_name; +"__svml_fmod4", //const char * variant_function_name; +1278, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod4", //const char * parent_function_name; +"__svml_fmod4", //const char * variant_function_name; +1279, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod4_mask", //const char * parent_function_name; +"__svml_fmod4_mask", //const char * variant_function_name; +1280, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod4_mask", //const char * parent_function_name; +"__svml_fmod4_mask", //const char * variant_function_name; +1281, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod8", //const char * parent_function_name; +"__svml_fmod8", //const char * variant_function_name; +1282, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod8", //const char * parent_function_name; +"__svml_fmod8", //const char * variant_function_name; +1283, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod8_mask", //const char * parent_function_name; +"__svml_fmod8_mask", //const char * variant_function_name; +1284, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmod8_mask", //const char * parent_function_name; +"__svml_fmod8_mask", //const char * variant_function_name; +1285, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf16", //const char * parent_function_name; +"__svml_fmodf16", //const char * variant_function_name; +1286, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf16", //const char * parent_function_name; +"__svml_fmodf16", //const char * variant_function_name; +1287, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf16_mask", //const char * parent_function_name; +"__svml_fmodf16_mask", //const char * variant_function_name; +1288, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf16_mask", //const char * parent_function_name; +"__svml_fmodf16_mask", //const char * variant_function_name; +1289, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf4", //const char * parent_function_name; +"__svml_fmodf4", //const char * variant_function_name; +1290, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf4", //const char * parent_function_name; +"__svml_fmodf4", //const char * variant_function_name; +1291, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf4_mask", //const char * parent_function_name; +"__svml_fmodf4_mask", //const char * variant_function_name; +1292, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf4_mask", //const char * parent_function_name; +"__svml_fmodf4_mask", //const char * variant_function_name; +1293, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf8", //const char * parent_function_name; +"__svml_fmodf8", //const char * variant_function_name; +1294, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf8", //const char * parent_function_name; +"__svml_fmodf8", //const char * variant_function_name; +1295, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf8_mask", //const char * parent_function_name; +"__svml_fmodf8_mask", //const char * variant_function_name; +1296, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_fmodf8_mask", //const char * parent_function_name; +"__svml_fmodf8_mask", //const char * variant_function_name; +1297, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2", //const char * parent_function_name; +"__svml_hypot2_ep", //const char * variant_function_name; +1298, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2", //const char * parent_function_name; +"__svml_hypot2", //const char * variant_function_name; +1299, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2", //const char * parent_function_name; +"__svml_hypot2_ha", //const char * variant_function_name; +1300, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2_mask", //const char * parent_function_name; +"__svml_hypot2_ep_mask", //const char * variant_function_name; +1301, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2_mask", //const char * parent_function_name; +"__svml_hypot2_mask", //const char * variant_function_name; +1302, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot2_mask", //const char * parent_function_name; +"__svml_hypot2_ha_mask", //const char * variant_function_name; +1303, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4", //const char * parent_function_name; +"__svml_hypot4_ep", //const char * variant_function_name; +1304, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4", //const char * parent_function_name; +"__svml_hypot4", //const char * variant_function_name; +1305, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4", //const char * parent_function_name; +"__svml_hypot4_ha", //const char * variant_function_name; +1306, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4", //const char * parent_function_name; +"__svml_hypot4_br", //const char * variant_function_name; +1307, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4_mask", //const char * parent_function_name; +"__svml_hypot4_ep_mask", //const char * variant_function_name; +1308, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4_mask", //const char * parent_function_name; +"__svml_hypot4_mask", //const char * variant_function_name; +1309, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4_mask", //const char * parent_function_name; +"__svml_hypot4_ha_mask", //const char * variant_function_name; +1310, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot4_mask", //const char * parent_function_name; +"__svml_hypot4_br_mask", //const char * variant_function_name; +1311, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8", //const char * parent_function_name; +"__svml_hypot8_ep", //const char * variant_function_name; +1312, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8", //const char * parent_function_name; +"__svml_hypot8", //const char * variant_function_name; +1313, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8", //const char * parent_function_name; +"__svml_hypot8_ha", //const char * variant_function_name; +1314, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8_mask", //const char * parent_function_name; +"__svml_hypot8_ep_mask", //const char * variant_function_name; +1315, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8_mask", //const char * parent_function_name; +"__svml_hypot8_mask", //const char * variant_function_name; +1316, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypot8_mask", //const char * parent_function_name; +"__svml_hypot8_ha_mask", //const char * variant_function_name; +1317, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16", //const char * parent_function_name; +"__svml_hypotf16_ep", //const char * variant_function_name; +1318, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16", //const char * parent_function_name; +"__svml_hypotf16", //const char * variant_function_name; +1319, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16", //const char * parent_function_name; +"__svml_hypotf16_ha", //const char * variant_function_name; +1320, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16_mask", //const char * parent_function_name; +"__svml_hypotf16_ep_mask", //const char * variant_function_name; +1321, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16_mask", //const char * parent_function_name; +"__svml_hypotf16_mask", //const char * variant_function_name; +1322, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf16_mask", //const char * parent_function_name; +"__svml_hypotf16_ha_mask", //const char * variant_function_name; +1323, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4", //const char * parent_function_name; +"__svml_hypotf4_ep", //const char * variant_function_name; +1324, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4", //const char * parent_function_name; +"__svml_hypotf4", //const char * variant_function_name; +1325, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4", //const char * parent_function_name; +"__svml_hypotf4_ha", //const char * variant_function_name; +1326, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4_mask", //const char * parent_function_name; +"__svml_hypotf4_ep_mask", //const char * variant_function_name; +1327, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4_mask", //const char * parent_function_name; +"__svml_hypotf4_mask", //const char * variant_function_name; +1328, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf4_mask", //const char * parent_function_name; +"__svml_hypotf4_ha_mask", //const char * variant_function_name; +1329, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8", //const char * parent_function_name; +"__svml_hypotf8_ep", //const char * variant_function_name; +1330, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8", //const char * parent_function_name; +"__svml_hypotf8", //const char * variant_function_name; +1331, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8", //const char * parent_function_name; +"__svml_hypotf8_ha", //const char * variant_function_name; +1332, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8", //const char * parent_function_name; +"__svml_hypotf8_br", //const char * variant_function_name; +1333, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8_mask", //const char * parent_function_name; +"__svml_hypotf8_ep_mask", //const char * variant_function_name; +1334, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +31, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8_mask", //const char * parent_function_name; +"__svml_hypotf8_mask", //const char * variant_function_name; +1335, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8_mask", //const char * parent_function_name; +"__svml_hypotf8_ha_mask", //const char * variant_function_name; +1336, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_hypotf8_mask", //const char * parent_function_name; +"__svml_hypotf8_br_mask", //const char * variant_function_name; +1337, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div16", //const char * parent_function_name; +"__svml_i16div16", //const char * variant_function_name; +1338, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div16_mask", //const char * parent_function_name; +"__svml_i16div16_mask", //const char * variant_function_name; +1339, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div32", //const char * parent_function_name; +"__svml_i16div32", //const char * variant_function_name; +1340, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div32_mask", //const char * parent_function_name; +"__svml_i16div32_mask", //const char * variant_function_name; +1341, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div8", //const char * parent_function_name; +"__svml_i16div8", //const char * variant_function_name; +1342, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16div8_mask", //const char * parent_function_name; +"__svml_i16div8_mask", //const char * variant_function_name; +1343, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem16", //const char * parent_function_name; +"__svml_i16rem16", //const char * variant_function_name; +1344, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem16_mask", //const char * parent_function_name; +"__svml_i16rem16_mask", //const char * variant_function_name; +1345, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem32", //const char * parent_function_name; +"__svml_i16rem32", //const char * variant_function_name; +1346, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem32_mask", //const char * parent_function_name; +"__svml_i16rem32_mask", //const char * variant_function_name; +1347, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem8", //const char * parent_function_name; +"__svml_i16rem8", //const char * variant_function_name; +1348, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i16rem8_mask", //const char * parent_function_name; +"__svml_i16rem8_mask", //const char * variant_function_name; +1349, //int Index; +PE_PrecisionSignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div2", //const char * parent_function_name; +"__svml_i64div2", //const char * variant_function_name; +1350, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div2_mask", //const char * parent_function_name; +"__svml_i64div2_mask", //const char * variant_function_name; +1351, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div4", //const char * parent_function_name; +"__svml_i64div4", //const char * variant_function_name; +1352, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div4_mask", //const char * parent_function_name; +"__svml_i64div4_mask", //const char * variant_function_name; +1353, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div8", //const char * parent_function_name; +"__svml_i64div8", //const char * variant_function_name; +1354, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64div8_mask", //const char * parent_function_name; +"__svml_i64div8_mask", //const char * variant_function_name; +1355, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem2", //const char * parent_function_name; +"__svml_i64rem2", //const char * variant_function_name; +1356, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem2_mask", //const char * parent_function_name; +"__svml_i64rem2_mask", //const char * variant_function_name; +1357, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem4", //const char * parent_function_name; +"__svml_i64rem4", //const char * variant_function_name; +1358, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem4_mask", //const char * parent_function_name; +"__svml_i64rem4_mask", //const char * variant_function_name; +1359, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem8", //const char * parent_function_name; +"__svml_i64rem8", //const char * variant_function_name; +1360, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i64rem8_mask", //const char * parent_function_name; +"__svml_i64rem8_mask", //const char * variant_function_name; +1361, //int Index; +PE_PrecisionSignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div16", //const char * parent_function_name; +"__svml_i8div16", //const char * variant_function_name; +1362, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div16_mask", //const char * parent_function_name; +"__svml_i8div16_mask", //const char * variant_function_name; +1363, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div32", //const char * parent_function_name; +"__svml_i8div32", //const char * variant_function_name; +1364, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div32_mask", //const char * parent_function_name; +"__svml_i8div32_mask", //const char * variant_function_name; +1365, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div64", //const char * parent_function_name; +"__svml_i8div64", //const char * variant_function_name; +1366, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8div64_mask", //const char * parent_function_name; +"__svml_i8div64_mask", //const char * variant_function_name; +1367, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem16", //const char * parent_function_name; +"__svml_i8rem16", //const char * variant_function_name; +1368, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem16_mask", //const char * parent_function_name; +"__svml_i8rem16_mask", //const char * variant_function_name; +1369, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem32", //const char * parent_function_name; +"__svml_i8rem32", //const char * variant_function_name; +1370, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem32_mask", //const char * parent_function_name; +"__svml_i8rem32_mask", //const char * variant_function_name; +1371, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem64", //const char * parent_function_name; +"__svml_i8rem64", //const char * variant_function_name; +1372, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_i8rem64_mask", //const char * parent_function_name; +"__svml_i8rem64_mask", //const char * variant_function_name; +1373, //int Index; +PE_PrecisionSignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv16", //const char * parent_function_name; +"__svml_idiv16", //const char * variant_function_name; +1374, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv16_mask", //const char * parent_function_name; +"__svml_idiv16_mask", //const char * variant_function_name; +1375, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv4", //const char * parent_function_name; +"__svml_idiv4", //const char * variant_function_name; +1376, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv4_mask", //const char * parent_function_name; +"__svml_idiv4_mask", //const char * variant_function_name; +1377, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv8", //const char * parent_function_name; +"__svml_idiv8", //const char * variant_function_name; +1378, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idiv8_mask", //const char * parent_function_name; +"__svml_idiv8_mask", //const char * variant_function_name; +1379, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem16", //const char * parent_function_name; +"__svml_idivrem16", //const char * variant_function_name; +1380, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem16_mask", //const char * parent_function_name; +"__svml_idivrem16_mask", //const char * variant_function_name; +1381, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem4", //const char * parent_function_name; +"__svml_idivrem4", //const char * variant_function_name; +1382, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem4_mask", //const char * parent_function_name; +"__svml_idivrem4_mask", //const char * variant_function_name; +1383, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem8", //const char * parent_function_name; +"__svml_idivrem8", //const char * variant_function_name; +1384, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_idivrem8_mask", //const char * parent_function_name; +"__svml_idivrem8_mask", //const char * variant_function_name; +1385, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2", //const char * parent_function_name; +"__svml_invcbrt2_ep", //const char * variant_function_name; +1386, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2", //const char * parent_function_name; +"__svml_invcbrt2", //const char * variant_function_name; +1387, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2", //const char * parent_function_name; +"__svml_invcbrt2_ha", //const char * variant_function_name; +1388, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2_mask", //const char * parent_function_name; +"__svml_invcbrt2_ep_mask", //const char * variant_function_name; +1389, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2_mask", //const char * parent_function_name; +"__svml_invcbrt2_mask", //const char * variant_function_name; +1390, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt2_mask", //const char * parent_function_name; +"__svml_invcbrt2_ha_mask", //const char * variant_function_name; +1391, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4", //const char * parent_function_name; +"__svml_invcbrt4_ep", //const char * variant_function_name; +1392, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4", //const char * parent_function_name; +"__svml_invcbrt4", //const char * variant_function_name; +1393, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4", //const char * parent_function_name; +"__svml_invcbrt4_ha", //const char * variant_function_name; +1394, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4", //const char * parent_function_name; +"__svml_invcbrt4_br", //const char * variant_function_name; +1395, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4_mask", //const char * parent_function_name; +"__svml_invcbrt4_ep_mask", //const char * variant_function_name; +1396, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4_mask", //const char * parent_function_name; +"__svml_invcbrt4_mask", //const char * variant_function_name; +1397, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4_mask", //const char * parent_function_name; +"__svml_invcbrt4_ha_mask", //const char * variant_function_name; +1398, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt4_mask", //const char * parent_function_name; +"__svml_invcbrt4_br_mask", //const char * variant_function_name; +1399, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8", //const char * parent_function_name; +"__svml_invcbrt8_ep", //const char * variant_function_name; +1400, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8", //const char * parent_function_name; +"__svml_invcbrt8", //const char * variant_function_name; +1401, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8", //const char * parent_function_name; +"__svml_invcbrt8_ha", //const char * variant_function_name; +1402, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8_mask", //const char * parent_function_name; +"__svml_invcbrt8_ep_mask", //const char * variant_function_name; +1403, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8_mask", //const char * parent_function_name; +"__svml_invcbrt8_mask", //const char * variant_function_name; +1404, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrt8_mask", //const char * parent_function_name; +"__svml_invcbrt8_ha_mask", //const char * variant_function_name; +1405, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16", //const char * parent_function_name; +"__svml_invcbrtf16_ep", //const char * variant_function_name; +1406, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16", //const char * parent_function_name; +"__svml_invcbrtf16", //const char * variant_function_name; +1407, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16", //const char * parent_function_name; +"__svml_invcbrtf16_ha", //const char * variant_function_name; +1408, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16_mask", //const char * parent_function_name; +"__svml_invcbrtf16_ep_mask", //const char * variant_function_name; +1409, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16_mask", //const char * parent_function_name; +"__svml_invcbrtf16_mask", //const char * variant_function_name; +1410, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf16_mask", //const char * parent_function_name; +"__svml_invcbrtf16_ha_mask", //const char * variant_function_name; +1411, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4", //const char * parent_function_name; +"__svml_invcbrtf4_ep", //const char * variant_function_name; +1412, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4", //const char * parent_function_name; +"__svml_invcbrtf4", //const char * variant_function_name; +1413, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4", //const char * parent_function_name; +"__svml_invcbrtf4_ha", //const char * variant_function_name; +1414, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4_mask", //const char * parent_function_name; +"__svml_invcbrtf4_ep_mask", //const char * variant_function_name; +1415, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4_mask", //const char * parent_function_name; +"__svml_invcbrtf4_mask", //const char * variant_function_name; +1416, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf4_mask", //const char * parent_function_name; +"__svml_invcbrtf4_ha_mask", //const char * variant_function_name; +1417, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8", //const char * parent_function_name; +"__svml_invcbrtf8_ep", //const char * variant_function_name; +1418, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8", //const char * parent_function_name; +"__svml_invcbrtf8", //const char * variant_function_name; +1419, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8", //const char * parent_function_name; +"__svml_invcbrtf8_ha", //const char * variant_function_name; +1420, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8", //const char * parent_function_name; +"__svml_invcbrtf8_br", //const char * variant_function_name; +1421, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8_mask", //const char * parent_function_name; +"__svml_invcbrtf8_ep_mask", //const char * variant_function_name; +1422, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8_mask", //const char * parent_function_name; +"__svml_invcbrtf8_mask", //const char * variant_function_name; +1423, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8_mask", //const char * parent_function_name; +"__svml_invcbrtf8_ha_mask", //const char * variant_function_name; +1424, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invcbrtf8_mask", //const char * parent_function_name; +"__svml_invcbrtf8_br_mask", //const char * variant_function_name; +1425, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2", //const char * parent_function_name; +"__svml_invsqrt2_ep", //const char * variant_function_name; +1426, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2", //const char * parent_function_name; +"__svml_invsqrt2", //const char * variant_function_name; +1427, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2", //const char * parent_function_name; +"__svml_invsqrt2_ha", //const char * variant_function_name; +1428, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2", //const char * parent_function_name; +"__svml_invsqrt2_br", //const char * variant_function_name; +1429, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2_mask", //const char * parent_function_name; +"__svml_invsqrt2_ep_mask", //const char * variant_function_name; +1430, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2_mask", //const char * parent_function_name; +"__svml_invsqrt2_mask", //const char * variant_function_name; +1431, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2_mask", //const char * parent_function_name; +"__svml_invsqrt2_ha_mask", //const char * variant_function_name; +1432, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt2_mask", //const char * parent_function_name; +"__svml_invsqrt2_br_mask", //const char * variant_function_name; +1433, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4", //const char * parent_function_name; +"__svml_invsqrt4_ep", //const char * variant_function_name; +1434, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4", //const char * parent_function_name; +"__svml_invsqrt4", //const char * variant_function_name; +1435, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4", //const char * parent_function_name; +"__svml_invsqrt4_ha", //const char * variant_function_name; +1436, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4", //const char * parent_function_name; +"__svml_invsqrt4_br", //const char * variant_function_name; +1437, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4_mask", //const char * parent_function_name; +"__svml_invsqrt4_ep_mask", //const char * variant_function_name; +1438, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4_mask", //const char * parent_function_name; +"__svml_invsqrt4_mask", //const char * variant_function_name; +1439, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4_mask", //const char * parent_function_name; +"__svml_invsqrt4_ha_mask", //const char * variant_function_name; +1440, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt4_mask", //const char * parent_function_name; +"__svml_invsqrt4_br_mask", //const char * variant_function_name; +1441, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8", //const char * parent_function_name; +"__svml_invsqrt8_ep", //const char * variant_function_name; +1442, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8", //const char * parent_function_name; +"__svml_invsqrt8", //const char * variant_function_name; +1443, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8", //const char * parent_function_name; +"__svml_invsqrt8_ha", //const char * variant_function_name; +1444, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8", //const char * parent_function_name; +"__svml_invsqrt8_br", //const char * variant_function_name; +1445, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8_mask", //const char * parent_function_name; +"__svml_invsqrt8_ep_mask", //const char * variant_function_name; +1446, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8_mask", //const char * parent_function_name; +"__svml_invsqrt8_mask", //const char * variant_function_name; +1447, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8_mask", //const char * parent_function_name; +"__svml_invsqrt8_ha_mask", //const char * variant_function_name; +1448, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrt8_mask", //const char * parent_function_name; +"__svml_invsqrt8_br_mask", //const char * variant_function_name; +1449, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16", //const char * parent_function_name; +"__svml_invsqrtf16_ep", //const char * variant_function_name; +1450, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16", //const char * parent_function_name; +"__svml_invsqrtf16", //const char * variant_function_name; +1451, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16", //const char * parent_function_name; +"__svml_invsqrtf16_ha", //const char * variant_function_name; +1452, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16", //const char * parent_function_name; +"__svml_invsqrtf16_br", //const char * variant_function_name; +1453, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16_mask", //const char * parent_function_name; +"__svml_invsqrtf16_ep_mask", //const char * variant_function_name; +1454, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16_mask", //const char * parent_function_name; +"__svml_invsqrtf16_mask", //const char * variant_function_name; +1455, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16_mask", //const char * parent_function_name; +"__svml_invsqrtf16_ha_mask", //const char * variant_function_name; +1456, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf16_mask", //const char * parent_function_name; +"__svml_invsqrtf16_br_mask", //const char * variant_function_name; +1457, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4", //const char * parent_function_name; +"__svml_invsqrtf4_ep", //const char * variant_function_name; +1458, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4", //const char * parent_function_name; +"__svml_invsqrtf4", //const char * variant_function_name; +1459, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4", //const char * parent_function_name; +"__svml_invsqrtf4_ha", //const char * variant_function_name; +1460, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4", //const char * parent_function_name; +"__svml_invsqrtf4_br", //const char * variant_function_name; +1461, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4_mask", //const char * parent_function_name; +"__svml_invsqrtf4_ep_mask", //const char * variant_function_name; +1462, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4_mask", //const char * parent_function_name; +"__svml_invsqrtf4_mask", //const char * variant_function_name; +1463, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4_mask", //const char * parent_function_name; +"__svml_invsqrtf4_ha_mask", //const char * variant_function_name; +1464, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf4_mask", //const char * parent_function_name; +"__svml_invsqrtf4_br_mask", //const char * variant_function_name; +1465, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8", //const char * parent_function_name; +"__svml_invsqrtf8_ep", //const char * variant_function_name; +1466, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8", //const char * parent_function_name; +"__svml_invsqrtf8", //const char * variant_function_name; +1467, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8", //const char * parent_function_name; +"__svml_invsqrtf8_ha", //const char * variant_function_name; +1468, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8", //const char * parent_function_name; +"__svml_invsqrtf8_br", //const char * variant_function_name; +1469, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8_mask", //const char * parent_function_name; +"__svml_invsqrtf8_ep_mask", //const char * variant_function_name; +1470, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8_mask", //const char * parent_function_name; +"__svml_invsqrtf8_mask", //const char * variant_function_name; +1471, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8_mask", //const char * parent_function_name; +"__svml_invsqrtf8_ha_mask", //const char * variant_function_name; +1472, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_invsqrtf8_mask", //const char * parent_function_name; +"__svml_invsqrtf8_br_mask", //const char * variant_function_name; +1473, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem16", //const char * parent_function_name; +"__svml_irem16", //const char * variant_function_name; +1474, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem16_mask", //const char * parent_function_name; +"__svml_irem16_mask", //const char * variant_function_name; +1475, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem4", //const char * parent_function_name; +"__svml_irem4", //const char * variant_function_name; +1476, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem4_mask", //const char * parent_function_name; +"__svml_irem4_mask", //const char * variant_function_name; +1477, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem8", //const char * parent_function_name; +"__svml_irem8", //const char * variant_function_name; +1478, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_irem8_mask", //const char * parent_function_name; +"__svml_irem8_mask", //const char * variant_function_name; +1479, //int Index; +PE_PrecisionSignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102", //const char * parent_function_name; +"__svml_log102_ep", //const char * variant_function_name; +1480, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102", //const char * parent_function_name; +"__svml_log102", //const char * variant_function_name; +1481, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102", //const char * parent_function_name; +"__svml_log102_ha", //const char * variant_function_name; +1482, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102", //const char * parent_function_name; +"__svml_log102_br", //const char * variant_function_name; +1483, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102_mask", //const char * parent_function_name; +"__svml_log102_ep_mask", //const char * variant_function_name; +1484, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102_mask", //const char * parent_function_name; +"__svml_log102_mask", //const char * variant_function_name; +1485, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102_mask", //const char * parent_function_name; +"__svml_log102_ha_mask", //const char * variant_function_name; +1486, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log102_mask", //const char * parent_function_name; +"__svml_log102_br_mask", //const char * variant_function_name; +1487, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104", //const char * parent_function_name; +"__svml_log104_ep", //const char * variant_function_name; +1488, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104", //const char * parent_function_name; +"__svml_log104", //const char * variant_function_name; +1489, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104", //const char * parent_function_name; +"__svml_log104_ha", //const char * variant_function_name; +1490, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104", //const char * parent_function_name; +"__svml_log104_br", //const char * variant_function_name; +1491, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104_mask", //const char * parent_function_name; +"__svml_log104_ep_mask", //const char * variant_function_name; +1492, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104_mask", //const char * parent_function_name; +"__svml_log104_mask", //const char * variant_function_name; +1493, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104_mask", //const char * parent_function_name; +"__svml_log104_ha_mask", //const char * variant_function_name; +1494, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log104_mask", //const char * parent_function_name; +"__svml_log104_br_mask", //const char * variant_function_name; +1495, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108", //const char * parent_function_name; +"__svml_log108_ep", //const char * variant_function_name; +1496, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108", //const char * parent_function_name; +"__svml_log108", //const char * variant_function_name; +1497, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108", //const char * parent_function_name; +"__svml_log108_ha", //const char * variant_function_name; +1498, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108", //const char * parent_function_name; +"__svml_log108_br", //const char * variant_function_name; +1499, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108_mask", //const char * parent_function_name; +"__svml_log108_ep_mask", //const char * variant_function_name; +1500, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108_mask", //const char * parent_function_name; +"__svml_log108_mask", //const char * variant_function_name; +1501, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108_mask", //const char * parent_function_name; +"__svml_log108_ha_mask", //const char * variant_function_name; +1502, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log108_mask", //const char * parent_function_name; +"__svml_log108_br_mask", //const char * variant_function_name; +1503, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16", //const char * parent_function_name; +"__svml_log10f16_ep", //const char * variant_function_name; +1504, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16", //const char * parent_function_name; +"__svml_log10f16", //const char * variant_function_name; +1505, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16", //const char * parent_function_name; +"__svml_log10f16_ha", //const char * variant_function_name; +1506, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16", //const char * parent_function_name; +"__svml_log10f16_br", //const char * variant_function_name; +1507, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16_mask", //const char * parent_function_name; +"__svml_log10f16_ep_mask", //const char * variant_function_name; +1508, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16_mask", //const char * parent_function_name; +"__svml_log10f16_mask", //const char * variant_function_name; +1509, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16_mask", //const char * parent_function_name; +"__svml_log10f16_ha_mask", //const char * variant_function_name; +1510, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f16_mask", //const char * parent_function_name; +"__svml_log10f16_br_mask", //const char * variant_function_name; +1511, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4", //const char * parent_function_name; +"__svml_log10f4_ep", //const char * variant_function_name; +1512, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4", //const char * parent_function_name; +"__svml_log10f4", //const char * variant_function_name; +1513, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4", //const char * parent_function_name; +"__svml_log10f4_ha", //const char * variant_function_name; +1514, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4", //const char * parent_function_name; +"__svml_log10f4_br", //const char * variant_function_name; +1515, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4_mask", //const char * parent_function_name; +"__svml_log10f4_ep_mask", //const char * variant_function_name; +1516, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4_mask", //const char * parent_function_name; +"__svml_log10f4_mask", //const char * variant_function_name; +1517, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4_mask", //const char * parent_function_name; +"__svml_log10f4_ha_mask", //const char * variant_function_name; +1518, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f4_mask", //const char * parent_function_name; +"__svml_log10f4_br_mask", //const char * variant_function_name; +1519, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8", //const char * parent_function_name; +"__svml_log10f8_ep", //const char * variant_function_name; +1520, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8", //const char * parent_function_name; +"__svml_log10f8", //const char * variant_function_name; +1521, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8", //const char * parent_function_name; +"__svml_log10f8_ha", //const char * variant_function_name; +1522, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8", //const char * parent_function_name; +"__svml_log10f8_br", //const char * variant_function_name; +1523, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8_mask", //const char * parent_function_name; +"__svml_log10f8_ep_mask", //const char * variant_function_name; +1524, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8_mask", //const char * parent_function_name; +"__svml_log10f8_mask", //const char * variant_function_name; +1525, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8_mask", //const char * parent_function_name; +"__svml_log10f8_ha_mask", //const char * variant_function_name; +1526, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log10f8_mask", //const char * parent_function_name; +"__svml_log10f8_br_mask", //const char * variant_function_name; +1527, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2", //const char * parent_function_name; +"__svml_log1p2_ep", //const char * variant_function_name; +1528, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2", //const char * parent_function_name; +"__svml_log1p2", //const char * variant_function_name; +1529, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2", //const char * parent_function_name; +"__svml_log1p2_ha", //const char * variant_function_name; +1530, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2", //const char * parent_function_name; +"__svml_log1p2_br", //const char * variant_function_name; +1531, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2_mask", //const char * parent_function_name; +"__svml_log1p2_ep_mask", //const char * variant_function_name; +1532, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2_mask", //const char * parent_function_name; +"__svml_log1p2_mask", //const char * variant_function_name; +1533, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2_mask", //const char * parent_function_name; +"__svml_log1p2_ha_mask", //const char * variant_function_name; +1534, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p2_mask", //const char * parent_function_name; +"__svml_log1p2_br_mask", //const char * variant_function_name; +1535, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4", //const char * parent_function_name; +"__svml_log1p4_ep", //const char * variant_function_name; +1536, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4", //const char * parent_function_name; +"__svml_log1p4", //const char * variant_function_name; +1537, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4", //const char * parent_function_name; +"__svml_log1p4_ha", //const char * variant_function_name; +1538, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4", //const char * parent_function_name; +"__svml_log1p4_br", //const char * variant_function_name; +1539, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4_mask", //const char * parent_function_name; +"__svml_log1p4_ep_mask", //const char * variant_function_name; +1540, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4_mask", //const char * parent_function_name; +"__svml_log1p4_mask", //const char * variant_function_name; +1541, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4_mask", //const char * parent_function_name; +"__svml_log1p4_ha_mask", //const char * variant_function_name; +1542, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p4_mask", //const char * parent_function_name; +"__svml_log1p4_br_mask", //const char * variant_function_name; +1543, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8", //const char * parent_function_name; +"__svml_log1p8_ep", //const char * variant_function_name; +1544, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8", //const char * parent_function_name; +"__svml_log1p8", //const char * variant_function_name; +1545, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8", //const char * parent_function_name; +"__svml_log1p8_ha", //const char * variant_function_name; +1546, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8", //const char * parent_function_name; +"__svml_log1p8_br", //const char * variant_function_name; +1547, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8_mask", //const char * parent_function_name; +"__svml_log1p8_ep_mask", //const char * variant_function_name; +1548, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8_mask", //const char * parent_function_name; +"__svml_log1p8_mask", //const char * variant_function_name; +1549, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8_mask", //const char * parent_function_name; +"__svml_log1p8_ha_mask", //const char * variant_function_name; +1550, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1p8_mask", //const char * parent_function_name; +"__svml_log1p8_br_mask", //const char * variant_function_name; +1551, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16", //const char * parent_function_name; +"__svml_log1pf16_ep", //const char * variant_function_name; +1552, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16", //const char * parent_function_name; +"__svml_log1pf16", //const char * variant_function_name; +1553, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16", //const char * parent_function_name; +"__svml_log1pf16_ha", //const char * variant_function_name; +1554, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16", //const char * parent_function_name; +"__svml_log1pf16_br", //const char * variant_function_name; +1555, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16_mask", //const char * parent_function_name; +"__svml_log1pf16_ep_mask", //const char * variant_function_name; +1556, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16_mask", //const char * parent_function_name; +"__svml_log1pf16_mask", //const char * variant_function_name; +1557, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16_mask", //const char * parent_function_name; +"__svml_log1pf16_ha_mask", //const char * variant_function_name; +1558, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf16_mask", //const char * parent_function_name; +"__svml_log1pf16_br_mask", //const char * variant_function_name; +1559, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4", //const char * parent_function_name; +"__svml_log1pf4_ep", //const char * variant_function_name; +1560, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4", //const char * parent_function_name; +"__svml_log1pf4", //const char * variant_function_name; +1561, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4", //const char * parent_function_name; +"__svml_log1pf4_ha", //const char * variant_function_name; +1562, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4", //const char * parent_function_name; +"__svml_log1pf4_br", //const char * variant_function_name; +1563, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4_mask", //const char * parent_function_name; +"__svml_log1pf4_ep_mask", //const char * variant_function_name; +1564, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4_mask", //const char * parent_function_name; +"__svml_log1pf4_mask", //const char * variant_function_name; +1565, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4_mask", //const char * parent_function_name; +"__svml_log1pf4_ha_mask", //const char * variant_function_name; +1566, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf4_mask", //const char * parent_function_name; +"__svml_log1pf4_br_mask", //const char * variant_function_name; +1567, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8", //const char * parent_function_name; +"__svml_log1pf8_ep", //const char * variant_function_name; +1568, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8", //const char * parent_function_name; +"__svml_log1pf8", //const char * variant_function_name; +1569, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8", //const char * parent_function_name; +"__svml_log1pf8_ha", //const char * variant_function_name; +1570, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8", //const char * parent_function_name; +"__svml_log1pf8_br", //const char * variant_function_name; +1571, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8_mask", //const char * parent_function_name; +"__svml_log1pf8_ep_mask", //const char * variant_function_name; +1572, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8_mask", //const char * parent_function_name; +"__svml_log1pf8_mask", //const char * variant_function_name; +1573, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8_mask", //const char * parent_function_name; +"__svml_log1pf8_ha_mask", //const char * variant_function_name; +1574, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log1pf8_mask", //const char * parent_function_name; +"__svml_log1pf8_br_mask", //const char * variant_function_name; +1575, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2", //const char * parent_function_name; +"__svml_log2_ep", //const char * variant_function_name; +1576, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2", //const char * parent_function_name; +"__svml_log2", //const char * variant_function_name; +1577, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2", //const char * parent_function_name; +"__svml_log2_ha", //const char * variant_function_name; +1578, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2", //const char * parent_function_name; +"__svml_log2_br", //const char * variant_function_name; +1579, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22", //const char * parent_function_name; +"__svml_log22_ep", //const char * variant_function_name; +1580, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22", //const char * parent_function_name; +"__svml_log22", //const char * variant_function_name; +1581, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22", //const char * parent_function_name; +"__svml_log22_ha", //const char * variant_function_name; +1582, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22", //const char * parent_function_name; +"__svml_log22_br", //const char * variant_function_name; +1583, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22_mask", //const char * parent_function_name; +"__svml_log22_ep_mask", //const char * variant_function_name; +1584, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22_mask", //const char * parent_function_name; +"__svml_log22_mask", //const char * variant_function_name; +1585, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22_mask", //const char * parent_function_name; +"__svml_log22_ha_mask", //const char * variant_function_name; +1586, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log22_mask", //const char * parent_function_name; +"__svml_log22_br_mask", //const char * variant_function_name; +1587, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24", //const char * parent_function_name; +"__svml_log24_ep", //const char * variant_function_name; +1588, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24", //const char * parent_function_name; +"__svml_log24", //const char * variant_function_name; +1589, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24", //const char * parent_function_name; +"__svml_log24_ha", //const char * variant_function_name; +1590, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24", //const char * parent_function_name; +"__svml_log24_br", //const char * variant_function_name; +1591, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24_mask", //const char * parent_function_name; +"__svml_log24_ep_mask", //const char * variant_function_name; +1592, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24_mask", //const char * parent_function_name; +"__svml_log24_mask", //const char * variant_function_name; +1593, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24_mask", //const char * parent_function_name; +"__svml_log24_ha_mask", //const char * variant_function_name; +1594, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log24_mask", //const char * parent_function_name; +"__svml_log24_br_mask", //const char * variant_function_name; +1595, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28", //const char * parent_function_name; +"__svml_log28_ep", //const char * variant_function_name; +1596, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28", //const char * parent_function_name; +"__svml_log28", //const char * variant_function_name; +1597, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28", //const char * parent_function_name; +"__svml_log28_ha", //const char * variant_function_name; +1598, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28", //const char * parent_function_name; +"__svml_log28_br", //const char * variant_function_name; +1599, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28_mask", //const char * parent_function_name; +"__svml_log28_ep_mask", //const char * variant_function_name; +1600, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28_mask", //const char * parent_function_name; +"__svml_log28_mask", //const char * variant_function_name; +1601, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28_mask", //const char * parent_function_name; +"__svml_log28_ha_mask", //const char * variant_function_name; +1602, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log28_mask", //const char * parent_function_name; +"__svml_log28_br_mask", //const char * variant_function_name; +1603, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2_mask", //const char * parent_function_name; +"__svml_log2_ep_mask", //const char * variant_function_name; +1604, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2_mask", //const char * parent_function_name; +"__svml_log2_mask", //const char * variant_function_name; +1605, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2_mask", //const char * parent_function_name; +"__svml_log2_ha_mask", //const char * variant_function_name; +1606, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2_mask", //const char * parent_function_name; +"__svml_log2_br_mask", //const char * variant_function_name; +1607, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16", //const char * parent_function_name; +"__svml_log2f16_ep", //const char * variant_function_name; +1608, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16", //const char * parent_function_name; +"__svml_log2f16", //const char * variant_function_name; +1609, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16", //const char * parent_function_name; +"__svml_log2f16_ha", //const char * variant_function_name; +1610, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16", //const char * parent_function_name; +"__svml_log2f16_br", //const char * variant_function_name; +1611, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16_mask", //const char * parent_function_name; +"__svml_log2f16_ep_mask", //const char * variant_function_name; +1612, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16_mask", //const char * parent_function_name; +"__svml_log2f16_mask", //const char * variant_function_name; +1613, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16_mask", //const char * parent_function_name; +"__svml_log2f16_ha_mask", //const char * variant_function_name; +1614, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f16_mask", //const char * parent_function_name; +"__svml_log2f16_br_mask", //const char * variant_function_name; +1615, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4", //const char * parent_function_name; +"__svml_log2f4_ep", //const char * variant_function_name; +1616, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4", //const char * parent_function_name; +"__svml_log2f4", //const char * variant_function_name; +1617, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4", //const char * parent_function_name; +"__svml_log2f4_ha", //const char * variant_function_name; +1618, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4", //const char * parent_function_name; +"__svml_log2f4_br", //const char * variant_function_name; +1619, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4_mask", //const char * parent_function_name; +"__svml_log2f4_ep_mask", //const char * variant_function_name; +1620, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4_mask", //const char * parent_function_name; +"__svml_log2f4_mask", //const char * variant_function_name; +1621, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4_mask", //const char * parent_function_name; +"__svml_log2f4_ha_mask", //const char * variant_function_name; +1622, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f4_mask", //const char * parent_function_name; +"__svml_log2f4_br_mask", //const char * variant_function_name; +1623, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8", //const char * parent_function_name; +"__svml_log2f8_ep", //const char * variant_function_name; +1624, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8", //const char * parent_function_name; +"__svml_log2f8", //const char * variant_function_name; +1625, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8", //const char * parent_function_name; +"__svml_log2f8_ha", //const char * variant_function_name; +1626, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8", //const char * parent_function_name; +"__svml_log2f8_br", //const char * variant_function_name; +1627, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8_mask", //const char * parent_function_name; +"__svml_log2f8_ep_mask", //const char * variant_function_name; +1628, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8_mask", //const char * parent_function_name; +"__svml_log2f8_mask", //const char * variant_function_name; +1629, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8_mask", //const char * parent_function_name; +"__svml_log2f8_ha_mask", //const char * variant_function_name; +1630, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log2f8_mask", //const char * parent_function_name; +"__svml_log2f8_br_mask", //const char * variant_function_name; +1631, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4", //const char * parent_function_name; +"__svml_log4_ep", //const char * variant_function_name; +1632, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4", //const char * parent_function_name; +"__svml_log4", //const char * variant_function_name; +1633, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4", //const char * parent_function_name; +"__svml_log4_ha", //const char * variant_function_name; +1634, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4", //const char * parent_function_name; +"__svml_log4_br", //const char * variant_function_name; +1635, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4_mask", //const char * parent_function_name; +"__svml_log4_ep_mask", //const char * variant_function_name; +1636, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4_mask", //const char * parent_function_name; +"__svml_log4_mask", //const char * variant_function_name; +1637, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4_mask", //const char * parent_function_name; +"__svml_log4_ha_mask", //const char * variant_function_name; +1638, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log4_mask", //const char * parent_function_name; +"__svml_log4_br_mask", //const char * variant_function_name; +1639, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8", //const char * parent_function_name; +"__svml_log8_ep", //const char * variant_function_name; +1640, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8", //const char * parent_function_name; +"__svml_log8", //const char * variant_function_name; +1641, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8", //const char * parent_function_name; +"__svml_log8_ha", //const char * variant_function_name; +1642, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8", //const char * parent_function_name; +"__svml_log8_br", //const char * variant_function_name; +1643, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8_mask", //const char * parent_function_name; +"__svml_log8_ep_mask", //const char * variant_function_name; +1644, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8_mask", //const char * parent_function_name; +"__svml_log8_mask", //const char * variant_function_name; +1645, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8_mask", //const char * parent_function_name; +"__svml_log8_ha_mask", //const char * variant_function_name; +1646, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_log8_mask", //const char * parent_function_name; +"__svml_log8_br_mask", //const char * variant_function_name; +1647, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb2", //const char * parent_function_name; +"__svml_logb2", //const char * variant_function_name; +1648, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb2_mask", //const char * parent_function_name; +"__svml_logb2_mask", //const char * variant_function_name; +1649, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb4", //const char * parent_function_name; +"__svml_logb4", //const char * variant_function_name; +1650, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb4_mask", //const char * parent_function_name; +"__svml_logb4_mask", //const char * variant_function_name; +1651, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb8", //const char * parent_function_name; +"__svml_logb8", //const char * variant_function_name; +1652, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logb8_mask", //const char * parent_function_name; +"__svml_logb8_mask", //const char * variant_function_name; +1653, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf16", //const char * parent_function_name; +"__svml_logbf16", //const char * variant_function_name; +1654, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf16_mask", //const char * parent_function_name; +"__svml_logbf16_mask", //const char * variant_function_name; +1655, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf4", //const char * parent_function_name; +"__svml_logbf4", //const char * variant_function_name; +1656, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf4_mask", //const char * parent_function_name; +"__svml_logbf4_mask", //const char * variant_function_name; +1657, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf8", //const char * parent_function_name; +"__svml_logbf8", //const char * variant_function_name; +1658, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logbf8_mask", //const char * parent_function_name; +"__svml_logbf8_mask", //const char * variant_function_name; +1659, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16", //const char * parent_function_name; +"__svml_logf16_ep", //const char * variant_function_name; +1660, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16", //const char * parent_function_name; +"__svml_logf16", //const char * variant_function_name; +1661, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16", //const char * parent_function_name; +"__svml_logf16_ha", //const char * variant_function_name; +1662, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16", //const char * parent_function_name; +"__svml_logf16_br", //const char * variant_function_name; +1663, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16_mask", //const char * parent_function_name; +"__svml_logf16_ep_mask", //const char * variant_function_name; +1664, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16_mask", //const char * parent_function_name; +"__svml_logf16_mask", //const char * variant_function_name; +1665, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16_mask", //const char * parent_function_name; +"__svml_logf16_ha_mask", //const char * variant_function_name; +1666, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf16_mask", //const char * parent_function_name; +"__svml_logf16_br_mask", //const char * variant_function_name; +1667, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4", //const char * parent_function_name; +"__svml_logf4_ep", //const char * variant_function_name; +1668, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4", //const char * parent_function_name; +"__svml_logf4", //const char * variant_function_name; +1669, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4", //const char * parent_function_name; +"__svml_logf4_ha", //const char * variant_function_name; +1670, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4", //const char * parent_function_name; +"__svml_logf4_br", //const char * variant_function_name; +1671, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4_mask", //const char * parent_function_name; +"__svml_logf4_ep_mask", //const char * variant_function_name; +1672, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4_mask", //const char * parent_function_name; +"__svml_logf4_mask", //const char * variant_function_name; +1673, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4_mask", //const char * parent_function_name; +"__svml_logf4_ha_mask", //const char * variant_function_name; +1674, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf4_mask", //const char * parent_function_name; +"__svml_logf4_br_mask", //const char * variant_function_name; +1675, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8", //const char * parent_function_name; +"__svml_logf8_ep", //const char * variant_function_name; +1676, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8", //const char * parent_function_name; +"__svml_logf8", //const char * variant_function_name; +1677, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8", //const char * parent_function_name; +"__svml_logf8_ha", //const char * variant_function_name; +1678, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8", //const char * parent_function_name; +"__svml_logf8_br", //const char * variant_function_name; +1679, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8_mask", //const char * parent_function_name; +"__svml_logf8_ep_mask", //const char * variant_function_name; +1680, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8_mask", //const char * parent_function_name; +"__svml_logf8_mask", //const char * variant_function_name; +1681, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8_mask", //const char * parent_function_name; +"__svml_logf8_ha_mask", //const char * variant_function_name; +1682, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_logf8_mask", //const char * parent_function_name; +"__svml_logf8_br_mask", //const char * variant_function_name; +1683, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint2", //const char * parent_function_name; +"__svml_nearbyint2", //const char * variant_function_name; +1684, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint2_mask", //const char * parent_function_name; +"__svml_nearbyint2_mask", //const char * variant_function_name; +1685, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint4", //const char * parent_function_name; +"__svml_nearbyint4", //const char * variant_function_name; +1686, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint4_mask", //const char * parent_function_name; +"__svml_nearbyint4_mask", //const char * variant_function_name; +1687, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint8", //const char * parent_function_name; +"__svml_nearbyint8", //const char * variant_function_name; +1688, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyint8_mask", //const char * parent_function_name; +"__svml_nearbyint8_mask", //const char * variant_function_name; +1689, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf16", //const char * parent_function_name; +"__svml_nearbyintf16", //const char * variant_function_name; +1690, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf16_mask", //const char * parent_function_name; +"__svml_nearbyintf16_mask", //const char * variant_function_name; +1691, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf4", //const char * parent_function_name; +"__svml_nearbyintf4", //const char * variant_function_name; +1692, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf4_mask", //const char * parent_function_name; +"__svml_nearbyintf4_mask", //const char * variant_function_name; +1693, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf8", //const char * parent_function_name; +"__svml_nearbyintf8", //const char * variant_function_name; +1694, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_nearbyintf8_mask", //const char * parent_function_name; +"__svml_nearbyintf8_mask", //const char * variant_function_name; +1695, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2", //const char * parent_function_name; +"__svml_pow2_ep", //const char * variant_function_name; +1696, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2", //const char * parent_function_name; +"__svml_pow2", //const char * variant_function_name; +1697, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2", //const char * parent_function_name; +"__svml_pow2_ha", //const char * variant_function_name; +1698, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2_mask", //const char * parent_function_name; +"__svml_pow2_ep_mask", //const char * variant_function_name; +1699, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2_mask", //const char * parent_function_name; +"__svml_pow2_mask", //const char * variant_function_name; +1700, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow2_mask", //const char * parent_function_name; +"__svml_pow2_ha_mask", //const char * variant_function_name; +1701, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4", //const char * parent_function_name; +"__svml_pow4_ep", //const char * variant_function_name; +1702, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4", //const char * parent_function_name; +"__svml_pow4", //const char * variant_function_name; +1703, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4", //const char * parent_function_name; +"__svml_pow4_ha", //const char * variant_function_name; +1704, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4", //const char * parent_function_name; +"__svml_pow4_br", //const char * variant_function_name; +1705, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4_mask", //const char * parent_function_name; +"__svml_pow4_ep_mask", //const char * variant_function_name; +1706, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4_mask", //const char * parent_function_name; +"__svml_pow4_mask", //const char * variant_function_name; +1707, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4_mask", //const char * parent_function_name; +"__svml_pow4_ha_mask", //const char * variant_function_name; +1708, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow4_mask", //const char * parent_function_name; +"__svml_pow4_br_mask", //const char * variant_function_name; +1709, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8", //const char * parent_function_name; +"__svml_pow8_ep", //const char * variant_function_name; +1710, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8", //const char * parent_function_name; +"__svml_pow8", //const char * variant_function_name; +1711, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8", //const char * parent_function_name; +"__svml_pow8_ha", //const char * variant_function_name; +1712, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8_mask", //const char * parent_function_name; +"__svml_pow8_ep_mask", //const char * variant_function_name; +1713, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8_mask", //const char * parent_function_name; +"__svml_pow8_mask", //const char * variant_function_name; +1714, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pow8_mask", //const char * parent_function_name; +"__svml_pow8_ha_mask", //const char * variant_function_name; +1715, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16", //const char * parent_function_name; +"__svml_powf16_ep", //const char * variant_function_name; +1716, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16", //const char * parent_function_name; +"__svml_powf16", //const char * variant_function_name; +1717, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16", //const char * parent_function_name; +"__svml_powf16_ha", //const char * variant_function_name; +1718, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16_mask", //const char * parent_function_name; +"__svml_powf16_ep_mask", //const char * variant_function_name; +1719, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16_mask", //const char * parent_function_name; +"__svml_powf16_mask", //const char * variant_function_name; +1720, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf16_mask", //const char * parent_function_name; +"__svml_powf16_ha_mask", //const char * variant_function_name; +1721, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4", //const char * parent_function_name; +"__svml_powf4_ep", //const char * variant_function_name; +1722, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4", //const char * parent_function_name; +"__svml_powf4", //const char * variant_function_name; +1723, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4", //const char * parent_function_name; +"__svml_powf4_ha", //const char * variant_function_name; +1724, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4_mask", //const char * parent_function_name; +"__svml_powf4_ep_mask", //const char * variant_function_name; +1725, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4_mask", //const char * parent_function_name; +"__svml_powf4_mask", //const char * variant_function_name; +1726, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf4_mask", //const char * parent_function_name; +"__svml_powf4_ha_mask", //const char * variant_function_name; +1727, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8", //const char * parent_function_name; +"__svml_powf8_ep", //const char * variant_function_name; +1728, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8", //const char * parent_function_name; +"__svml_powf8", //const char * variant_function_name; +1729, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8", //const char * parent_function_name; +"__svml_powf8_ha", //const char * variant_function_name; +1730, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8", //const char * parent_function_name; +"__svml_powf8_br", //const char * variant_function_name; +1731, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8_mask", //const char * parent_function_name; +"__svml_powf8_ep_mask", //const char * variant_function_name; +1732, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8_mask", //const char * parent_function_name; +"__svml_powf8_mask", //const char * variant_function_name; +1733, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8_mask", //const char * parent_function_name; +"__svml_powf8_ha_mask", //const char * variant_function_name; +1734, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_powf8_mask", //const char * parent_function_name; +"__svml_powf8_br_mask", //const char * variant_function_name; +1735, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8", //const char * parent_function_name; +"__svml_pown8_ep", //const char * variant_function_name; +1736, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8", //const char * parent_function_name; +"__svml_pown8", //const char * variant_function_name; +1737, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8", //const char * parent_function_name; +"__svml_pown8_ha", //const char * variant_function_name; +1738, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8_mask", //const char * parent_function_name; +"__svml_pown8_ep_mask", //const char * variant_function_name; +1739, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8_mask", //const char * parent_function_name; +"__svml_pown8_mask", //const char * variant_function_name; +1740, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pown8_mask", //const char * parent_function_name; +"__svml_pown8_ha_mask", //const char * variant_function_name; +1741, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16", //const char * parent_function_name; +"__svml_pownf16_ep", //const char * variant_function_name; +1742, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16", //const char * parent_function_name; +"__svml_pownf16", //const char * variant_function_name; +1743, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16", //const char * parent_function_name; +"__svml_pownf16_ha", //const char * variant_function_name; +1744, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16_mask", //const char * parent_function_name; +"__svml_pownf16_ep_mask", //const char * variant_function_name; +1745, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16_mask", //const char * parent_function_name; +"__svml_pownf16_mask", //const char * variant_function_name; +1746, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_pownf16_mask", //const char * parent_function_name; +"__svml_pownf16_ha_mask", //const char * variant_function_name; +1747, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint2", //const char * parent_function_name; +"__svml_rint2", //const char * variant_function_name; +1748, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint2_mask", //const char * parent_function_name; +"__svml_rint2_mask", //const char * variant_function_name; +1749, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint4", //const char * parent_function_name; +"__svml_rint4", //const char * variant_function_name; +1750, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint4_mask", //const char * parent_function_name; +"__svml_rint4_mask", //const char * variant_function_name; +1751, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint8", //const char * parent_function_name; +"__svml_rint8", //const char * variant_function_name; +1752, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rint8_mask", //const char * parent_function_name; +"__svml_rint8_mask", //const char * variant_function_name; +1753, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf16", //const char * parent_function_name; +"__svml_rintf16", //const char * variant_function_name; +1754, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf16_mask", //const char * parent_function_name; +"__svml_rintf16_mask", //const char * variant_function_name; +1755, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf4", //const char * parent_function_name; +"__svml_rintf4", //const char * variant_function_name; +1756, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf4_mask", //const char * parent_function_name; +"__svml_rintf4_mask", //const char * variant_function_name; +1757, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf8", //const char * parent_function_name; +"__svml_rintf8", //const char * variant_function_name; +1758, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_rintf8_mask", //const char * parent_function_name; +"__svml_rintf8_mask", //const char * variant_function_name; +1759, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round2", //const char * parent_function_name; +"__svml_round2", //const char * variant_function_name; +1760, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round2_mask", //const char * parent_function_name; +"__svml_round2_mask", //const char * variant_function_name; +1761, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round4", //const char * parent_function_name; +"__svml_round4", //const char * variant_function_name; +1762, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round4_mask", //const char * parent_function_name; +"__svml_round4_mask", //const char * variant_function_name; +1763, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round8", //const char * parent_function_name; +"__svml_round8", //const char * variant_function_name; +1764, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_round8_mask", //const char * parent_function_name; +"__svml_round8_mask", //const char * variant_function_name; +1765, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf16", //const char * parent_function_name; +"__svml_roundf16", //const char * variant_function_name; +1766, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf16_mask", //const char * parent_function_name; +"__svml_roundf16_mask", //const char * variant_function_name; +1767, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf4", //const char * parent_function_name; +"__svml_roundf4", //const char * variant_function_name; +1768, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf4_mask", //const char * parent_function_name; +"__svml_roundf4_mask", //const char * variant_function_name; +1769, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf8", //const char * parent_function_name; +"__svml_roundf8", //const char * variant_function_name; +1770, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_roundf8_mask", //const char * parent_function_name; +"__svml_roundf8_mask", //const char * variant_function_name; +1771, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2", //const char * parent_function_name; +"__svml_sin2_ep", //const char * variant_function_name; +1772, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2", //const char * parent_function_name; +"__svml_sin2", //const char * variant_function_name; +1773, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2", //const char * parent_function_name; +"__svml_sin2_ha", //const char * variant_function_name; +1774, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2_mask", //const char * parent_function_name; +"__svml_sin2_ep_mask", //const char * variant_function_name; +1775, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2_mask", //const char * parent_function_name; +"__svml_sin2_mask", //const char * variant_function_name; +1776, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin2_mask", //const char * parent_function_name; +"__svml_sin2_ha_mask", //const char * variant_function_name; +1777, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4", //const char * parent_function_name; +"__svml_sin4_ep", //const char * variant_function_name; +1778, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4", //const char * parent_function_name; +"__svml_sin4", //const char * variant_function_name; +1779, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4", //const char * parent_function_name; +"__svml_sin4_ha", //const char * variant_function_name; +1780, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4", //const char * parent_function_name; +"__svml_sin4_br", //const char * variant_function_name; +1781, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4_mask", //const char * parent_function_name; +"__svml_sin4_ep_mask", //const char * variant_function_name; +1782, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4_mask", //const char * parent_function_name; +"__svml_sin4_mask", //const char * variant_function_name; +1783, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4_mask", //const char * parent_function_name; +"__svml_sin4_ha_mask", //const char * variant_function_name; +1784, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin4_mask", //const char * parent_function_name; +"__svml_sin4_br_mask", //const char * variant_function_name; +1785, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8", //const char * parent_function_name; +"__svml_sin8_ep", //const char * variant_function_name; +1786, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8", //const char * parent_function_name; +"__svml_sin8", //const char * variant_function_name; +1787, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8", //const char * parent_function_name; +"__svml_sin8_ha", //const char * variant_function_name; +1788, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8_mask", //const char * parent_function_name; +"__svml_sin8_ep_mask", //const char * variant_function_name; +1789, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8_mask", //const char * parent_function_name; +"__svml_sin8_mask", //const char * variant_function_name; +1790, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sin8_mask", //const char * parent_function_name; +"__svml_sin8_ha_mask", //const char * variant_function_name; +1791, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2", //const char * parent_function_name; +"__svml_sincos2_ep", //const char * variant_function_name; +1792, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2", //const char * parent_function_name; +"__svml_sincos2", //const char * variant_function_name; +1793, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2", //const char * parent_function_name; +"__svml_sincos2_ha", //const char * variant_function_name; +1794, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2_mask", //const char * parent_function_name; +"__svml_sincos2_ep_mask", //const char * variant_function_name; +1795, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2_mask", //const char * parent_function_name; +"__svml_sincos2_mask", //const char * variant_function_name; +1796, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos2_mask", //const char * parent_function_name; +"__svml_sincos2_ha_mask", //const char * variant_function_name; +1797, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4", //const char * parent_function_name; +"__svml_sincos4_ep", //const char * variant_function_name; +1798, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4", //const char * parent_function_name; +"__svml_sincos4", //const char * variant_function_name; +1799, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4", //const char * parent_function_name; +"__svml_sincos4_ha", //const char * variant_function_name; +1800, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4", //const char * parent_function_name; +"__svml_sincos4_br", //const char * variant_function_name; +1801, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4_mask", //const char * parent_function_name; +"__svml_sincos4_ep_mask", //const char * variant_function_name; +1802, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4_mask", //const char * parent_function_name; +"__svml_sincos4_mask", //const char * variant_function_name; +1803, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4_mask", //const char * parent_function_name; +"__svml_sincos4_ha_mask", //const char * variant_function_name; +1804, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos4_mask", //const char * parent_function_name; +"__svml_sincos4_br_mask", //const char * variant_function_name; +1805, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8", //const char * parent_function_name; +"__svml_sincos8_ep", //const char * variant_function_name; +1806, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8", //const char * parent_function_name; +"__svml_sincos8", //const char * variant_function_name; +1807, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8", //const char * parent_function_name; +"__svml_sincos8_ha", //const char * variant_function_name; +1808, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8_mask", //const char * parent_function_name; +"__svml_sincos8_ep_mask", //const char * variant_function_name; +1809, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8_mask", //const char * parent_function_name; +"__svml_sincos8_mask", //const char * variant_function_name; +1810, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincos8_mask", //const char * parent_function_name; +"__svml_sincos8_ha_mask", //const char * variant_function_name; +1811, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16", //const char * parent_function_name; +"__svml_sincosf16_ep", //const char * variant_function_name; +1812, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16", //const char * parent_function_name; +"__svml_sincosf16", //const char * variant_function_name; +1813, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16", //const char * parent_function_name; +"__svml_sincosf16_ha", //const char * variant_function_name; +1814, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16_mask", //const char * parent_function_name; +"__svml_sincosf16_ep_mask", //const char * variant_function_name; +1815, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16_mask", //const char * parent_function_name; +"__svml_sincosf16_mask", //const char * variant_function_name; +1816, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf16_mask", //const char * parent_function_name; +"__svml_sincosf16_ha_mask", //const char * variant_function_name; +1817, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4", //const char * parent_function_name; +"__svml_sincosf4_ep", //const char * variant_function_name; +1818, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4", //const char * parent_function_name; +"__svml_sincosf4", //const char * variant_function_name; +1819, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4", //const char * parent_function_name; +"__svml_sincosf4_ha", //const char * variant_function_name; +1820, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4_mask", //const char * parent_function_name; +"__svml_sincosf4_ep_mask", //const char * variant_function_name; +1821, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4_mask", //const char * parent_function_name; +"__svml_sincosf4_mask", //const char * variant_function_name; +1822, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf4_mask", //const char * parent_function_name; +"__svml_sincosf4_ha_mask", //const char * variant_function_name; +1823, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8", //const char * parent_function_name; +"__svml_sincosf8_ep", //const char * variant_function_name; +1824, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8", //const char * parent_function_name; +"__svml_sincosf8", //const char * variant_function_name; +1825, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8", //const char * parent_function_name; +"__svml_sincosf8_ha", //const char * variant_function_name; +1826, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8", //const char * parent_function_name; +"__svml_sincosf8_br", //const char * variant_function_name; +1827, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8_mask", //const char * parent_function_name; +"__svml_sincosf8_ep_mask", //const char * variant_function_name; +1828, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8_mask", //const char * parent_function_name; +"__svml_sincosf8_mask", //const char * variant_function_name; +1829, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8_mask", //const char * parent_function_name; +"__svml_sincosf8_ha_mask", //const char * variant_function_name; +1830, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sincosf8_mask", //const char * parent_function_name; +"__svml_sincosf8_br_mask", //const char * variant_function_name; +1831, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2", //const char * parent_function_name; +"__svml_sind2_ep", //const char * variant_function_name; +1832, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2", //const char * parent_function_name; +"__svml_sind2", //const char * variant_function_name; +1833, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2", //const char * parent_function_name; +"__svml_sind2_ha", //const char * variant_function_name; +1834, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2_mask", //const char * parent_function_name; +"__svml_sind2_ep_mask", //const char * variant_function_name; +1835, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2_mask", //const char * parent_function_name; +"__svml_sind2_mask", //const char * variant_function_name; +1836, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind2_mask", //const char * parent_function_name; +"__svml_sind2_ha_mask", //const char * variant_function_name; +1837, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4", //const char * parent_function_name; +"__svml_sind4_ep", //const char * variant_function_name; +1838, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4", //const char * parent_function_name; +"__svml_sind4", //const char * variant_function_name; +1839, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4", //const char * parent_function_name; +"__svml_sind4_ha", //const char * variant_function_name; +1840, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4", //const char * parent_function_name; +"__svml_sind4_br", //const char * variant_function_name; +1841, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4_mask", //const char * parent_function_name; +"__svml_sind4_ep_mask", //const char * variant_function_name; +1842, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4_mask", //const char * parent_function_name; +"__svml_sind4_mask", //const char * variant_function_name; +1843, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4_mask", //const char * parent_function_name; +"__svml_sind4_ha_mask", //const char * variant_function_name; +1844, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind4_mask", //const char * parent_function_name; +"__svml_sind4_br_mask", //const char * variant_function_name; +1845, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8", //const char * parent_function_name; +"__svml_sind8_ep", //const char * variant_function_name; +1846, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8", //const char * parent_function_name; +"__svml_sind8", //const char * variant_function_name; +1847, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8", //const char * parent_function_name; +"__svml_sind8_ha", //const char * variant_function_name; +1848, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8_mask", //const char * parent_function_name; +"__svml_sind8_ep_mask", //const char * variant_function_name; +1849, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8_mask", //const char * parent_function_name; +"__svml_sind8_mask", //const char * variant_function_name; +1850, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sind8_mask", //const char * parent_function_name; +"__svml_sind8_ha_mask", //const char * variant_function_name; +1851, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16", //const char * parent_function_name; +"__svml_sindf16_ep", //const char * variant_function_name; +1852, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16", //const char * parent_function_name; +"__svml_sindf16", //const char * variant_function_name; +1853, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16", //const char * parent_function_name; +"__svml_sindf16_ha", //const char * variant_function_name; +1854, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16_mask", //const char * parent_function_name; +"__svml_sindf16_ep_mask", //const char * variant_function_name; +1855, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16_mask", //const char * parent_function_name; +"__svml_sindf16_mask", //const char * variant_function_name; +1856, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf16_mask", //const char * parent_function_name; +"__svml_sindf16_ha_mask", //const char * variant_function_name; +1857, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4", //const char * parent_function_name; +"__svml_sindf4_ep", //const char * variant_function_name; +1858, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4", //const char * parent_function_name; +"__svml_sindf4", //const char * variant_function_name; +1859, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4", //const char * parent_function_name; +"__svml_sindf4_ha", //const char * variant_function_name; +1860, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4_mask", //const char * parent_function_name; +"__svml_sindf4_ep_mask", //const char * variant_function_name; +1861, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4_mask", //const char * parent_function_name; +"__svml_sindf4_mask", //const char * variant_function_name; +1862, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf4_mask", //const char * parent_function_name; +"__svml_sindf4_ha_mask", //const char * variant_function_name; +1863, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8", //const char * parent_function_name; +"__svml_sindf8_ep", //const char * variant_function_name; +1864, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8", //const char * parent_function_name; +"__svml_sindf8", //const char * variant_function_name; +1865, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8", //const char * parent_function_name; +"__svml_sindf8_ha", //const char * variant_function_name; +1866, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8", //const char * parent_function_name; +"__svml_sindf8_br", //const char * variant_function_name; +1867, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8_mask", //const char * parent_function_name; +"__svml_sindf8_ep_mask", //const char * variant_function_name; +1868, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8_mask", //const char * parent_function_name; +"__svml_sindf8_mask", //const char * variant_function_name; +1869, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8_mask", //const char * parent_function_name; +"__svml_sindf8_ha_mask", //const char * variant_function_name; +1870, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sindf8_mask", //const char * parent_function_name; +"__svml_sindf8_br_mask", //const char * variant_function_name; +1871, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16", //const char * parent_function_name; +"__svml_sinf16_ep", //const char * variant_function_name; +1872, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16", //const char * parent_function_name; +"__svml_sinf16", //const char * variant_function_name; +1873, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16", //const char * parent_function_name; +"__svml_sinf16_ha", //const char * variant_function_name; +1874, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16_mask", //const char * parent_function_name; +"__svml_sinf16_ep_mask", //const char * variant_function_name; +1875, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16_mask", //const char * parent_function_name; +"__svml_sinf16_mask", //const char * variant_function_name; +1876, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf16_mask", //const char * parent_function_name; +"__svml_sinf16_ha_mask", //const char * variant_function_name; +1877, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4", //const char * parent_function_name; +"__svml_sinf4_ep", //const char * variant_function_name; +1878, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4", //const char * parent_function_name; +"__svml_sinf4", //const char * variant_function_name; +1879, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4", //const char * parent_function_name; +"__svml_sinf4_ha", //const char * variant_function_name; +1880, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4_mask", //const char * parent_function_name; +"__svml_sinf4_ep_mask", //const char * variant_function_name; +1881, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4_mask", //const char * parent_function_name; +"__svml_sinf4_mask", //const char * variant_function_name; +1882, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf4_mask", //const char * parent_function_name; +"__svml_sinf4_ha_mask", //const char * variant_function_name; +1883, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8", //const char * parent_function_name; +"__svml_sinf8_ep", //const char * variant_function_name; +1884, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8", //const char * parent_function_name; +"__svml_sinf8", //const char * variant_function_name; +1885, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8", //const char * parent_function_name; +"__svml_sinf8_ha", //const char * variant_function_name; +1886, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8", //const char * parent_function_name; +"__svml_sinf8_br", //const char * variant_function_name; +1887, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8_mask", //const char * parent_function_name; +"__svml_sinf8_ep_mask", //const char * variant_function_name; +1888, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8_mask", //const char * parent_function_name; +"__svml_sinf8_mask", //const char * variant_function_name; +1889, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8_mask", //const char * parent_function_name; +"__svml_sinf8_ha_mask", //const char * variant_function_name; +1890, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinf8_mask", //const char * parent_function_name; +"__svml_sinf8_br_mask", //const char * variant_function_name; +1891, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2", //const char * parent_function_name; +"__svml_sinh2_ep", //const char * variant_function_name; +1892, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2", //const char * parent_function_name; +"__svml_sinh2", //const char * variant_function_name; +1893, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2", //const char * parent_function_name; +"__svml_sinh2_ha", //const char * variant_function_name; +1894, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2_mask", //const char * parent_function_name; +"__svml_sinh2_ep_mask", //const char * variant_function_name; +1895, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2_mask", //const char * parent_function_name; +"__svml_sinh2_mask", //const char * variant_function_name; +1896, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh2_mask", //const char * parent_function_name; +"__svml_sinh2_ha_mask", //const char * variant_function_name; +1897, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4", //const char * parent_function_name; +"__svml_sinh4_ep", //const char * variant_function_name; +1898, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4", //const char * parent_function_name; +"__svml_sinh4", //const char * variant_function_name; +1899, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4", //const char * parent_function_name; +"__svml_sinh4_ha", //const char * variant_function_name; +1900, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4", //const char * parent_function_name; +"__svml_sinh4_br", //const char * variant_function_name; +1901, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4_mask", //const char * parent_function_name; +"__svml_sinh4_ep_mask", //const char * variant_function_name; +1902, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4_mask", //const char * parent_function_name; +"__svml_sinh4_mask", //const char * variant_function_name; +1903, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4_mask", //const char * parent_function_name; +"__svml_sinh4_ha_mask", //const char * variant_function_name; +1904, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh4_mask", //const char * parent_function_name; +"__svml_sinh4_br_mask", //const char * variant_function_name; +1905, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8", //const char * parent_function_name; +"__svml_sinh8_ep", //const char * variant_function_name; +1906, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8", //const char * parent_function_name; +"__svml_sinh8", //const char * variant_function_name; +1907, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8", //const char * parent_function_name; +"__svml_sinh8_ha", //const char * variant_function_name; +1908, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8_mask", //const char * parent_function_name; +"__svml_sinh8_ep_mask", //const char * variant_function_name; +1909, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8_mask", //const char * parent_function_name; +"__svml_sinh8_mask", //const char * variant_function_name; +1910, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinh8_mask", //const char * parent_function_name; +"__svml_sinh8_ha_mask", //const char * variant_function_name; +1911, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16", //const char * parent_function_name; +"__svml_sinhf16_ep", //const char * variant_function_name; +1912, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16", //const char * parent_function_name; +"__svml_sinhf16", //const char * variant_function_name; +1913, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16", //const char * parent_function_name; +"__svml_sinhf16_ha", //const char * variant_function_name; +1914, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16_mask", //const char * parent_function_name; +"__svml_sinhf16_ep_mask", //const char * variant_function_name; +1915, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16_mask", //const char * parent_function_name; +"__svml_sinhf16_mask", //const char * variant_function_name; +1916, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf16_mask", //const char * parent_function_name; +"__svml_sinhf16_ha_mask", //const char * variant_function_name; +1917, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4", //const char * parent_function_name; +"__svml_sinhf4_ep", //const char * variant_function_name; +1918, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4", //const char * parent_function_name; +"__svml_sinhf4", //const char * variant_function_name; +1919, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4", //const char * parent_function_name; +"__svml_sinhf4_ha", //const char * variant_function_name; +1920, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4_mask", //const char * parent_function_name; +"__svml_sinhf4_ep_mask", //const char * variant_function_name; +1921, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4_mask", //const char * parent_function_name; +"__svml_sinhf4_mask", //const char * variant_function_name; +1922, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf4_mask", //const char * parent_function_name; +"__svml_sinhf4_ha_mask", //const char * variant_function_name; +1923, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8", //const char * parent_function_name; +"__svml_sinhf8_ep", //const char * variant_function_name; +1924, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8", //const char * parent_function_name; +"__svml_sinhf8", //const char * variant_function_name; +1925, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8", //const char * parent_function_name; +"__svml_sinhf8_ha", //const char * variant_function_name; +1926, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8", //const char * parent_function_name; +"__svml_sinhf8_br", //const char * variant_function_name; +1927, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8_mask", //const char * parent_function_name; +"__svml_sinhf8_ep_mask", //const char * variant_function_name; +1928, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8_mask", //const char * parent_function_name; +"__svml_sinhf8_mask", //const char * variant_function_name; +1929, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8_mask", //const char * parent_function_name; +"__svml_sinhf8_ha_mask", //const char * variant_function_name; +1930, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sinhf8_mask", //const char * parent_function_name; +"__svml_sinhf8_br_mask", //const char * variant_function_name; +1931, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2", //const char * parent_function_name; +"__svml_sqrt2_ep", //const char * variant_function_name; +1932, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2", //const char * parent_function_name; +"__svml_sqrt2", //const char * variant_function_name; +1933, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2", //const char * parent_function_name; +"__svml_sqrt2_ha", //const char * variant_function_name; +1934, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2", //const char * parent_function_name; +"__svml_sqrt2_br", //const char * variant_function_name; +1935, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2_mask", //const char * parent_function_name; +"__svml_sqrt2_ep_mask", //const char * variant_function_name; +1936, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2_mask", //const char * parent_function_name; +"__svml_sqrt2_mask", //const char * variant_function_name; +1937, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2_mask", //const char * parent_function_name; +"__svml_sqrt2_ha_mask", //const char * variant_function_name; +1938, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt2_mask", //const char * parent_function_name; +"__svml_sqrt2_br_mask", //const char * variant_function_name; +1939, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4", //const char * parent_function_name; +"__svml_sqrt4_ep", //const char * variant_function_name; +1940, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4", //const char * parent_function_name; +"__svml_sqrt4", //const char * variant_function_name; +1941, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4", //const char * parent_function_name; +"__svml_sqrt4_ha", //const char * variant_function_name; +1942, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4", //const char * parent_function_name; +"__svml_sqrt4_br", //const char * variant_function_name; +1943, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4_mask", //const char * parent_function_name; +"__svml_sqrt4_ep_mask", //const char * variant_function_name; +1944, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4_mask", //const char * parent_function_name; +"__svml_sqrt4_mask", //const char * variant_function_name; +1945, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4_mask", //const char * parent_function_name; +"__svml_sqrt4_ha_mask", //const char * variant_function_name; +1946, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt4_mask", //const char * parent_function_name; +"__svml_sqrt4_br_mask", //const char * variant_function_name; +1947, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8", //const char * parent_function_name; +"__svml_sqrt8_ep", //const char * variant_function_name; +1948, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8", //const char * parent_function_name; +"__svml_sqrt8", //const char * variant_function_name; +1949, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8", //const char * parent_function_name; +"__svml_sqrt8_ha", //const char * variant_function_name; +1950, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8", //const char * parent_function_name; +"__svml_sqrt8_br", //const char * variant_function_name; +1951, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8_mask", //const char * parent_function_name; +"__svml_sqrt8_ep_mask", //const char * variant_function_name; +1952, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8_mask", //const char * parent_function_name; +"__svml_sqrt8_mask", //const char * variant_function_name; +1953, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8_mask", //const char * parent_function_name; +"__svml_sqrt8_ha_mask", //const char * variant_function_name; +1954, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrt8_mask", //const char * parent_function_name; +"__svml_sqrt8_br_mask", //const char * variant_function_name; +1955, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16", //const char * parent_function_name; +"__svml_sqrtf16_ep", //const char * variant_function_name; +1956, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16", //const char * parent_function_name; +"__svml_sqrtf16", //const char * variant_function_name; +1957, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16", //const char * parent_function_name; +"__svml_sqrtf16_ha", //const char * variant_function_name; +1958, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16", //const char * parent_function_name; +"__svml_sqrtf16_br", //const char * variant_function_name; +1959, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16_mask", //const char * parent_function_name; +"__svml_sqrtf16_ep_mask", //const char * variant_function_name; +1960, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16_mask", //const char * parent_function_name; +"__svml_sqrtf16_mask", //const char * variant_function_name; +1961, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16_mask", //const char * parent_function_name; +"__svml_sqrtf16_ha_mask", //const char * variant_function_name; +1962, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf16_mask", //const char * parent_function_name; +"__svml_sqrtf16_br_mask", //const char * variant_function_name; +1963, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4", //const char * parent_function_name; +"__svml_sqrtf4_ep", //const char * variant_function_name; +1964, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4", //const char * parent_function_name; +"__svml_sqrtf4", //const char * variant_function_name; +1965, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4", //const char * parent_function_name; +"__svml_sqrtf4_ha", //const char * variant_function_name; +1966, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4", //const char * parent_function_name; +"__svml_sqrtf4_br", //const char * variant_function_name; +1967, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4_mask", //const char * parent_function_name; +"__svml_sqrtf4_ep_mask", //const char * variant_function_name; +1968, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4_mask", //const char * parent_function_name; +"__svml_sqrtf4_mask", //const char * variant_function_name; +1969, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4_mask", //const char * parent_function_name; +"__svml_sqrtf4_ha_mask", //const char * variant_function_name; +1970, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf4_mask", //const char * parent_function_name; +"__svml_sqrtf4_br_mask", //const char * variant_function_name; +1971, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8", //const char * parent_function_name; +"__svml_sqrtf8_ep", //const char * variant_function_name; +1972, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8", //const char * parent_function_name; +"__svml_sqrtf8", //const char * variant_function_name; +1973, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8", //const char * parent_function_name; +"__svml_sqrtf8_ha", //const char * variant_function_name; +1974, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8", //const char * parent_function_name; +"__svml_sqrtf8_br", //const char * variant_function_name; +1975, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8_mask", //const char * parent_function_name; +"__svml_sqrtf8_ep_mask", //const char * variant_function_name; +1976, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8_mask", //const char * parent_function_name; +"__svml_sqrtf8_mask", //const char * variant_function_name; +1977, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8_mask", //const char * parent_function_name; +"__svml_sqrtf8_ha_mask", //const char * variant_function_name; +1978, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_sqrtf8_mask", //const char * parent_function_name; +"__svml_sqrtf8_br_mask", //const char * variant_function_name; +1979, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2", //const char * parent_function_name; +"__svml_tan2_ep", //const char * variant_function_name; +1980, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2", //const char * parent_function_name; +"__svml_tan2", //const char * variant_function_name; +1981, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2", //const char * parent_function_name; +"__svml_tan2_ha", //const char * variant_function_name; +1982, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2", //const char * parent_function_name; +"__svml_tan2_br", //const char * variant_function_name; +1983, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2_mask", //const char * parent_function_name; +"__svml_tan2_ep_mask", //const char * variant_function_name; +1984, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2_mask", //const char * parent_function_name; +"__svml_tan2_mask", //const char * variant_function_name; +1985, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2_mask", //const char * parent_function_name; +"__svml_tan2_ha_mask", //const char * variant_function_name; +1986, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan2_mask", //const char * parent_function_name; +"__svml_tan2_br_mask", //const char * variant_function_name; +1987, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4", //const char * parent_function_name; +"__svml_tan4_ep", //const char * variant_function_name; +1988, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4", //const char * parent_function_name; +"__svml_tan4", //const char * variant_function_name; +1989, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4", //const char * parent_function_name; +"__svml_tan4_ha", //const char * variant_function_name; +1990, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4", //const char * parent_function_name; +"__svml_tan4_br", //const char * variant_function_name; +1991, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4_mask", //const char * parent_function_name; +"__svml_tan4_ep_mask", //const char * variant_function_name; +1992, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4_mask", //const char * parent_function_name; +"__svml_tan4_mask", //const char * variant_function_name; +1993, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4_mask", //const char * parent_function_name; +"__svml_tan4_ha_mask", //const char * variant_function_name; +1994, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan4_mask", //const char * parent_function_name; +"__svml_tan4_br_mask", //const char * variant_function_name; +1995, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8", //const char * parent_function_name; +"__svml_tan8_ep", //const char * variant_function_name; +1996, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8", //const char * parent_function_name; +"__svml_tan8", //const char * variant_function_name; +1997, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8", //const char * parent_function_name; +"__svml_tan8_ha", //const char * variant_function_name; +1998, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8", //const char * parent_function_name; +"__svml_tan8_br", //const char * variant_function_name; +1999, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8_mask", //const char * parent_function_name; +"__svml_tan8_ep_mask", //const char * variant_function_name; +2000, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8_mask", //const char * parent_function_name; +"__svml_tan8_mask", //const char * variant_function_name; +2001, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8_mask", //const char * parent_function_name; +"__svml_tan8_ha_mask", //const char * variant_function_name; +2002, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tan8_mask", //const char * parent_function_name; +"__svml_tan8_br_mask", //const char * variant_function_name; +2003, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2", //const char * parent_function_name; +"__svml_tand2_ep", //const char * variant_function_name; +2004, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2", //const char * parent_function_name; +"__svml_tand2", //const char * variant_function_name; +2005, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2", //const char * parent_function_name; +"__svml_tand2_ha", //const char * variant_function_name; +2006, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2", //const char * parent_function_name; +"__svml_tand2_br", //const char * variant_function_name; +2007, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2_mask", //const char * parent_function_name; +"__svml_tand2_ep_mask", //const char * variant_function_name; +2008, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2_mask", //const char * parent_function_name; +"__svml_tand2_mask", //const char * variant_function_name; +2009, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2_mask", //const char * parent_function_name; +"__svml_tand2_ha_mask", //const char * variant_function_name; +2010, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand2_mask", //const char * parent_function_name; +"__svml_tand2_br_mask", //const char * variant_function_name; +2011, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4", //const char * parent_function_name; +"__svml_tand4_ep", //const char * variant_function_name; +2012, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4", //const char * parent_function_name; +"__svml_tand4", //const char * variant_function_name; +2013, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4", //const char * parent_function_name; +"__svml_tand4_ha", //const char * variant_function_name; +2014, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4", //const char * parent_function_name; +"__svml_tand4_br", //const char * variant_function_name; +2015, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4_mask", //const char * parent_function_name; +"__svml_tand4_ep_mask", //const char * variant_function_name; +2016, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4_mask", //const char * parent_function_name; +"__svml_tand4_mask", //const char * variant_function_name; +2017, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4_mask", //const char * parent_function_name; +"__svml_tand4_ha_mask", //const char * variant_function_name; +2018, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand4_mask", //const char * parent_function_name; +"__svml_tand4_br_mask", //const char * variant_function_name; +2019, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8", //const char * parent_function_name; +"__svml_tand8_ep", //const char * variant_function_name; +2020, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8", //const char * parent_function_name; +"__svml_tand8", //const char * variant_function_name; +2021, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8", //const char * parent_function_name; +"__svml_tand8_ha", //const char * variant_function_name; +2022, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8", //const char * parent_function_name; +"__svml_tand8_br", //const char * variant_function_name; +2023, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8_mask", //const char * parent_function_name; +"__svml_tand8_ep_mask", //const char * variant_function_name; +2024, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8_mask", //const char * parent_function_name; +"__svml_tand8_mask", //const char * variant_function_name; +2025, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8_mask", //const char * parent_function_name; +"__svml_tand8_ha_mask", //const char * variant_function_name; +2026, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tand8_mask", //const char * parent_function_name; +"__svml_tand8_br_mask", //const char * variant_function_name; +2027, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16", //const char * parent_function_name; +"__svml_tandf16_ep", //const char * variant_function_name; +2028, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16", //const char * parent_function_name; +"__svml_tandf16", //const char * variant_function_name; +2029, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16", //const char * parent_function_name; +"__svml_tandf16_ha", //const char * variant_function_name; +2030, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16", //const char * parent_function_name; +"__svml_tandf16_br", //const char * variant_function_name; +2031, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16_mask", //const char * parent_function_name; +"__svml_tandf16_ep_mask", //const char * variant_function_name; +2032, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16_mask", //const char * parent_function_name; +"__svml_tandf16_mask", //const char * variant_function_name; +2033, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16_mask", //const char * parent_function_name; +"__svml_tandf16_ha_mask", //const char * variant_function_name; +2034, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf16_mask", //const char * parent_function_name; +"__svml_tandf16_br_mask", //const char * variant_function_name; +2035, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4", //const char * parent_function_name; +"__svml_tandf4_ep", //const char * variant_function_name; +2036, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4", //const char * parent_function_name; +"__svml_tandf4", //const char * variant_function_name; +2037, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4", //const char * parent_function_name; +"__svml_tandf4_ha", //const char * variant_function_name; +2038, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4", //const char * parent_function_name; +"__svml_tandf4_br", //const char * variant_function_name; +2039, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4_mask", //const char * parent_function_name; +"__svml_tandf4_ep_mask", //const char * variant_function_name; +2040, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4_mask", //const char * parent_function_name; +"__svml_tandf4_mask", //const char * variant_function_name; +2041, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4_mask", //const char * parent_function_name; +"__svml_tandf4_ha_mask", //const char * variant_function_name; +2042, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf4_mask", //const char * parent_function_name; +"__svml_tandf4_br_mask", //const char * variant_function_name; +2043, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8", //const char * parent_function_name; +"__svml_tandf8_ep", //const char * variant_function_name; +2044, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8", //const char * parent_function_name; +"__svml_tandf8", //const char * variant_function_name; +2045, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8", //const char * parent_function_name; +"__svml_tandf8_ha", //const char * variant_function_name; +2046, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8", //const char * parent_function_name; +"__svml_tandf8_br", //const char * variant_function_name; +2047, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8_mask", //const char * parent_function_name; +"__svml_tandf8_ep_mask", //const char * variant_function_name; +2048, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8_mask", //const char * parent_function_name; +"__svml_tandf8_mask", //const char * variant_function_name; +2049, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8_mask", //const char * parent_function_name; +"__svml_tandf8_ha_mask", //const char * variant_function_name; +2050, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tandf8_mask", //const char * parent_function_name; +"__svml_tandf8_br_mask", //const char * variant_function_name; +2051, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16", //const char * parent_function_name; +"__svml_tanf16_ep", //const char * variant_function_name; +2052, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16", //const char * parent_function_name; +"__svml_tanf16", //const char * variant_function_name; +2053, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16", //const char * parent_function_name; +"__svml_tanf16_ha", //const char * variant_function_name; +2054, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16", //const char * parent_function_name; +"__svml_tanf16_br", //const char * variant_function_name; +2055, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16_mask", //const char * parent_function_name; +"__svml_tanf16_ep_mask", //const char * variant_function_name; +2056, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16_mask", //const char * parent_function_name; +"__svml_tanf16_mask", //const char * variant_function_name; +2057, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16_mask", //const char * parent_function_name; +"__svml_tanf16_ha_mask", //const char * variant_function_name; +2058, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf16_mask", //const char * parent_function_name; +"__svml_tanf16_br_mask", //const char * variant_function_name; +2059, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4", //const char * parent_function_name; +"__svml_tanf4_ep", //const char * variant_function_name; +2060, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4", //const char * parent_function_name; +"__svml_tanf4", //const char * variant_function_name; +2061, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4", //const char * parent_function_name; +"__svml_tanf4_ha", //const char * variant_function_name; +2062, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4", //const char * parent_function_name; +"__svml_tanf4_br", //const char * variant_function_name; +2063, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4_mask", //const char * parent_function_name; +"__svml_tanf4_ep_mask", //const char * variant_function_name; +2064, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4_mask", //const char * parent_function_name; +"__svml_tanf4_mask", //const char * variant_function_name; +2065, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4_mask", //const char * parent_function_name; +"__svml_tanf4_ha_mask", //const char * variant_function_name; +2066, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf4_mask", //const char * parent_function_name; +"__svml_tanf4_br_mask", //const char * variant_function_name; +2067, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8", //const char * parent_function_name; +"__svml_tanf8_ep", //const char * variant_function_name; +2068, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8", //const char * parent_function_name; +"__svml_tanf8", //const char * variant_function_name; +2069, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8", //const char * parent_function_name; +"__svml_tanf8_ha", //const char * variant_function_name; +2070, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8", //const char * parent_function_name; +"__svml_tanf8_br", //const char * variant_function_name; +2071, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8_mask", //const char * parent_function_name; +"__svml_tanf8_ep_mask", //const char * variant_function_name; +2072, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8_mask", //const char * parent_function_name; +"__svml_tanf8_mask", //const char * variant_function_name; +2073, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8_mask", //const char * parent_function_name; +"__svml_tanf8_ha_mask", //const char * variant_function_name; +2074, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanf8_mask", //const char * parent_function_name; +"__svml_tanf8_br_mask", //const char * variant_function_name; +2075, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2", //const char * parent_function_name; +"__svml_tanh2_ep", //const char * variant_function_name; +2076, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2", //const char * parent_function_name; +"__svml_tanh2", //const char * variant_function_name; +2077, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2", //const char * parent_function_name; +"__svml_tanh2_ha", //const char * variant_function_name; +2078, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2_mask", //const char * parent_function_name; +"__svml_tanh2_ep_mask", //const char * variant_function_name; +2079, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2_mask", //const char * parent_function_name; +"__svml_tanh2_mask", //const char * variant_function_name; +2080, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh2_mask", //const char * parent_function_name; +"__svml_tanh2_ha_mask", //const char * variant_function_name; +2081, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4", //const char * parent_function_name; +"__svml_tanh4_ep", //const char * variant_function_name; +2082, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4", //const char * parent_function_name; +"__svml_tanh4", //const char * variant_function_name; +2083, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4", //const char * parent_function_name; +"__svml_tanh4_ha", //const char * variant_function_name; +2084, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4", //const char * parent_function_name; +"__svml_tanh4_br", //const char * variant_function_name; +2085, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4_mask", //const char * parent_function_name; +"__svml_tanh4_ep_mask", //const char * variant_function_name; +2086, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4_mask", //const char * parent_function_name; +"__svml_tanh4_mask", //const char * variant_function_name; +2087, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4_mask", //const char * parent_function_name; +"__svml_tanh4_ha_mask", //const char * variant_function_name; +2088, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh4_mask", //const char * parent_function_name; +"__svml_tanh4_br_mask", //const char * variant_function_name; +2089, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8", //const char * parent_function_name; +"__svml_tanh8_ep", //const char * variant_function_name; +2090, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8", //const char * parent_function_name; +"__svml_tanh8", //const char * variant_function_name; +2091, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8", //const char * parent_function_name; +"__svml_tanh8_ha", //const char * variant_function_name; +2092, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8_mask", //const char * parent_function_name; +"__svml_tanh8_ep_mask", //const char * variant_function_name; +2093, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +67108864, //float UlpError; +1e30f, //float AbsoluteError; +26, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8_mask", //const char * parent_function_name; +"__svml_tanh8_mask", //const char * variant_function_name; +2094, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +50, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanh8_mask", //const char * parent_function_name; +"__svml_tanh8_ha_mask", //const char * variant_function_name; +2095, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +52, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16", //const char * parent_function_name; +"__svml_tanhf16_ep", //const char * variant_function_name; +2096, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16", //const char * parent_function_name; +"__svml_tanhf16", //const char * variant_function_name; +2097, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16", //const char * parent_function_name; +"__svml_tanhf16_ha", //const char * variant_function_name; +2098, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16_mask", //const char * parent_function_name; +"__svml_tanhf16_ep_mask", //const char * variant_function_name; +2099, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16_mask", //const char * parent_function_name; +"__svml_tanhf16_mask", //const char * variant_function_name; +2100, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf16_mask", //const char * parent_function_name; +"__svml_tanhf16_ha_mask", //const char * variant_function_name; +2101, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4", //const char * parent_function_name; +"__svml_tanhf4_ep", //const char * variant_function_name; +2102, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4", //const char * parent_function_name; +"__svml_tanhf4", //const char * variant_function_name; +2103, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4", //const char * parent_function_name; +"__svml_tanhf4_ha", //const char * variant_function_name; +2104, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4_mask", //const char * parent_function_name; +"__svml_tanhf4_ep_mask", //const char * variant_function_name; +2105, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4_mask", //const char * parent_function_name; +"__svml_tanhf4_mask", //const char * variant_function_name; +2106, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf4_mask", //const char * parent_function_name; +"__svml_tanhf4_ha_mask", //const char * variant_function_name; +2107, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8", //const char * parent_function_name; +"__svml_tanhf8_ep", //const char * variant_function_name; +2108, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8", //const char * parent_function_name; +"__svml_tanhf8", //const char * variant_function_name; +2109, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8", //const char * parent_function_name; +"__svml_tanhf8_ha", //const char * variant_function_name; +2110, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8", //const char * parent_function_name; +"__svml_tanhf8_br", //const char * variant_function_name; +2111, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8_mask", //const char * parent_function_name; +"__svml_tanhf8_ep_mask", //const char * variant_function_name; +2112, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyEnhancedPerformance, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4096, //float UlpError; +1e30f, //float AbsoluteError; +11, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8_mask", //const char * parent_function_name; +"__svml_tanhf8_mask", //const char * variant_function_name; +2113, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyLow, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +4, //float UlpError; +1e30f, //float AbsoluteError; +21, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8_mask", //const char * parent_function_name; +"__svml_tanhf8_ha_mask", //const char * variant_function_name; +2114, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyHigh, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +0, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_tanhf8_mask", //const char * parent_function_name; +"__svml_tanhf8_br_mask", //const char * variant_function_name; +2115, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyBitwiseReproducible, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.6, //float UlpError; +1e30f, //float AbsoluteError; +23, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc2", //const char * parent_function_name; +"__svml_trunc2", //const char * variant_function_name; +2116, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc2_mask", //const char * parent_function_name; +"__svml_trunc2_mask", //const char * variant_function_name; +2117, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc4", //const char * parent_function_name; +"__svml_trunc4", //const char * variant_function_name; +2118, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc4_mask", //const char * parent_function_name; +"__svml_trunc4_mask", //const char * variant_function_name; +2119, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc8", //const char * parent_function_name; +"__svml_trunc8", //const char * variant_function_name; +2120, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_trunc8_mask", //const char * parent_function_name; +"__svml_trunc8_mask", //const char * variant_function_name; +2121, //int Index; +PE_PrecisionDouble, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf16", //const char * parent_function_name; +"__svml_truncf16", //const char * variant_function_name; +2122, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf16_mask", //const char * parent_function_name; +"__svml_truncf16_mask", //const char * variant_function_name; +2123, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf4", //const char * parent_function_name; +"__svml_truncf4", //const char * variant_function_name; +2124, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf4_mask", //const char * parent_function_name; +"__svml_truncf4_mask", //const char * variant_function_name; +2125, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf8", //const char * parent_function_name; +"__svml_truncf8", //const char * variant_function_name; +2126, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_truncf8_mask", //const char * parent_function_name; +"__svml_truncf8_mask", //const char * variant_function_name; +2127, //int Index; +PE_PrecisionSingle, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +24, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div16", //const char * parent_function_name; +"__svml_u16div16", //const char * variant_function_name; +2128, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div16_mask", //const char * parent_function_name; +"__svml_u16div16_mask", //const char * variant_function_name; +2129, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div32", //const char * parent_function_name; +"__svml_u16div32", //const char * variant_function_name; +2130, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div32_mask", //const char * parent_function_name; +"__svml_u16div32_mask", //const char * variant_function_name; +2131, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div8", //const char * parent_function_name; +"__svml_u16div8", //const char * variant_function_name; +2132, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16div8_mask", //const char * parent_function_name; +"__svml_u16div8_mask", //const char * variant_function_name; +2133, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem16", //const char * parent_function_name; +"__svml_u16rem16", //const char * variant_function_name; +2134, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem16_mask", //const char * parent_function_name; +"__svml_u16rem16_mask", //const char * variant_function_name; +2135, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem32", //const char * parent_function_name; +"__svml_u16rem32", //const char * variant_function_name; +2136, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem32_mask", //const char * parent_function_name; +"__svml_u16rem32_mask", //const char * variant_function_name; +2137, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem8", //const char * parent_function_name; +"__svml_u16rem8", //const char * variant_function_name; +2138, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u16rem8_mask", //const char * parent_function_name; +"__svml_u16rem8_mask", //const char * variant_function_name; +2139, //int Index; +PE_PrecisionUnsignedShort, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div2", //const char * parent_function_name; +"__svml_u64div2", //const char * variant_function_name; +2140, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div2_mask", //const char * parent_function_name; +"__svml_u64div2_mask", //const char * variant_function_name; +2141, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div4", //const char * parent_function_name; +"__svml_u64div4", //const char * variant_function_name; +2142, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div4_mask", //const char * parent_function_name; +"__svml_u64div4_mask", //const char * variant_function_name; +2143, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div8", //const char * parent_function_name; +"__svml_u64div8", //const char * variant_function_name; +2144, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64div8_mask", //const char * parent_function_name; +"__svml_u64div8_mask", //const char * variant_function_name; +2145, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem2", //const char * parent_function_name; +"__svml_u64rem2", //const char * variant_function_name; +2146, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem2_mask", //const char * parent_function_name; +"__svml_u64rem2_mask", //const char * variant_function_name; +2147, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem4", //const char * parent_function_name; +"__svml_u64rem4", //const char * variant_function_name; +2148, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem4_mask", //const char * parent_function_name; +"__svml_u64rem4_mask", //const char * variant_function_name; +2149, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem8", //const char * parent_function_name; +"__svml_u64rem8", //const char * variant_function_name; +2150, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u64rem8_mask", //const char * parent_function_name; +"__svml_u64rem8_mask", //const char * variant_function_name; +2151, //int Index; +PE_PrecisionUnsignedLongLong, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div16", //const char * parent_function_name; +"__svml_u8div16", //const char * variant_function_name; +2152, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div16_mask", //const char * parent_function_name; +"__svml_u8div16_mask", //const char * variant_function_name; +2153, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div32", //const char * parent_function_name; +"__svml_u8div32", //const char * variant_function_name; +2154, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div32_mask", //const char * parent_function_name; +"__svml_u8div32_mask", //const char * variant_function_name; +2155, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div64", //const char * parent_function_name; +"__svml_u8div64", //const char * variant_function_name; +2156, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8div64_mask", //const char * parent_function_name; +"__svml_u8div64_mask", //const char * variant_function_name; +2157, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem16", //const char * parent_function_name; +"__svml_u8rem16", //const char * variant_function_name; +2158, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem16_mask", //const char * parent_function_name; +"__svml_u8rem16_mask", //const char * variant_function_name; +2159, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem32", //const char * parent_function_name; +"__svml_u8rem32", //const char * variant_function_name; +2160, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem32_mask", //const char * parent_function_name; +"__svml_u8rem32_mask", //const char * variant_function_name; +2161, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem64", //const char * parent_function_name; +"__svml_u8rem64", //const char * variant_function_name; +2162, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_u8rem64_mask", //const char * parent_function_name; +"__svml_u8rem64_mask", //const char * variant_function_name; +2163, //int Index; +PE_PrecisionUnsignedChar, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv16", //const char * parent_function_name; +"__svml_udiv16", //const char * variant_function_name; +2164, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv16_mask", //const char * parent_function_name; +"__svml_udiv16_mask", //const char * variant_function_name; +2165, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv4", //const char * parent_function_name; +"__svml_udiv4", //const char * variant_function_name; +2166, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv4_mask", //const char * parent_function_name; +"__svml_udiv4_mask", //const char * variant_function_name; +2167, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv8", //const char * parent_function_name; +"__svml_udiv8", //const char * variant_function_name; +2168, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udiv8_mask", //const char * parent_function_name; +"__svml_udiv8_mask", //const char * variant_function_name; +2169, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem16", //const char * parent_function_name; +"__svml_udivrem16", //const char * variant_function_name; +2170, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem16_mask", //const char * parent_function_name; +"__svml_udivrem16_mask", //const char * variant_function_name; +2171, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem4", //const char * parent_function_name; +"__svml_udivrem4", //const char * variant_function_name; +2172, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem4_mask", //const char * parent_function_name; +"__svml_udivrem4_mask", //const char * variant_function_name; +2173, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem8", //const char * parent_function_name; +"__svml_udivrem8", //const char * variant_function_name; +2174, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_udivrem8_mask", //const char * parent_function_name; +"__svml_udivrem8_mask", //const char * variant_function_name; +2175, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem16", //const char * parent_function_name; +"__svml_urem16", //const char * variant_function_name; +2176, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem16_mask", //const char * parent_function_name; +"__svml_urem16_mask", //const char * variant_function_name; +2177, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem4", //const char * parent_function_name; +"__svml_urem4", //const char * variant_function_name; +2178, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem4_mask", //const char * parent_function_name; +"__svml_urem4_mask", //const char * variant_function_name; +2179, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem8", //const char * parent_function_name; +"__svml_urem8", //const char * variant_function_name; +2180, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, + +{ +"__svml_urem8_mask", //const char * parent_function_name; +"__svml_urem8_mask", //const char * variant_function_name; +2181, //int Index; +PE_PrecisionUnsignedInt, // PrecisionEnum Precision; +AE_AccuracyCorrectlyRounded, // AccuracyEnum Accuracy; +CE_ConfigurationAll, //ConfigurationsEnum Configuration; +0.5, //float UlpError; +1e30f, //float AbsoluteError; +53, //float AccurateBits; +0, //int DomainExclusion; +1, //int ArchConsistency; +0, //int ValidStatusBits; +}, +/* End of libiml_attr table */ Index: lib/Transforms/IntrinToMathLib/IntrinToMathLib.cpp =================================================================== --- lib/Transforms/IntrinToMathLib/IntrinToMathLib.cpp +++ lib/Transforms/IntrinToMathLib/IntrinToMathLib.cpp @@ -0,0 +1,1172 @@ +//==--- IntrinToMathLib.cpp - Replace intrinsics with math lib -*- C++ -*---==// +// calls. +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// This pass consumes llvm intrinsics and maps them to vector math library +/// calls or to alternative scalar math library calls. For vector calls, this +/// pass also performs type legalization when partial registers are used or +/// when the logical vector length exceeds the true vector length of the +/// target architecture. The type legalization adjusts vector lengths of the +/// math lib calls and those instructions that are users of them. The rest of +/// the legalization is left to CodeGen. If a suitable replacement is not +/// found for a vector intrinsic, this pass scalarizes the math lib calls. +// +// ===--------------------------------------------------------------------=== // + +#include "llvm/Transforms/IntrinToMathLib/IntrinToMathLib.h" +#include "llvm/Analysis/Passes.h" +#include "llvm/Analysis/TargetLibraryInfo.h" +#include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/InstIterator.h" +#include "llvm/IR/Instruction.h" +#include "llvm/IR/IntrinsicInst.h" +#include "llvm/InitializePasses.h" +#include "llvm/PassRegistry.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/ADT/Triple.h" +#include + +#define SV_NAME "intrin-to-mathlib" +#define DEBUG_TYPE "IntrinToMathLib" + +using namespace llvm; +using namespace llvm::vpo; + +static cl::opt RunIntrinToMathLibStressMode( + "intrin-to-mathlib-stress-mode", cl::init(false), cl::Hidden, + cl::desc("Scalarize vector intrinsic instead of calling vector math\ + library.")); + +IntrinToMathLib::IntrinToMathLib() : FunctionPass(ID) {} + +// The idea of this pass is simple and involves these steps: +// 1) Find vectorized math library related intrinsic calls, or scalar +// intrinsics. +// 2) Collect precision requirements in the form of call site attributes, +// which will be used to generate the correct math lib call. +// 3) Query the appropriate interface based on target to find the math lib +// call that will replace the intrinsic. +// 4) Perform type legalization for the math lib calls. +// 5) Generate the new math lib call instructions and update users of the +// old intrinsics. + +bool IntrinToMathLib::parseIntrinsicName(StringRef IntrinName, + StringRef &FuncName, + TargetLibraryInfo *TLI) { + // This function extracts the math function name from the intrinsic call. + // + // Example: + // + // llvm.sin.v4f32 + // + // FuncName = sin + // + // The caller then uses this information to query the IML interface. + + StringRef IntrinPrefix = "llvm."; + + size_t Idx = IntrinName.find(IntrinPrefix, 0); + + // Not an intrinsic call. By definition, all LLVM intrinsics start with + // "llvm.". + if (Idx == StringRef::npos) + return false; + + // Skip past the "llvm." prefix. + StringRef RemainFuncName = + IntrinName.substr(Idx + IntrinPrefix.size(), StringRef::npos); + + // We should find another '.' delimiter for math calls that serves as the + // separator for the type information. If not, return unsuccessfully, and + // find the next intrinsic call. + Idx = RemainFuncName.find(".", 0); + if (Idx == StringRef::npos) + return false; + + // Checking the LibFunc entries serves as an additional filter so that we + // do not process intrinsics such as "llvm.lifetime.start", etc. + LibFunc::Func LF; + FuncName = RemainFuncName.substr(0, Idx); + bool IsLibFunc = TLI->getLibFunc(FuncName, LF); + if (!IsLibFunc) + return false; + + return true; +} + +void IntrinToMathLib::addAttributeToList(ImfAttr **List, ImfAttr **Tail, + ImfAttr *Attr) { + if (*Tail) + (*Tail)->Next = Attr; + else + *List = Attr; + + *Tail = Attr; +} + +void IntrinToMathLib::deleteAttributeList(ImfAttr **List) { + ImfAttr *Attr = *List; + + while (Attr) { + ImfAttr *Next = Attr->Next; + delete Attr; + Attr = Next; + } +} + +// Unfortunately, this function exists because valid_attribute_names in +// iml_accuracy_interface.c is declared static. TODO: find out if this +// can be changed so that we can reference it directly to avoid having +// to maintain two pieces of code. +bool IntrinToMathLib::isValidIMFAttribute(std::string AttrName) { + if (AttrName == "absolute-error" || AttrName == "accuracy-bits" || + AttrName == "accuracy-bits-128" || AttrName == "accuracy-bits-32" || + AttrName == "accuracy-bits-64" || AttrName == "accuracy-bits-80" || + AttrName == "arch-consistency" || AttrName == "configuration" || + AttrName == "domain-exclusion" || AttrName == "max-error" || + AttrName == "precision" || AttrName == "valid-status-bits") + return true; + + return false; +} + +unsigned IntrinToMathLib::calculateNumReturns(TargetTransformInfo *TTI, + unsigned TypeBitWidth, + unsigned LogicalVL, + unsigned *TargetVL) { + unsigned VectorBitWidth = TTI->getRegisterBitWidth(true); + *TargetVL = VectorBitWidth / TypeBitWidth; + unsigned NumRet = LogicalVL / *TargetVL; + + // If the logical vector width is smaller than the target vector width, + // then we have less than full vector. Thus, just set NumRet = 1. + NumRet = NumRet == 0 ? 1 : NumRet; + + // If LogicalVL < TargetVL and LogicalVL is supported for TargetVL, then + // just adjust TargetVL = LogicalVL. E.g., LogicalVL = 4, and TargetVL = 8 + // for ymm target. Doing 8-way vectorization (assuming float/int) results + // in duplicating the lower half of the vector register elements into the + // upper half. Doing 4-way vectorization eliminates the extra shuffles and + // gives the user what they asked for if the LogicalVL was given by a loop + // pragma. Note: the low element duplication is needed for when the VL + // specified is less than a full xmm register width, so no adjustment is + // done. + if (LogicalVL < *TargetVL && VectorBitWidth != 128) { + *TargetVL = LogicalVL; + } + + DEBUG(dbgs() << "Type Bit Width: " << TypeBitWidth << "\n"); + DEBUG(dbgs() << "Legalizing VL: " << LogicalVL << "\n"); + DEBUG(dbgs() << "Vector Bit Width: " << VectorBitWidth << "\n"); + DEBUG(dbgs() << "Legal Target VL: " << *TargetVL << "\n"); + DEBUG(dbgs() << "Num Regs: " << NumRet << "\n"); + + return NumRet; +} + +void IntrinToMathLib::splitArgs( + SmallVectorImpl &Args, + SmallVectorImpl> &NewArgs, unsigned NumRet, + unsigned TargetVL) { + DEBUG(dbgs() << "Splitting Args to match legal VL:\n"); + NewArgs.resize(NumRet); + + for (unsigned I = 0; I < Args.size(); I++) { + + DEBUG(dbgs() << "Arg: " << *Args[I] << "\n"); + + for (unsigned J = 0; J < NumRet; J++) { + + // Use shuffle instructions to split the parameters into pseudo-registers + // of size TargetVL. For example, if the logical VL = 8, and TargetVL = 4, + // then the vector parameter will be split into two registers, where the + // shuffle masks correspond to the following: + // + // Shuffle Mask 1: + // <4 x i32> + // + // Shuffle Mask 2: + // <4 x i32> + // + // The resulting registers will hold the elements corresponding to the + // masks. + // + + SmallVector Splat; + unsigned StartElemIdx = J * TargetVL; + unsigned ElemIdx = StartElemIdx; + + for (unsigned K = 0; K < TargetVL; K++) { + Constant *ConstVal = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), ElemIdx); + Splat.push_back(ConstVal); + ++ElemIdx; + } + + Value *Undef = UndefValue::get(Args[I]->getType()); + Value *Mask = ConstantVector::get(Splat); + + ShuffleVectorInst *ShuffleInst = + new ShuffleVectorInst(Args[I], Undef, Mask, "shuffle"); + + NewArgs[J].push_back(ShuffleInst); + } + } +} + +void IntrinToMathLib::createImfAttributeList(IntrinsicInst *II, + ImfAttr **List) { + // Tail of the linked list of IMF attributes. The head of the list is + // passed in from the caller via the List parameter. + ImfAttr *Tail = nullptr; + + // Build the linked list of IMF attributes that will be used to query + // the IML interface. + + const StringRef ImfPrefix = "imf-"; + const AttributeSet Attrs = II->getAttributes(); + + if (Attrs.hasAttributes(AttributeSet::FunctionIndex)) { + AttributeSet::iterator FAIt = Attrs.begin(AttributeSet::FunctionIndex); + AttributeSet::iterator FAEnd = Attrs.end(AttributeSet::FunctionIndex); + for (; FAIt != FAEnd; ++FAIt) { + // Attributes will be of the form: + // + // "imf-max-error"="0.6" + // + std::string AttrStr = FAIt->getAsString(); + size_t EqualIdx = AttrStr.find("="); + if (EqualIdx == std::string::npos) + continue; + + // Ignore leading and trailing quotes, and '=' + std::string AttrName = AttrStr.substr(1, EqualIdx - 2); + size_t QuoteIdx = AttrStr.rfind('"'); + if (QuoteIdx == std::string::npos) + continue; + + std::string AttrValue = + AttrStr.substr(EqualIdx + 2, QuoteIdx - (EqualIdx + 2)); + + // Make sure this is an IMF attribute by looking for the prefix of + // "imf-". + if (AttrName.find(ImfPrefix) != 0) + continue; + AttrName = AttrName.substr(ImfPrefix.size(), std::string::npos); + + if (isValidIMFAttribute(AttrName)) { + ImfAttr *Attribute = new ImfAttr(); + char *Name = new char[AttrName.length() + 1]; + std::strcpy(Name, AttrName.c_str()); + char *Value = new char[AttrValue.length() + 1]; + std::strcpy(Value, AttrValue.c_str()); + Attribute->Name = Name; + Attribute->Value = Value; + Attribute->Next = nullptr; + addAttributeToList(List, &Tail, Attribute); + } + } + } + + // If no IMF attributes were found for the function call, then default to + // high accuracy. + if (!*List) { + ImfAttr *MaxError = new ImfAttr(); + MaxError->Name = "max-error"; + MaxError->Value = "0.6"; + ImfAttr *Precision = new ImfAttr(); + Precision->Name = "precision"; + Precision->Value = "high"; + MaxError->Next = Precision; + Precision->Next = nullptr; + addAttributeToList(List, &Tail, MaxError); + addAttributeToList(List, &Tail, Precision); + } + + // TODO: only debug mode + ImfAttr *CurrAttr = *List; + DEBUG(dbgs() << "Attribute List for function:\n"); + while (CurrAttr) { + DEBUG(dbgs() << CurrAttr->Name << " = " << CurrAttr->Value << "\n"); + CurrAttr = CurrAttr->Next; + } + // end debug +} + +void IntrinToMathLib::addAlwaysInlineAttribute(CallInst *CI) { + AttrBuilder AttrList; + AttrList.addAttribute(Attribute::AlwaysInline); + CI->setAttributes(CI->getAttributes().addAttributes( + CI->getContext(), AttributeSet::FunctionIndex, + AttributeSet::get(CI->getContext(), AttributeSet::FunctionIndex, + AttrList))); +} + +FunctionType * +IntrinToMathLib::legalizeFunctionTypes(FunctionType *FT, + SmallVectorImpl &Args, + unsigned TargetVL, LibFunc::Func &LF) { + // New type legalized argument types. + SmallVector NewArgTypes; + + // Perform type legalization for the function declaration. + for (unsigned I = 0; I < Args.size(); I++) { + Type *ParmType = Args[I]->getType(); + + // Adjust vector parameter types to a legal vector width. These will + // be used to build the math library function variant declaration. + VectorType *VecType = dyn_cast(ParmType); + if (VecType) { + ParmType = VectorType::get(VecType->getElementType(), TargetVL); + } + NewArgTypes.push_back(ParmType); + } + + Type *ReturnType = FT->getReturnType(); + VectorType *VectorReturn = dyn_cast(FT->getReturnType()); + + // Adjust original vector return type to the legal vector width. + // Insert the math library function declaration. + if (VectorReturn) { + unsigned TypeVL = isSinCosVariant(LF) ? TargetVL * 2 : TargetVL; + ReturnType = VectorType::get(VectorReturn->getElementType(), TypeVL); + } + + FunctionType *LegalFT = FunctionType::get(ReturnType, NewArgTypes, false); + return LegalFT; +} + +void IntrinToMathLib::generateMathLibCalls( + unsigned NumRet, Constant *Func, + SmallVectorImpl> &Args, + SmallVectorImpl &Calls, Instruction **InsertPt) { + + // Insert the new shuffle instructions that split the original vector + // parameter and generate the call to the math library function. + for (unsigned I = 0; I < NumRet; I++) { + for (unsigned J = 0; J < Args[I].size(); J++) { + Instruction *ArgInst = dyn_cast(Args[I][J]); + assert(ArgInst && "Expected arg to be associated with an instruction"); + ArgInst->insertAfter(*InsertPt); + *InsertPt = ArgInst; + } + Twine TempName = "vcall"; + CallInst *NewCI = CallInst::Create(Func, Args[I], TempName); + NewCI->insertAfter(*InsertPt); + Calls.push_back(NewCI); + *InsertPt = NewCI; + } +} + +Instruction * +IntrinToMathLib::combineCallResults(unsigned NumRet, + SmallVectorImpl &WorkList, + Instruction **InsertPt) { + // The initial number of elements for the first shuffle is NumElems. As we + // go, this number is adjusted up for the increasing size of vectors used in + // the shuffles. See notes in loop below. + VectorType *CallType = dyn_cast(WorkList[0]->getType()); + assert(CallType && "Expected result of call to be vector"); + ShuffleVectorInst *CombinedShuffle; + unsigned NumElems = CallType->getNumElements() * 2; + unsigned NumRegs = NumRet; + + // This code works by combining pairs of instructions that are the results of + // the math library calls. This is necessary for type legalization where + // NumRet > 1. For example, for logical VL=16, target VL=4: + // + // First, %1 (original intrinsic arg) is split via splitArgs() call above + // using shuffles. After the math library calls, the results are combined to + // form a vector of the logical vector length. + // + // %1 = %0 <16 x float> + // + // %shuffle.1 = shufflevector <16 x float> %1, <4 x i32> <0, 1, 2, 3> + // %call.1 = __svml_sinf4(%shuffle.1); + // + // %shuffle.2 = shufflevector <16 x float> %1, <4 x i32> <4, 5, 6, 7> + // %call.2 = __svml_sinf4(%shuffle.2); + // + // %shuffle.3 = shufflevector <16 x float> %1, <4 x i32> <8, 9, 10, 11> + // %call.3 = __svml_sinf4(%shuffle.3); + // + // %shuffle.4 = shufflevector <16 x float> %1, <4 x i32> <12, 13, 14, 15> + // %call.4 = __svml_sinf4(%shuffle.4); + // + // %comb.1 = shufflevector <4 x float> %call.1, <4 x float> %call.2, + // <8 x i32> <0, 1, 2, 3, 4, 5, 6, 7> + // + // %comb.2 = shufflevector <4 x float> %call.3, <4 x float> %call.4, + // <8 x i32> <0, 1, 2, 3, 4, 5, 6, 7> + // + // %final = shufflevector <8 x float> %comb.1, <8 x float> %comb.2, + // <16 x i32> <0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15> + // + // %final then replaces the users of the original intrinsic. The remainder of + // instructions are left to CodeGen to type legalize. + + while (NumRegs > 1) { + + for (unsigned I = 0; I < NumRegs; I += 2) { + // NumRet is a power of two and we must apply shuffles in pairs. Thus, we + // need to apply shuffles of increasing vector width. E.g., when + // NumRet = 4, LogicalVL = 16, we need to combine 2 <4 x type> vectors, + // and then combine 2 <8 x type> vectors. Create a mask the size of + // NumElems that will reflect an in order sequence of elements from the + // two input vectors, starting at 0. + + // Create the shuffle mask. + SmallVector Splat; + for (unsigned J = 0; J < NumElems; J++) { + Constant *ConstVal = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), J); + Splat.push_back(ConstVal); + } + Value *Mask = ConstantVector::get(Splat); + + // Combine the results of the svml calls. + CombinedShuffle = new ShuffleVectorInst(WorkList[I], WorkList[I + 1], + Mask, "shuffle.comb"); + CombinedShuffle->insertAfter(*InsertPt); + + // Add the new result vector to the WorkList. Subsequent iterations will + // combine them into a larger vector until we get to the logical vector + // length. + WorkList.push_back(CombinedShuffle); + + // Set the Instruction insertion point in the basic block. + *InsertPt = CombinedShuffle; + } + + // Remove the Instructions that have been combined from the + // WorkList. + SmallVector::iterator Start = WorkList.begin(); + SmallVector::iterator End = Start + NumRegs; + WorkList.erase(Start, End); + + // The next iteration will require a vector 2x the size of this one. + NumElems *= 2; + + // The number of result vectors to be combined will be reduced by + // half. + NumRegs /= 2; + } + + return CombinedShuffle; +} + +LoadStoreMode IntrinToMathLib::getLoadStoreModeForArg(AttributeSet &AS, + unsigned ArgNo, + StringRef &AttrValStr) { + assert(AS.hasAttribute(ArgNo, "stride") && + "Expected argument to have a specified stride"); + Attribute Attr = AS.getAttribute(ArgNo, "stride"); + AttrValStr = Attr.getValueAsString(); + + if (AttrValStr == "indirect") { + return LSM_Indirect; + } else if (AttrValStr == "1") { + return LSM_UnitStride; + } else { + // No strided load/store support right now, so revert to scalar mode. + // return LSM_NonUnitStride; + return LSM_Scalar; + } +} + +// TODO: For now, we assume LoadStoreMode is the same for each arg. +// This will need to change because it's possible that the memory +// reference pattern is different for each one. +void IntrinToMathLib::generateSinCosStore(IntrinsicInst *VectorIntrin, + Instruction *ResultVector, + unsigned NumElemsToStore, + unsigned TargetVL, + unsigned StorePtrIdx, + Instruction **InsertPt) { + // For __svml_sincos calls, the result vector is always 2x that of the input + // vector. + unsigned NumResultVectors = 2; + + AttributeSet AttrList = VectorIntrin->getAttributes(); + // For Arg 2, I = 0. Attributes are at position 2 + // For Arg 3, I = 1. Attributes are at position 3 + + for (unsigned I = 0; I < NumResultVectors; ++I) { + + // Name used to distinguish what is going into registers. + // Iteration 0 is sin + // Iteration 1 is cos + StringRef ResultName = I == 0 ? "sin" : "cos"; + + // This represents the address to where we will store the sin/cos results. + // Either arg 2 or 3 from the vector sincos call. + Value *SvmlArg = VectorIntrin->getArgOperand(I + 1); + + // Shuffle out the sin/cos results from the return vector of the svml call. + // This is necessary since we have a 2 x VL wide return vector. + SmallVector Splat; + unsigned StartElemIdx = I * TargetVL; + unsigned ElemIdx = StartElemIdx; + + Instruction *ShuffleInst = + extractElemsFromVector(ResultVector, ElemIdx, NumElemsToStore); + ShuffleInst->insertAfter(*InsertPt); + *InsertPt = ShuffleInst; + + VectorType *ShuffleType = dyn_cast(ShuffleInst->getType()); + unsigned NumElems = ShuffleType->getNumElements(); + + StringRef StrideValStr; + LoadStoreMode Mode = getLoadStoreModeForArg(AttrList, I + 2, StrideValStr); + + if (Mode == LSM_Scalar) { + // Store a single element at a time. + unsigned PtrIdx = StorePtrIdx; + for (unsigned Idx = 0; Idx < NumElems; ++Idx, ++PtrIdx) { + Constant *ElmIdx = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), Idx); + + Constant *ElmIdxPtr = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), PtrIdx); + + // Extract the sin/cos result from the vector register. + Twine ExtractName = ResultName + ".elem"; + ExtractElementInst *ElemToStore = + ExtractElementInst::Create(ShuffleInst, ElmIdx, ExtractName); + ElemToStore->insertAfter(*InsertPt); + *InsertPt = ElemToStore; + + // Extract the pointer from the vector of pointers argument from the + // intrinsic call. + Twine ExtractNamePtr = ResultName + ".elem.ptr"; + ExtractElementInst *ElemToStorePtr = + ExtractElementInst::Create(SvmlArg, ElmIdxPtr, ExtractNamePtr); + ElemToStorePtr->insertAfter(*InsertPt); + *InsertPt = ElemToStorePtr; + + // Store the sin/cos element to the pointer. + StoreInst *Store = new StoreInst(ElemToStore, ElemToStorePtr); + Store->insertAfter(*InsertPt); + *InsertPt = Store; + } + } else if (Mode == LSM_UnitStride) { + // Generate unit stride store. Here, we just need to extract the 1st + // address of the argument vector from the intrinsic because this will + // represent the base address for the vector store. If there are multiple + // returns, the index into the pointer of vectors on the intrinsic arg + // needs to advance by the number of elements being stored. E.g., + // + // call void @llvm.sincos.v8f32.p0v8f32.p0v8f32( + // <8 x float> %wide.load, + // <8 x float*> "stride"="1" %32, + // <8 x float*> "stride"="1" %48) + // + // where NumRet = 2 and VL = 4, so for the first call the based pointers + // are %32[0] and %48[0]. For the second call, the base pointers are + // %32[4] and %48[4]. These addresses are then used to store the results + // of the __svml_sincos calls. + Constant *Index = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), StorePtrIdx); + + ExtractElementInst *StorePtr = + ExtractElementInst::Create(SvmlArg, Index, ResultName + ".ptr"); + StorePtr->insertAfter(*InsertPt); + + // Cast the scalar pointer type to a vector one. The vector pointer is + // what is used for the store. + PointerType *PtrElemType = dyn_cast(StorePtr->getType()); + assert(PtrElemType && + "Expected element type of svml arg to be a pointer"); + *InsertPt = StorePtr; + + PointerType *VecPtrType = PointerType::get( + ShuffleInst->getType(), PtrElemType->getAddressSpace()); + BitCastInst *BitCast = + new BitCastInst(StorePtr, VecPtrType, ResultName + ".ptr.cast"); + BitCast->insertAfter(*InsertPt); + *InsertPt = BitCast; + + // Store the vector of sin/cos elements to the vector pointer. + StoreInst *Store = new StoreInst(ShuffleInst, BitCast); + Store->insertAfter(*InsertPt); + *InsertPt = Store; + } + } +} + +bool IntrinToMathLib::isLessThanFullVector(Type *ValType, Type *LegalType) { + + VectorType *ValVecType = dyn_cast(ValType); + VectorType *LegalVecType = dyn_cast(LegalType); + + if (ValVecType && LegalVecType && + ValVecType->getBitWidth() < LegalVecType->getBitWidth()) { + return true; + } + + return false; +} + +void IntrinToMathLib::generateNewArgsFromPartialVectors( + IntrinsicInst *II, FunctionType *FT, unsigned TargetVL, + SmallVectorImpl &NewArgs, Instruction **InsertPt) { + // This function builds a new argument list for the math library function + // call by finding any arguments that are less than full vector and + // duplicating the low order elements into the upper part of a new vector + // register. If the argument type is already legal, then just insert it as + // is in the arg list. + + for (unsigned I = 0; I < FT->getNumParams(); ++I) { + + // Type of the parameter of the intrinsic, which can be driven by the user + // specifying an explicit vector length. + Value *NewArg = II->getArgOperand(I); + VectorType *VecArgType = dyn_cast(NewArg->getType()); + + // The type of the parameter if using the full register specified through + // legalization. + VectorType *LegalVecArgType = dyn_cast(FT->getParamType(I)); + + unsigned NumElems = VecArgType->getNumElements(); + unsigned LegalNumElems = LegalVecArgType->getNumElements(); + + bool LessThanFullVector = isLessThanFullVector(VecArgType, LegalVecArgType); + + // Check to see if we have a partial register. + if (LessThanFullVector) { + + SmallVector Splat; + + // Build a mask vector that repeats the number of elements difference + // between the partial vector and the legal full vector. e.g., partial + // vl=2, legal vl=4, build a mask vector of <0, 1, 0, 1>. The math + // library call will operate on all 4 elements, but only the lower two + // will be used. + + for (unsigned J = 0; J < LegalNumElems / NumElems; ++J) { + for (unsigned K = 0; K < NumElems; ++K) { + Constant *ConstVal = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), K); + Splat.push_back(ConstVal); + } + } + + // Insert the shuffle that duplicates the elements and use this + // instruction as the new math library call argument. + Value *Undef = UndefValue::get(VecArgType); + Value *Mask = ConstantVector::get(Splat); + ShuffleVectorInst *ShuffleInst = new ShuffleVectorInst( + II->getArgOperand(I), Undef, Mask, "shuffle.dup"); + ShuffleInst->insertBefore(*InsertPt); + *InsertPt = ShuffleInst; + NewArg = ShuffleInst; + } + + NewArgs.push_back(NewArg); + } +} + +Instruction *IntrinToMathLib::extractElemsFromVector(Value *Reg, + unsigned StartPos, + unsigned NumElems) { + Type *RegType = Reg->getType(); + assert(RegType->isVectorTy() && "Expected vector register type for extract"); + + VectorType *VecRegType = dyn_cast(RegType); + + SmallVector Splat; + + for (unsigned I = StartPos; I < NumElems + StartPos; ++I) { + Constant *ConstVal = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), I); + Splat.push_back(ConstVal); + } + + Value *Undef = UndefValue::get(VecRegType); + Value *Mask = ConstantVector::get(Splat); + + ShuffleVectorInst *ShuffleResult = + new ShuffleVectorInst(Reg, Undef, Mask, "shuffle.part"); + return ShuffleResult; +} + +// Returns the return vector type in the function signature. NumRet is based +// on this type. Most math functions' argument types match the return type and +// these are the simple cases. However, this function should be flexible enough +// to deal with odd cases like the following (assume 128-bit target vector +// register width for explanatory purposes). +// +// Case 1) int ilogb(double) -> <4 x i32> ilogb(<4 x double>) +// - argument must be split into two <2 x double> vectors +// - return is reduced to <2 x i32> +// - this function should return <4 x double>, so that we know NumRet = 2 +// (i.e., generate two math library calls) +// - this is ok because the function should return only two i32 values in the +// lower half of the 128-bit register. +// +// TODO: support for Case 1 still needs to be added. Calls to ilogb (and any +// other functions with parameter/return types that will result in +// different vector type widths) will not be vectorized at the moment, so +// stability is not an issue. +// +// Case 2) double drand48() -> <4 x double> drand(void) +// - return must be split into two <2 x double> vectors +// - this function returns <4 x double>, so NumRet = 2 +// +// Case 3) void sincos(double, double*, double*) -> +// void sincos(<4 x double>, <4 x double*>, <4 x double*>) +// - return is void, so the largest argument is <4 x double> (keep in mind +// that double* is 32-bit or 64-bit depending on target pointer size). +// - all arguments are reduced to 2 elements +// - NumRet = 2 +// - this is ok because __svml_sincos expects two pointers for each sin/cos +// result. +// +// For cases 1 and 3, we unfortunately need special logic to determine the +// correct intrinsic type information. sincos is void, but the incoming vector +// intrinsic will be transformed to an svml call that returns a 2x wide vector +// based on the type of the 1st argument of the intrinsic signature. For ilogb +// type cases, the number of elements returned is the number of elements +// indicated by the 1st argument since it is 2x the size of the return. Case 2 +// will work as is. + +VectorType *IntrinToMathLib::getIntrinsicType(IntrinsicInst *Intrin) { + + Intrinsic::ID ID = Intrin->getIntrinsicID(); + + if (ID == Intrinsic::sincos) + return dyn_cast(Intrin->getArgOperand(0)->getType()); + + FunctionType *IntrinFT = Intrin->getFunctionType(); + Type *IntrinRetType = IntrinFT->getReturnType(); + return dyn_cast(IntrinRetType); +} + +void IntrinToMathLib::scalarizeVectorIntrinsic(IntrinsicInst *II, + StringRef LibFuncName, + unsigned VL, Type *ElemType) { + SmallVector FTArgTypes; + StringRef LibFuncVariantName; + + FunctionType *IntrinFT = II->getFunctionType(); + Type *RetType = IntrinFT->getReturnType(); + if (VectorType *VecRetType = dyn_cast(RetType)) { + RetType = VecRetType->getElementType(); + } + + for (auto *ParmType : IntrinFT->params()) { + if (VectorType *VecParmType = dyn_cast(ParmType)) { + Type *ElemType = VecParmType->getElementType(); + FTArgTypes.push_back(ElemType); + } else { + FTArgTypes.push_back(ParmType); + } + } + + if (ElemType->isFloatTy()) { + Twine LibFuncStr = LibFuncName + "f"; + LibFuncVariantName = LibFuncStr.str(); + } else if (ElemType->isDoubleTy()) { + LibFuncVariantName = LibFuncName; + } + + FunctionType *FT = FunctionType::get(RetType, FTArgTypes, false); + Constant *FCache = M->getOrInsertFunction(LibFuncVariantName, FT); + SmallVector CallResults; + + for (unsigned I = 0; I < VL; ++I) { + SmallVector ScalarCallArgs; + + for (unsigned J = 0; J < II->getNumArgOperands(); ++J) { + Value *Parm = II->getArgOperand(J); + VectorType *VecParmType = dyn_cast(Parm->getType()); + + if (VecParmType) { + Constant *Index = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), I); + + ExtractElementInst *Extract = + ExtractElementInst::Create(II->getOperand(J), Index, "arg", II); + + Parm = Extract; + } + + ScalarCallArgs.push_back(Parm); + } + + CallInst *ScalarCall = CallInst::Create(FCache, ScalarCallArgs); + ScalarCall->insertBefore(II); + CallResults.push_back(ScalarCall); + } + + if (!RetType->isVoidTy()) { + // If this is not a void intrinsic then there will be users of the call + // results. Insert each scalar call instruction (this corresponds to an + // SSA temp) into a vector and replace the original vector intrinsic call's + // users. + + Value *InsertVector = + UndefValue::get(II->getFunctionType()->getReturnType()); + + for (unsigned I = 0; I < CallResults.size(); ++I) { + Constant *Index = + ConstantInt::get(Type::getInt32Ty(Func->getContext()), I); + InsertVector = InsertElementInst::Create(InsertVector, CallResults[I], + Index, "ins", II); + } + + // Find the instructions that are using the intrinsic results and replace + // with the vector that has all of the scalar call results. + II->replaceAllUsesWith(InsertVector); + } +} + +bool IntrinToMathLib::isSinCosVariant(LibFunc::Func LF) { + if (LF == LibFunc::sincos || LF == LibFunc::sincosf) { + return true; + } + return false; +} + +const char* IntrinToMathLib::findX86Variant(IntrinsicInst *II, Type *ElemType, + StringRef FuncName, + unsigned TargetVL) { + + StringRef DataType; + std::string TargetVLString = std::to_string(TargetVL); + + // Translation for float versions of svml variants require an 'f' to be part + // of the name. e.g., sinf vs. sin for double. + if (ElemType->isFloatTy()) + DataType = "f"; + + // Construct the function name that will be used to look up the proper + // SVML variant (the parent function). + Twine TempFuncName = "__svml_" + FuncName + DataType + TargetVLString; + std::string TempFuncNameRef = TempFuncName.str(); + char *ParentFuncName = new char[TempFuncNameRef.length() + 1]; + std::strcpy(ParentFuncName, TempFuncNameRef.c_str()); + + DEBUG(dbgs() << "Parent Function: " << ParentFuncName << "\n"); + + ImfAttr *AttrList = nullptr; + createImfAttributeList(II, &AttrList); + + // External libiml_attr interface that returns the SVML/libm variant if the + // parent function and IMF attributes match. Return NULL otherwise. + const char *VariantFuncName = + getLibraryFunctionName(ParentFuncName, AttrList); + + // No longer need the IMF attribute list at this point, so free up the memory. + // Note: this does not remove the attributes from the instruction, only the + // internal data structure used to query the iml interface. + deleteAttributeList(&AttrList); + + return VariantFuncName; +} + +bool IntrinToMathLib::runOnFunction(Function &F) { + DEBUG(dbgs() << "\nExecuting IntrinToMathLib for function: " << F.getName() + << "\n\n"); + if (RunIntrinToMathLibStressMode) { + DEBUG(dbgs() << "Stress Testing Mode Invoked - vector intrinsic calls will\ + be scalarized\n"); + } + + Func = &F; + M = F.getParent(); + + // Use TTI to provide information on the legal vector register size for the + // target. + TargetTransformInfo *TTI = + &getAnalysis().getTTI(F); + + TargetLibraryInfo *TLI = + &getAnalysis().getTLI(); + + const DataLayout DL = M->getDataLayout(); + + Triple *T = new Triple(M->getTargetTriple()); + bool X86Target = (T->getArch() == Triple::x86 || + T->getArch() == Triple::x86_64); + + // Will be populated with the intrinsics that will be replaced with svml + // calls. + SmallVector InstToRemove; + + // Dirty becomes true (LLVM IR is modified) under two circumstances: + // 1) A candidate vector math intrinsic is found and is replaced with an + // svml/libm variant. + // 2) A candidate vector math intrinsic is found, is not replaced by an + // svml/libm variant, but is scalarized. + bool Dirty = false; // LLVM IR not yet modified + + // Begin searching for vector intrinsics that are candidates for translation + // to svml/libm. + for (inst_iterator Inst = inst_begin(F), InstEnd = inst_end(F); + Inst != InstEnd; ++Inst) { + + // Attempt to find an SVML/libm variant for all intrinsic calls and let + // libiml_attr worry about those functions that do not have any SVML/libm + // variants. It will simply return a NULL pointer if a variant is not found. + // This way we don't need to check any specific intrinsic IDs. If a vector + // math intrinsic is found but not replaced by an svml/libm variant, the + // intrinsic is scalarized. Dirty stays false if this check fails since + // a vector intrinsic is not found. + if (IntrinsicInst *II = dyn_cast(&*Inst)) { + + DEBUG(dbgs() << "Intrin: " << *II << "\n"); + + StringRef FuncName; + if (!parseIntrinsicName(II->getCalledFunction()->getName(), FuncName, + TLI)) + continue; + + unsigned ScalarBitWidth = 0; + LibFunc::Func LF; + TLI->getLibFunc(FuncName, LF); + + VectorType *VecIntrinType = getIntrinsicType(II); + + // Translation of scalar intrinsics to scalar math library functions is + // not yet supported. This check will be removed when libm support is + // added, and the code will be refactored so that there are separate code + // paths for vector and scalar transformations. As of now, the code below + // assumes svml translation for X86 targets only. However, this can be + // extended for non-x86 as needed. + if (!VecIntrinType) + continue; + + unsigned LogicalVL = VecIntrinType->getNumElements(); + Type *ElemType = VecIntrinType->getElementType(); + + // Need to go through DataLayout in cases where we have pointer types to + // get the correct pointer bit size. + ScalarBitWidth = DL.getTypeSizeInBits(ElemType); + + // Get the number of library calls that will be required, indicated by + // NumRet. NumRet is determined by getting the vector type info from the + // intrinsic signature. See notes in getIntrinsicType() for more + // information. + unsigned TargetVL = 0; + unsigned NumRet = + calculateNumReturns(TTI, ScalarBitWidth, LogicalVL, &TargetVL); + + const char *VariantFuncName = nullptr; + + if (X86Target) { + VariantFuncName = findX86Variant(II, ElemType, FuncName, TargetVL); + } + + // A math library function was found for the intrinsic, so replace the + // intrinsic with the math library call. Set Dirty to true since the LLVM + // IR is modified. Scalarize the call when: + // 1) an appropriate math library function is not found through querying + // the function selection interface. + // 2) the pass is running in stress testing mode. + if (VariantFuncName && !RunIntrinToMathLibStressMode) { + StringRef VariantFuncNameRef = StringRef(VariantFuncName); + DEBUG(dbgs() << "Function Variant: " << VariantFuncNameRef << "\n\n"); + + // Original arguments to the vector intrinsic. + SmallVector Args; + + FunctionType *FT; + + if (X86Target && isSinCosVariant(LF)) { + // We have to do some special handling for sincos calls on X86 + // because 'void sincos(, , )' + // must be transformed to: + // ' __svml_sincos()' + Args.push_back(II->getArgOperand(0)); + VectorType *RetType = + VectorType::getDoubleElementsVectorType(VecIntrinType); + FT = FunctionType::get(RetType, VecIntrinType, false); + } else { + unsigned NumArgs = II->getNumArgOperands(); + for (unsigned I = 0; I < NumArgs; I++) { + Value *Arg = II->getArgOperand(I); + Args.push_back(Arg); + } + FT = II->getFunctionType(); + } + + // FT will point to the legal FunctionType based on target register + // size requirements. This FunctionType is used to create the call + // to the svml function. + FT = legalizeFunctionTypes(FT, Args, TargetVL, LF); + Constant *FCache = M->getOrInsertFunction(VariantFuncNameRef, FT); + Instruction *InsertPt = II; + + // WorkList contains the instructions that are the results of math + // library calls. This could be the call instructions themselves, or + // the results of shuffles for cases like calls to sincos, or calls to + // functions that are less than full vector. + SmallVector WorkList; + + if (NumRet > 1) { + + // NumRet > 1 means that multiple library calls are required to + // support the vector length of the intrinsic. + + // NewArgs contains the type legalized parameters that are split in + // splitArgs(). These are the results of shuffle instructions. + SmallVector, 8> NewArgs; + splitArgs(Args, NewArgs, NumRet, TargetVL); + + generateMathLibCalls(NumRet, FCache, NewArgs, WorkList, &InsertPt); + + if (!isSinCosVariant(LF)) { + // There will be no users of sincos because it's a void function. + // Because of this, we have to generate the store instructions + // explicitly. See generateSinCosStore(). + Instruction *FinalResult = + combineCallResults(NumRet, WorkList, &InsertPt); + II->replaceAllUsesWith(FinalResult); + } + } else { + // NumRet = 1 + + // Type legalization still needs to happen for NumRet = 1 when + // dealing with less than full vector cases. + // generateNewArgsFromPartialVectors() duplicates the low elements + // into the upper part of the vector so the math library call operates + // on safe values. But, the duplicate results are not needed, so + // shuffle out the ones we want and then replace the users of the + // function call with the shuffle. This work is done via + // extractElemsFromVector(). + // + // Assuming target register width of 128-bit and user specifying + // explicit vl=2: + // + // Before Transformation: + // + // %7 = sitofp <2 x i32> %induction3.1 to <2 x float> + // %8 = call <2 x float> @llvm.cos.v2f32(<2 x float> %7) + // + // %9 = getelementptr inbounds [128 x float], [128 x float]* %array, + // i64 0, i64 %index.next + // + // %10 = bitcast float* %9 to <2 x float>* + // store <2 x float> %8, <2 x float>* %10, align 8 + // + // After Transformation: + // + // %1 = sitofp <2 x i32> %induction27 to <2 x float> + // + // duplicate low order elements via + // generateNewArgsFromPartialVectors() + // %dup = shufflevector <2 x float> %1, <2 x float> undef, + // <4 x i32> + // + // Example call here is to X86 svml. + // %vcall = call <4 x float> @__svml_cosf4_ha(<4 x float> %dup) + // + // shuffle out the results that are needed via + // extractElemsFromVector() + // %part = shufflevector <4 x float> %vcall, <4 x float> undef, + // <2 x i32> + // + // %2 = getelementptr inbounds float, float* %array, i64 %index + // %3 = bitcast float* %2 to <2 x float>* + // store <2 x float> %part, <2 x float>* %3, align 4 + + SmallVector NewArgs; + generateNewArgsFromPartialVectors(II, FT, TargetVL, NewArgs, + &InsertPt); + + CallInst *NewCI = CallInst::Create(FCache, NewArgs, "vcall"); + Instruction *CallResult = NewCI; + NewCI->insertAfter(InsertPt); + + if (!isSinCosVariant(LF)) { + bool LessThanFullVector = isLessThanFullVector( + II->getFunctionType()->getReturnType(), FT->getReturnType()); + + if (LessThanFullVector) { + // sincos requires a special extraction because it has a double + // wide return register. This is dealt with in + // generateSinCosStore(). + // + // Extract the number of elements specified by the partial vector + // return type of the intrinsic (indicated by LogicalVL). The + // NewCI return type will indicate the size of the vector + // extracted from. Start extracting from position 0. + CallResult = extractElemsFromVector(NewCI, 0, LogicalVL); + CallResult->insertAfter(NewCI); + } + + II->replaceAllUsesWith(CallResult); + } else { + WorkList.push_back(NewCI); + } + } + + if (X86Target && isSinCosVariant(LF)) { + unsigned StorePtrIdx = 0; + // For partial register cases, we only want to extract the partial + // number of elements from the results. Otherwise, extract the full + // legal register width number of elements. + unsigned NumElemsToStore = + LogicalVL < TargetVL ? LogicalVL : TargetVL; + for (unsigned I = 0; I < NumRet; ++I) { + InsertPt = WorkList[I]; + generateSinCosStore(II, WorkList[I], NumElemsToStore, TargetVL, + StorePtrIdx, &InsertPt); + StorePtrIdx += NumElemsToStore; + } + } + + InstToRemove.push_back(II); + Dirty = true; // LLVM-IR has been changed because we replaced the + // intrinsic with a corresponding library function. + } else { + // TODO: If for some reason the call translation failed, it is possible + // that the vector intrinsic left in the LLVM IR will not be recognized + // by the back-end, causing an assert. To prevent this, scalarize the + // vector intrinsic call. + // Also scalarize when running in stress test mode. Since the LLVM IR + // is modified, set Dirty to true. + + scalarizeVectorIntrinsic(II, TLI->getName(LF), LogicalVL, ElemType); + InstToRemove.push_back(II); + Dirty = true; // LLVM-IR has been changed because the vector intrinsic + // was replaced with scalar calls. + + DEBUG(dbgs() << "\n\n"); + } + } + } + + // Remove the old intrinsic calls since they have been replaced with the + // library calls or the intrinsic has been scalarized. + for (auto *Inst : InstToRemove) { + Inst->eraseFromParent(); + } + + return Dirty; // Has the LLVM IR been modified? +} + +FunctionPass *llvm::createIntrinToMathLibPass() { + return new llvm::vpo::IntrinToMathLib(); +} + +using namespace llvm::vpo; + +char IntrinToMathLib::ID = 0; + +static const char lv_name[] = "IntrinToMathLib"; +INITIALIZE_PASS_BEGIN(IntrinToMathLib, SV_NAME, lv_name, + false /* modifies CFG */, false /* transform pass */) +INITIALIZE_PASS_END(IntrinToMathLib, SV_NAME, lv_name, + false /* modififies CFG */, false /* transform pass */) Index: lib/Transforms/IntrinToMathLib/LLVMBuild.txt =================================================================== --- lib/Transforms/IntrinToMathLib/LLVMBuild.txt +++ lib/Transforms/IntrinToMathLib/LLVMBuild.txt @@ -0,0 +1,5 @@ +[component_0] +type = Library +name = IntrinToMathLib +parent = Transforms +required_libraries = Analysis Core Scalar Support TransformUtils Index: lib/Transforms/IntrinToMathLib/Search.cpp =================================================================== --- lib/Transforms/IntrinToMathLib/Search.cpp +++ lib/Transforms/IntrinToMathLib/Search.cpp @@ -0,0 +1,155 @@ +//==---------- Search.cpp - compiler/library interface -*- C++ -*-----------==// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +/// \file +/// Helper routines to perform searches in various arrays. +// +// ===--------------------------------------------------------------------=== // + +#include "llvm/Transforms/IntrinToMathLib/Search.h" +#include "llvm/Transforms/IntrinToMathLib/ImlAttrPrivate.h" +#include "llvm/Transforms/IntrinToMathLib/Messaging.h" +#include + +#define DEBUG_TYPE "ImlInterfaceSearch" + +#if defined __cplusplus +extern "C" { +#endif // __cplusplus + +// this function performs a binary search over the !sorted! array of strings +// and returns the index if the value is found +IMLATTR_INTERNAL_FUNC_VISIBILITY +int imlAttrGetNameIndex(const char *Name, const char *WhereToSearch[], + int MaxSize) { + + int Left, Right, StrIdx, Direction; + + if (!strcmp(Name, "")) { + PRN_MSG("error: in ImlAttrGetNameIndex: empty search token\n"); + return -1; + } + +#ifdef DEBUG + // user should not suffer the penalty of this extra check + int i; + + for (i = 0; i < MaxSize - 1; i++) { + if (strcmp(WhereToSearch[i], WhereToSearch[i + 1]) >= 0) { + PRN_MSG("error: in ImlAttrGetNameIndex: search space unsorted\n"); + PRN_MSG("error: in ImlAttrGetNameIndex: %s >= %s\n", + WhereToSearch[i], WhereToSearch[i + 1]); + return -2; + } + } +#endif + + Left = 0; + Right = MaxSize - 1; + + while ((Right - Left) > 1) { + StrIdx = (Left + Right) / 2; + + Direction = strcmp(Name, WhereToSearch[StrIdx]); + + if (Direction < 0) { + Right = StrIdx; + } else if (Direction > 0) { + Left = StrIdx; + } else if (Direction == 0) { + return StrIdx; + } + } + + if (!strcmp(Name, WhereToSearch[Left])) { + return Left; + } + if (!strcmp(Name, WhereToSearch[Right])) { + return Right; + } + + PRN_MSG("error: in ImlAttrGetNameIndex: token \"%s\" not found\n", Name); + return -3; +} + +// this function performs a search over the !unsorted! array of strings +// and returns the index if the value is found +IMLATTR_INTERNAL_FUNC_VISIBILITY +int imlAttrGetNameIndexUnsorted(const char *Name, const char *WhereToSearch[], + int MaxSize) { + int i; + + if (!strcmp(Name, "")) { + PRN_MSG("error: in ImlAttrGetNameIndexUnsorted: empty search token\n"); + return -1; + } + + for (i = 0; i < MaxSize; i++) { + if (!strcmp(Name, WhereToSearch[i])) { + return i; + } + } + + PRN_MSG( + "error: in ImlAttrGetNameIndexUnsorted: token \"%s\" not found\n", + Name); + return -2; +} + +// this function performs a binary search over the !sorted! array of integers +// returns the index of the value which is less than or equal +// return zero if searching number is less than all present in array +IMLATTR_INTERNAL_FUNC_VISIBILITY +int imlAttrGetIntIndex(const int Name, const int *WhereToSearch, int MaxSize) { + + int Left, Right, StrIdx; + +#ifdef DEBUG + // user should not suffer the penalty of this extra check + int i; + + for (i = 0; i < MaxSize - 1; i++) { + if (WhereToSearch[i] >= WhereToSearch[i + 1]) { + PRN_MSG("error: in ImlAttrGetIntIndex: search space unsorted\n"); + PRN_MSG("error: in ImlAttrGetIntIndex: a[%d] >= a[%d]\n", i, i + 1); + return 0; + } + } +#endif + + Left = 0; + Right = MaxSize - 1; + + while ((Right - Left) > 1) { + StrIdx = (Left + Right) / 2; + + if (Name < WhereToSearch[StrIdx]) { + Right = StrIdx; + } else if (Name > WhereToSearch[StrIdx]) { + Left = StrIdx; + } else { + return StrIdx; + } + } + + if (Name <= WhereToSearch[Left]) { + return Left; + } + if (Name >= WhereToSearch[Right]) { + return Right; + } + + PRN_MSG("error: in ImlAttrGetIntIndex: token \"%d\" not found, should " + "not get here\n", Name); + return 0; +} + +#if defined __cplusplus +} +#endif // __cplusplus Index: lib/Transforms/LLVMBuild.txt =================================================================== --- lib/Transforms/LLVMBuild.txt +++ lib/Transforms/LLVMBuild.txt @@ -16,7 +16,7 @@ ;===------------------------------------------------------------------------===; [common] -subdirectories = IPO InstCombine Instrumentation Scalar Utils Vectorize ObjCARC +subdirectories = IPO InstCombine Instrumentation Scalar Utils Vectorize ObjCARC IntrinToMathLib [component_0] type = Group Index: test/Transforms/IntrinToMathLib/cosf.ll =================================================================== --- test/Transforms/IntrinToMathLib/cosf.ll +++ test/Transforms/IntrinToMathLib/cosf.ll @@ -0,0 +1,42 @@ +; Check to see that the llvm.cos.v4f32 intrinsic is translated to svml. + +; RUN: opt -intrin-to-mathlib -S < %s | FileCheck %s + +; CHECK-LABEL: @foo +; CHECK: call <4 x float> @__svml_cosf4 +; CHECK: ret + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +@.str = private unnamed_addr constant [6 x i8] c"%.2f\0A\00", align 1 + +; Function Attrs: nounwind uwtable +define void @foo(float* nocapture %array) #0 { +entry: + br label %vector.body + +vector.body: ; preds = %vector.body, %entry + %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ] + %0 = trunc i64 %index to i32 + %broadcast.splatinsert6 = insertelement <4 x i32> undef, i32 %0, i32 0 + %broadcast.splat7 = shufflevector <4 x i32> %broadcast.splatinsert6, <4 x i32> undef, <4 x i32> zeroinitializer + %induction8 = add <4 x i32> %broadcast.splat7, + %1 = sitofp <4 x i32> %induction8 to <4 x float> + %2 = call <4 x float> @llvm.cos.v4f32(<4 x float> %1) + %3 = getelementptr inbounds float, float* %array, i64 %index + %4 = bitcast float* %3 to <4 x float>* + store <4 x float> %2, <4 x float>* %4, align 4 + %index.next = add i64 %index, 4 + %5 = icmp eq i64 %index.next, 1000 + br i1 %5, label %for.end, label %vector.body + +for.end: ; preds = %vector.body + ret void +} + +; Function Attrs: nounwind readnone +declare <4 x float> @llvm.cos.v4f32(<4 x float>) #3 + +attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #3 = { nounwind readnone } Index: test/Transforms/IntrinToMathLib/expf.ll =================================================================== --- test/Transforms/IntrinToMathLib/expf.ll +++ test/Transforms/IntrinToMathLib/expf.ll @@ -0,0 +1,42 @@ +; Check to see that the llvm.exp.v4f32 intrinsic is translated to svml. + +; RUN: opt -intrin-to-mathlib -S < %s | FileCheck %s + +; CHECK-LABEL: @foo +; CHECK: call <4 x float> @__svml_expf4 +; CHECK: ret + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +@.str = private unnamed_addr constant [6 x i8] c"%.2f\0A\00", align 1 + +; Function Attrs: nounwind uwtable +define void @foo(float* nocapture %array) #0 { +entry: + br label %vector.body + +vector.body: ; preds = %vector.body, %entry + %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ] + %0 = trunc i64 %index to i32 + %broadcast.splatinsert6 = insertelement <4 x i32> undef, i32 %0, i32 0 + %broadcast.splat7 = shufflevector <4 x i32> %broadcast.splatinsert6, <4 x i32> undef, <4 x i32> zeroinitializer + %induction8 = add <4 x i32> %broadcast.splat7, + %1 = sitofp <4 x i32> %induction8 to <4 x float> + %2 = call <4 x float> @llvm.exp.v4f32(<4 x float> %1) + %3 = getelementptr inbounds float, float* %array, i64 %index + %4 = bitcast float* %3 to <4 x float>* + store <4 x float> %2, <4 x float>* %4, align 4 + %index.next = add i64 %index, 4 + %5 = icmp eq i64 %index.next, 1000 + br i1 %5, label %for.end, label %vector.body + +for.end: ; preds = %vector.body + ret void +} + +; Function Attrs: nounwind readnone +declare <4 x float> @llvm.exp.v4f32(<4 x float>) #3 + +attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #3 = { nounwind readnone } Index: test/Transforms/IntrinToMathLib/logf.ll =================================================================== --- test/Transforms/IntrinToMathLib/logf.ll +++ test/Transforms/IntrinToMathLib/logf.ll @@ -0,0 +1,42 @@ +; Check to see that the llvm.log.v4f32 intrinsic is translated to svml. + +; RUN: opt -intrin-to-mathlib -S < %s | FileCheck %s + +; CHECK-LABEL: @foo +; CHECK: call <4 x float> @__svml_logf4 +; CHECK: ret + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +@.str = private unnamed_addr constant [6 x i8] c"%.2f\0A\00", align 1 + +; Function Attrs: nounwind uwtable +define void @foo(float* nocapture %array) #0 { +entry: + br label %vector.body + +vector.body: ; preds = %vector.body, %entry + %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ] + %0 = trunc i64 %index to i32 + %broadcast.splatinsert6 = insertelement <4 x i32> undef, i32 %0, i32 0 + %broadcast.splat7 = shufflevector <4 x i32> %broadcast.splatinsert6, <4 x i32> undef, <4 x i32> zeroinitializer + %induction8 = add <4 x i32> %broadcast.splat7, + %1 = sitofp <4 x i32> %induction8 to <4 x float> + %2 = call <4 x float> @llvm.log.v4f32(<4 x float> %1) + %3 = getelementptr inbounds float, float* %array, i64 %index + %4 = bitcast float* %3 to <4 x float>* + store <4 x float> %2, <4 x float>* %4, align 4 + %index.next = add i64 %index, 4 + %5 = icmp eq i64 %index.next, 1000 + br i1 %5, label %for.end, label %vector.body + +for.end: ; preds = %vector.body + ret void +} + +; Function Attrs: nounwind readnone +declare <4 x float> @llvm.log.v4f32(<4 x float>) #3 + +attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #3 = { nounwind readnone } Index: test/Transforms/IntrinToMathLib/powf.ll =================================================================== --- test/Transforms/IntrinToMathLib/powf.ll +++ test/Transforms/IntrinToMathLib/powf.ll @@ -0,0 +1,48 @@ +; Check to see that the llvm.pow.v4f32 intrinsic is translated to svml. + +; RUN: opt -intrin-to-mathlib -S < %s | FileCheck %s + +; CHECK-LABEL: @foo +; CHECK: call <4 x float> @__svml_powf4 +; CHECK: ret + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +; Function Attrs: norecurse nounwind uwtable +define void @foo(float* nocapture %array, float* noalias nocapture readonly %array2, float* noalias nocapture readonly %array3) #0 { +entry: + br label %vector.body + +vector.body: ; preds = %vector.body, %entry + %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ] + %0 = getelementptr inbounds float, float* %array2, i64 %index + %1 = bitcast float* %0 to <4 x float>* + %wide.load = load <4 x float>, <4 x float>* %1, align 4 + %2 = getelementptr inbounds float, float* %array3, i64 %index + %3 = bitcast float* %2 to <4 x float>* + %wide.load11 = load <4 x float>, <4 x float>* %3, align 4 + %4 = call <4 x float> @llvm.pow.v4f32(<4 x float> %wide.load, <4 x float> %wide.load11) + %5 = getelementptr inbounds float, float* %array, i64 %index + %6 = bitcast float* %5 to <4 x float>* + store <4 x float> %4, <4 x float>* %6, align 4 + %index.next = add i64 %index, 4 + %7 = icmp eq i64 %index.next, 1000 + br i1 %7, label %for.end, label %vector.body + +for.end: ; preds = %vector.body + ret void +} + +; Function Attrs: norecurse nounwind readnone uwtable +define i32 @main() #1 { +entry: + ret i32 0 +} + +; Function Attrs: nounwind readnone +declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) #2 + +attributes #0 = { norecurse nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #1 = { norecurse nounwind readnone uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #2 = { nounwind readnone } Index: test/Transforms/IntrinToMathLib/sinf.ll =================================================================== --- test/Transforms/IntrinToMathLib/sinf.ll +++ test/Transforms/IntrinToMathLib/sinf.ll @@ -0,0 +1,42 @@ +; Check to see that the llvm.sin.v4f32 intrinsic is translated to svml. + +; RUN: opt -intrin-to-mathlib -S < %s | FileCheck %s + +; CHECK-LABEL: @foo +; CHECK: call <4 x float> @__svml_sinf4 +; CHECK: ret + +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +@.str = private unnamed_addr constant [6 x i8] c"%.2f\0A\00", align 1 + +; Function Attrs: nounwind uwtable +define void @foo(float* nocapture %array) #0 { +entry: + br label %vector.body + +vector.body: ; preds = %vector.body, %entry + %index = phi i64 [ 0, %entry ], [ %index.next, %vector.body ] + %0 = trunc i64 %index to i32 + %broadcast.splatinsert6 = insertelement <4 x i32> undef, i32 %0, i32 0 + %broadcast.splat7 = shufflevector <4 x i32> %broadcast.splatinsert6, <4 x i32> undef, <4 x i32> zeroinitializer + %induction8 = add <4 x i32> %broadcast.splat7, + %1 = sitofp <4 x i32> %induction8 to <4 x float> + %2 = call <4 x float> @llvm.sin.v4f32(<4 x float> %1) + %3 = getelementptr inbounds float, float* %array, i64 %index + %4 = bitcast float* %3 to <4 x float>* + store <4 x float> %2, <4 x float>* %4, align 4 + %index.next = add i64 %index, 4 + %5 = icmp eq i64 %index.next, 1000 + br i1 %5, label %for.end, label %vector.body + +for.end: ; preds = %vector.body + ret void +} + +; Function Attrs: nounwind readnone +declare <4 x float> @llvm.sin.v4f32(<4 x float>) #3 + +attributes #0 = { nounwind uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="true" "use-soft-float"="false" } +attributes #3 = { nounwind readnone } Index: tools/bugpoint/CMakeLists.txt =================================================================== --- tools/bugpoint/CMakeLists.txt +++ tools/bugpoint/CMakeLists.txt @@ -14,6 +14,7 @@ Target TransformUtils Vectorize + IntrinToMathLib ) # Support plugins. Index: tools/bugpoint/bugpoint.cpp =================================================================== --- tools/bugpoint/bugpoint.cpp +++ tools/bugpoint/bugpoint.cpp @@ -130,6 +130,7 @@ initializeInstCombine(Registry); initializeInstrumentation(Registry); initializeTarget(Registry); + initializeIntrinToMathLibPass(Registry); #ifdef LINK_POLLY_INTO_TOOLS polly::initializePollyPasses(Registry); Index: tools/opt/CMakeLists.txt =================================================================== --- tools/opt/CMakeLists.txt +++ tools/opt/CMakeLists.txt @@ -16,6 +16,7 @@ TransformUtils Vectorize Passes + IntrinToMathLib ) # Support plugins. Index: tools/opt/opt.cpp =================================================================== --- tools/opt/opt.cpp +++ tools/opt/opt.cpp @@ -354,6 +354,7 @@ initializeSafeStackPass(Registry); initializeSjLjEHPreparePass(Registry); initializePreISelIntrinsicLoweringPass(Registry); + initializeIntrinToMathLibPass(Registry); #ifdef LINK_POLLY_INTO_TOOLS polly::initializePollyPasses(Registry);