pax_global_header 0000666 0000000 0000000 00000000064 13730031441 0014506 g ustar 00root root 0000000 0000000 52 comment=cc4b0213f2f57a2f7e8f6355758dc40973ae9998
sleef-3.5.1/ 0000775 0000000 0000000 00000000000 13730031441 0012612 5 ustar 00root root 0000000 0000000 sleef-3.5.1/.travis.yml 0000664 0000000 0000000 00000005147 13730031441 0014732 0 ustar 00root root 0000000 0000000 language: c
# Default linux jobs
os: linux
sudo: required
dist: bionic
# Include osx jobs
matrix:
include:
- os: osx
arch: amd64
compiler: clang # use default apple clang
env:
- LABEL="osx-clang"
- os: linux
services: docker
env:
- LABEL="armhf-gcc"
- ENABLE_DOCKER="true"
- os: linux
arch: amd64
addons:
apt:
packages:
- gcc-7
env:
- LABEL="x86_64-gcc"
- os: linux
arch: amd64
addons:
apt:
packages:
- clang-7
env:
- LABEL="x86_64-clang"
- os: linux
arch: arm64
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- gcc-10
env:
- LABEL="arm64-gcc-sve"
- os: linux
arch: arm64
addons:
apt:
packages:
- clang-8
env:
- LABEL="arm64-clang"
- arch: ppc64le
dist: bionic
env:
- LABEL="ppc64le-gcc"
- OMP_WAIT_POLICY=passive CTEST_OUTPUT_ON_FAILURE=TRUE
- arch: ppc64le
compiler: clang
dist: bionic
env:
- LABEL="ppc64le-clang"
- OMP_WAIT_POLICY=passive CTEST_OUTPUT_ON_FAILURE=TRUE
- arch: s390x
dist: bionic
env:
- LABEL="s390x-gcc"
- OMP_WAIT_POLICY=passive CTEST_OUTPUT_ON_FAILURE=TRUE
- os: linux
arch: s390x
compiler: clang-8
addons:
apt:
packages:
- clang-8
env:
- LABEL="s390x-clang"
- OMP_WAIT_POLICY=passive CTEST_OUTPUT_ON_FAILURE=TRUE
before_install:
- export PATH=$PATH:/usr/bin
- if [[ -x /bin/true ]]; then LD_SHOW_AUXV=1 /bin/true; fi
- sed '/^ *$/q' /proc/cpuinfo || true
- cd ${TRAVIS_BUILD_DIR}
- chmod +x ${TRAVIS_BUILD_DIR}/travis/*.sh
- if [[ "${ENABLE_DOCKER}" == "true" ]]; then ${TRAVIS_BUILD_DIR}/travis/setupdocker.sh; fi
- if [[ "${ENABLE_DOCKER}" == "true" ]]; then docker exec bionic /build/travis/before_install.${LABEL}.sh; fi
- if [[ "${ENABLE_DOCKER}" != "true" ]]; then ${TRAVIS_BUILD_DIR}/travis/before_install.${LABEL}.sh; fi
before_script:
- if [[ "${ENABLE_DOCKER}" == "true" ]]; then docker exec bionic /build/travis/before_script.${LABEL}.sh; fi
- if [[ "${ENABLE_DOCKER}" != "true" ]]; then ${TRAVIS_BUILD_DIR}/travis/before_script.${LABEL}.sh; fi
script:
- if [[ "${ENABLE_DOCKER}" == "true" ]]; then docker exec bionic /build/travis/script.${LABEL}.sh; fi
- if [[ "${ENABLE_DOCKER}" != "true" ]]; then ${TRAVIS_BUILD_DIR}/travis/script.${LABEL}.sh; fi
sleef-3.5.1/CHANGELOG.md 0000664 0000000 0000000 00000016313 13730031441 0014427 0 ustar 00root root 0000000 0000000 ## 3.5 - 2020-09-01
- IBM System/390 support is added.
- The library can be built with Clang on Windows.
- Static libraries with LTO can be generated.
- Alternative division and sqrt methods can be chosen with AArch64.
- Header files for inlining the whole SLEEF functions can be generated.
- IEEE remainder function is added.
- GCC-10 can now build SLEEF with SVE support.
## 3.4.1 - 2019-10-01
### Changed
- Fixed accuracy problem with tan_u35, atan_u10, log2f_u35 and exp10f_u10.
https://github.com/shibatch/sleef/pull/260
https://github.com/shibatch/sleef/pull/265
https://github.com/shibatch/sleef/pull/267
- SVE intrinsics that are not supported in newer ACLE are replaced.
https://github.com/shibatch/sleef/pull/268
- FMA4 detection problem is fixed.
https://github.com/shibatch/sleef/pull/262
- Compilation problem under Windows with MinGW is fixed.
https://github.com/shibatch/sleef/pull/266
## 3.4 - 2019-04-28
### Added
- Faster and low precision functions are added.
https://github.com/shibatch/sleef/pull/229
- Functions that return consistent results across platforms are
added
https://github.com/shibatch/sleef/pull/216
https://github.com/shibatch/sleef/pull/224
- Quad precision math library(libsleefquad) is added
https://github.com/shibatch/sleef/pull/235
https://github.com/shibatch/sleef/pull/237
https://github.com/shibatch/sleef/pull/240
- AArch64 Vector Procedure Call Standard (AAVPCS) support.
### Changed
- Many functions are now faster
- Testers are now faster
## 3.3.1 - 2018-08-20
### Added
- FreeBSD support is added
### Changed
- i386 build problem is fixed
- Trigonometric functions now evaluate correctly with full FP
domain.
https://github.com/shibatch/sleef/pull/210
## 3.3 - 2018-07-06
### Added
- SVE target support is added to libsleef.
https://github.com/shibatch/sleef/pull/180
- SVE target support is added to DFT. With this patch, DFT operations
can be carried out using 256, 512, 1024 and 2048-bit wide vectors
according to runtime availability of vector registers and operators.
https://github.com/shibatch/sleef/pull/182
- 3.5-ULP versions of sinh, cosh, tanh, sinhf, coshf, tanhf, and the
corresponding testing functionalities are added.
https://github.com/shibatch/sleef/pull/192
- Power VSX target support is added to libsleef.
https://github.com/shibatch/sleef/pull/195
- Payne-Hanek like argument reduction is added to libsleef.
https://github.com/shibatch/sleef/pull/197
## 3.2 - 2018-02-26
### Added
- The whole build system of the project migrated from makefiles to
cmake. In particualr this includes `libsleef`, `libsleefgnuabi`,
`libdft` and all the tests.
- Benchmarks that compare `libsleef` vs `SVML` on X86 Linux are
available in the project tree under src/libm-benchmarks directory.
- Extensive upstream testing via Travis CI and Appveyor, on the
following systems:
* OS: Windows / Linux / OSX.
* Compilers: gcc / clang / MSVC.
* Targets: X86 (SSE/AVX/AVX2/AVX512F), AArch64 (Advanced SIMD), ARM
(NEON). Emulators like QEMU or SDE can be used to run the tests.
- Added the following new vector functions (with relative testing):
* `log2`
- New compatibility tests have been added to check that
`libsleefgnuabi` exports the GNUABI symbols correctly.
- The library can be compiled to an LLVM bitcode object.
- Added masked interface to the library to support AVX512F masked
vectorization.
### Changed
- Use native instructions if available for `sqrt`.
- Fixed fmax and fmin behavior on AArch64:
https://github.com/shibatch/sleef/pull/140
- Speed improvements for `asin`, `acos`, `fmod` and `log`. Computation
speed of other functions are also improved by general optimization.
https://github.com/shibatch/sleef/pull/97
- Removed `libm` dependency.
### Removed
- Makefile build system
## 3.1 - 2017-07-19
- Added AArch64 support
- Implemented the remaining C99 math functions : lgamma, tgamma,
erf, erfc, fabs, copysign, fmax, fmin, fdim, trunc, floor, ceil,
round, rint, modf, ldexp, nextafter, frexp, hypot, and fmod.
- Added dispatcher for x86 functions
- Improved reduction of trigonometric functions
- Added support for 32-bit x86, Cygwin, etc.
- Improved tester
## 3.0 - 2017-02-07
- New API is defined
- Functions for DFT are added
- sincospi functions are added
- gencoef now supports single, extended and quad precision in addition to double precision
- Linux, Windows and Mac OS X are supported
- GCC, Clang, Intel Compiler, Microsoft Visual C++ are supported
- The library can be compiled as DLLs
- Files needed for creating a debian package are now included
## 2.120 - 2017-01-30
- Relicensed to Boost Software License Version 1.0
## 2.110 - 2016-12-11
- The valid range of argument is extended for trig functions
- Specification of each functions regarding to the domain and accuracy is added
- A coefficient generation tool is added
- New testing tools are introduced
- Following functions returned incorrect values when the argument is very large or small : exp, pow, asinh, acosh
- SIMD xsin and xcos returned values more than 1 when FMA is enabled
- Pure C cbrt returned incorrect values when the argument is negative
- tan_u1 returned values with more than 1 ulp of error on rare occasions
- Removed support for Java language(because no one seems using this)
## 2.100 - 2016-12-04
- Added support for AVX-512F and Clang Extended Vectors.
## 2.90 - 2016-11-27
- Added ilogbf. All the reported bugs(listed below) are fixed.
- Log function returned incorrect values when the argument is very small.
- Signs of returned values were incorrect when the argument is signed zero.
- Tester incorrectly counted ULP in some cases.
- ilogb function returned incorrect values in some cases.
## 2.80 - 2013-05-18
- Added support for ARM NEON. Added higher accuracy single
precision functions : sinf_u1, cosf_u1, sincosf_u1, tanf_u1, asinf_u1,
acosf_u1, atanf_u1, atan2f_u1, logf_u1, and cbrtf_u1.
## 2.70 - 2013-04-30
- Added higher accuracy functions : sin_u1, cos_u1, sincos_u1,
tan_u1, asin_u1, acos_u1, atan_u1, atan2_u1, log_u1, and
cbrt_u1. These functions evaluate the corresponding function with at
most 1 ulp of error.
## 2.60 - 2013-03-26
- Added the remaining single precision functions : powf, sinhf,
coshf, tanhf, exp2f, exp10f, log10f, log1pf. Added support for FMA4
(for AMD Bulldozer). Added more test cases. Fixed minor bugs (which
degraded accuracy in some rare cases).
## 2.50 - 2013-03-12
- Added support for AVX2. SLEEF now compiles with ICC.
## 2.40 - 2013-03-07
- Fixed incorrect denormal/nonnumber handling in ldexp, ldexpf,
sinf and cosf. Removed support for Go language.
## 2.31 - 2012-07-05
- Added sincosf.
## 2.30 - 2012-01-20
- Added single precision functions : sinf, cosf, tanf, asinf,
acosf, atanf, logf, expf, atan2f and cbrtf.
## 2.20 - 2012-01-09
- Added exp2, exp10, expm1, log10, log1p, and cbrt.
## 2.10 - 2012-01-05
- asin() and acos() are back.
- Added ilogb() and ldexp().
- Added hyperbolic functions.
- Eliminated dependency on frexp, ldexp, fabs, isnan and isinf.
## 2.00 - 2011-12-30
- All of the algorithm has been updated.
- Both accuracy and speed are improved since version 1.10.
- Denormal number handling is also improved.
## 1.10 - 2010-06-22
- AVX support is added. Accuracy tester is added.
## 1.00 - 2010-05-15
- Initial release
sleef-3.5.1/CMakeLists.txt 0000664 0000000 0000000 00000020140 13730031441 0015347 0 ustar 00root root 0000000 0000000 # Options
option(BUILD_SHARED_LIBS "Build shared libs" ON)
option(BUILD_STATIC_TEST_BINS "Build statically linked test executables" OFF)
option(ENABLE_LTO "Enable LTO on GCC or ThinLTO on clang" OFF)
option(BUILD_LIBM "libsleef will be built." ON)
option(BUILD_DFT "libsleefdft will be built." ON)
option(BUILD_QUAD "libsleefquad will be built." OFF)
option(BUILD_GNUABI_LIBS "libsleefgnuabi will be built." ON)
option(BUILD_TESTS "Tests will be built." ON)
option(BUILD_INLINE_HEADERS "Build header for inlining whole SLEEF functions" OFF)
option(SLEEF_TEST_ALL_IUT "Perform tests on implementations with all vector extensions" OFF)
option(SLEEF_SHOW_CONFIG "Show SLEEF configuration status messages." ON)
option(SLEEF_SHOW_ERROR_LOG "Show cmake error log." OFF)
option(ENFORCE_TESTER "Build fails if tester is not available" OFF)
option(ENFORCE_TESTER3 "Build fails if tester3 is not built" OFF)
option(ENABLE_ALTDIV "Enable alternative division method (aarch64 only)" OFF)
option(ENABLE_ALTSQRT "Enable alternative sqrt method (aarch64 only)" OFF)
option(DISABLE_FFTW "Disable testing the DFT library with FFTW" OFF)
cmake_minimum_required(VERSION 3.4.3)
# Set to NEW when updating cmake_minimum_required to VERSION >= 3.7.2
if(${CMAKE_VERSION} VERSION_GREATER "3.7.1")
cmake_policy(SET CMP0066 OLD)
endif()
if(${CMAKE_VERSION} VERSION_GREATER "3.14.99")
cmake_policy(SET CMP0091 NEW)
endif()
enable_testing()
set(SLEEF_VERSION_MAJOR 3)
set(SLEEF_VERSION_MINOR 5)
set(SLEEF_VERSION_PATCHLEVEL 1)
set(SLEEF_VERSION ${SLEEF_VERSION_MAJOR}.${SLEEF_VERSION_MINOR}.${SLEEF_VERSION_PATCHLEVEL})
set(SLEEF_SOVERSION ${SLEEF_VERSION_MAJOR})
project(SLEEF
VERSION ${SLEEF_VERSION}
LANGUAGES C)
# For specifying installation directories
include(GNUInstallDirs)
if(NOT DEFINED sleef_SOURCE_DIR)
set(sleef_SOURCE_DIR ${CMAKE_SOURCE_DIR})
endif()
if(NOT DEFINED sleef_BINARY_DIR)
set(sleef_BINARY_DIR ${CMAKE_BINARY_DIR})
endif()
# Sanity check for in-source builds which we do not want to happen
if(sleef_SOURCE_DIR STREQUAL sleef_BINARY_DIR)
message(FATAL_ERROR "SLEEF does not allow in-source builds.
You can refer to doc/build-with-cmake.md for instructions on how provide a \
separate build directory. Note: Please remove autogenerated file \
`CMakeCache.txt` and directory `CMakeFiles` in the current directory.")
endif()
if(ENABLE_LTO AND BUILD_SHARED_LIBS)
message(FATAL_ERROR "ENABLE_LTO and BUILD_SHARED_LIBS cannot be specified at the same time")
endif(ENABLE_LTO AND BUILD_SHARED_LIBS)
if(ENABLE_LTO)
cmake_policy(SET CMP0069 NEW)
include(CheckIPOSupported)
check_ipo_supported(RESULT supported OUTPUT error)
endif()
# Set output directories for the library files
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
foreach(CONFIG ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${CONFIG} CONFIG)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CONFIG} ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CONFIG} ${PROJECT_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CONFIG} ${PROJECT_BINARY_DIR}/bin)
endforeach(CONFIG CMAKE_CONFIGURATION_TYPES)
# Path for finding cmake modules
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules)
set(SLEEF_SCRIPT_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Scripts CACHE PATH
"Path for finding sleef specific cmake scripts")
if (CMAKE_C_COMPILER_ID MATCHES "Clang" AND "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
message(STATUS "Building with Clang on Windows")
set(SLEEF_CLANG_ON_WINDOWS TRUE)
endif()
# sleef-config.h.in passes cmake settings to the source code
include(Configure.cmake)
configure_file(
${PROJECT_SOURCE_DIR}/sleef-config.h.in
${PROJECT_BINARY_DIR}/include/sleef-config.h @ONLY)
# We like to have a documented index of all targets in the project. The
# variables listed below carry the names of the targets defined throughout
# the project.
# Generates object file (shared library) `libsleef`
# Defined in src/libm/CMakeLists.txt via command add_library
set(TARGET_LIBSLEEF "sleef")
set(TARGET_LIBSLEEFGNUABI "sleefgnuabi")
# Generates the sleef.h headers and all the rename headers
# Defined in src/libm/CMakeLists.txt via custom commands and a custom target
set(TARGET_HEADERS "headers")
set(TARGET_INLINE_HEADERS "inline_headers")
set(TARGET_LIBINLINE "sleefinline")
# Generates executable files for running the test suite
# Defined in src/libm-tester/CMakeLists.txt via command add_executable
set(TARGET_TESTER "tester")
set(TARGET_IUT "iut")
# The target to generate LLVM bitcode only, available when SLEEF_ENABLE_LLVM_BITCODE is passed to cmake
set(TARGET_LLVM_BITCODE "llvm-bitcode")
# Generates the helper executable file mkrename needed to write the sleef header
set(TARGET_MKRENAME "mkrename")
set(TARGET_MKRENAME_GNUABI "mkrename_gnuabi")
set(TARGET_MKMASKED_GNUABI "mkmasked_gnuabi")
# Generates the helper executable file mkdisp needed to write the sleef header
set(TARGET_MKDISP "mkdisp")
set(TARGET_MKALIAS "mkalias")
# Generates static library common
# Defined in src/common/CMakeLists.txt via command add_library
set(TARGET_LIBCOMMON_OBJ "common")
set(TARGET_LIBARRAYMAP_OBJ "arraymap")
# Function used to add an executable that is executed on host
function(add_host_executable TARGETNAME)
if (NOT CMAKE_CROSSCOMPILING)
add_executable(${TARGETNAME} ${ARGN})
else()
add_executable(${TARGETNAME} IMPORTED)
set_property(TARGET ${TARGETNAME} PROPERTY IMPORTED_LOCATION ${NATIVE_BUILD_DIR}/bin/${TARGETNAME})
endif()
endfunction()
function(host_target_AAVPCS_definitions TARGETNAME)
if (NOT CMAKE_CROSSCOMPILING)
target_compile_definitions(${TARGETNAME} PRIVATE ENABLE_AAVPCS=1)
endif()
endfunction()
# Generates object file (shared library) `libsleefdft`
# Defined in src/dft/CMakeLists.txt via command add_library
set(TARGET_LIBDFT "sleefdft")
# Check subdirectories
add_subdirectory("src")
# Extra messages at configuration time. By default is active, it can be
# turned off by invoking cmake with "-DSLEEF_SHOW_CONFIG=OFF".
if(SLEEF_SHOW_CONFIG)
message(STATUS "Configuring build for ${PROJECT_NAME}-v${SLEEF_VERSION}")
message(" Target system: ${CMAKE_SYSTEM}")
message(" Target processor: ${CMAKE_SYSTEM_PROCESSOR}")
message(" Host system: ${CMAKE_HOST_SYSTEM}")
message(" Host processor: ${CMAKE_HOST_SYSTEM_PROCESSOR}")
message(" Detected C compiler: ${CMAKE_C_COMPILER_ID} @ ${CMAKE_C_COMPILER}")
message(" CMake: ${CMAKE_VERSION}")
message(" Make program: ${CMAKE_MAKE_PROGRAM}")
if(CMAKE_CROSSCOMPILING)
message(" Crosscompiling SLEEF.")
message(" Native build dir: ${NATIVE_BUILD_DIR}")
endif(CMAKE_CROSSCOMPILING)
message(STATUS "Using option `${SLEEF_C_FLAGS}` to compile libsleef")
message(STATUS "Building shared libs : " ${BUILD_SHARED_LIBS})
message(STATUS "Building static test bins: " ${BUILD_STATIC_TEST_BINS})
message(STATUS "MPFR : " ${LIB_MPFR})
if (MPFR_INCLUDE_DIR)
message(STATUS "MPFR header file in " ${MPFR_INCLUDE_DIR})
endif()
message(STATUS "GMP : " ${LIBGMP})
message(STATUS "RT : " ${LIBRT})
message(STATUS "FFTW3 : " ${LIBFFTW3})
message(STATUS "OPENSSL : " ${OPENSSL_VERSION})
message(STATUS "SDE : " ${SDE_COMMAND})
if (BUILD_INLINE_HEADERS)
message(STATUS "SED : " ${SED_COMMAND})
endif()
message(STATUS "RUNNING_ON_TRAVIS : " ${RUNNING_ON_TRAVIS})
message(STATUS "COMPILER_SUPPORTS_OPENMP : " ${COMPILER_SUPPORTS_OPENMP})
if(ENABLE_GNUABI)
message(STATUS "A version of SLEEF compatible with libm and libmvec in GNU libc will be produced (${TARGET_LIBSLEEFGNUABI}.so)")
endif()
if (COMPILER_SUPPORTS_SVE)
message(STATUS "Building SLEEF with VLA SVE support")
if (ARMIE_COMMAND)
message(STATUS "Arm Instruction Emulator found at ${ARMIE_COMMAND}")
message(STATUS "SVE testing is done with ${SVE_VECTOR_BITS}-bits vectors.")
endif()
endif()
if(FORCE_AAVPCS)
message(STATUS "Building SLEEF with AArch64 Vector PCS support")
endif()
endif(SLEEF_SHOW_CONFIG)
if (NOT CMAKE_MAKE_PROGRAM MATCHES "ninja")
message("")
message("*** Note: Parallel build is only supported with Ninja ***")
message("")
endif()
sleef-3.5.1/CMakeLists.txt.nested 0000664 0000000 0000000 00000001256 13730031441 0016637 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 3.4.3)
set(sleef_SOURCE_DIR ${CMAKE_SOURCE_DIR}/sleef)
set(sleef_BINARY_DIR ${CMAKE_BINARY_DIR}/sleef)
add_subdirectory("sleef")
include_directories(${sleef_BINARY_DIR}/include)
include_directories(${sleef_SOURCE_DIR}/include)
link_directories(${sleef_BINARY_DIR}/lib)
add_executable(hellox86 hellox86.c)
set_target_properties(hellox86 PROPERTIES C_STANDARD 99)
add_dependencies(hellox86 sleef)
target_link_libraries(hellox86 sleef)
#
add_executable(dfttutorial tutorial.c)
set_target_properties(dfttutorial PROPERTIES C_STANDARD 99)
add_dependencies(dfttutorial sleef)
find_library(LIBM m)
target_link_libraries(dfttutorial sleef sleefdft ${LIBM})
sleef-3.5.1/CONTRIBUTORS.md 0000664 0000000 0000000 00000001343 13730031441 0015072 0 ustar 00root root 0000000 0000000 # List of contributors
| Name | Affiliation | Github profile |
| -------------------- | ----------------------- | ---------------------------------- |
| Naoki Shibata | Nara Institute of Science and Technology | https://github.com/shibatch |
| Jilayne Lovejoy | Arm Inc. | https://github.com/jlovejoy |
| Francesco Petrogalli | Arm Ltd. | https://github.com/fpetrogalli-arm |
| Diana Bite | Arm Ltd. | https://github.com/diaena |
| Alexandre Mutel | Unity Technologies | https://github.com/xoofx |
| Martin Krastev | Chaos Group | https://github.com/blu |
sleef-3.5.1/Configure.cmake 0000664 0000000 0000000 00000077535 13730031441 0015556 0 ustar 00root root 0000000 0000000 include(CheckCCompilerFlag)
include(CheckCSourceCompiles)
include(CheckTypeSize)
if (BUILD_STATIC_TEST_BINS)
set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
set(BUILD_SHARED_LIBS OFF)
set(CMAKE_EXE_LINKER_FLAGS "-static")
endif()
if (NOT CMAKE_CROSSCOMPILING AND NOT SLEEF_FORCE_FIND_PACKAGE_SSL)
find_package(OpenSSL)
if (OPENSSL_FOUND)
set(SLEEF_OPENSSL_FOUND TRUE)
set(SLEEF_OPENSSL_LIBRARIES ${OPENSSL_LIBRARIES})
set(SLEEF_OPENSSL_VERSION ${OPENSSL_VERSION})
set(SLEEF_OPENSSL_INCLUDE_DIR ${OPENSSL_INCLUDE_DIR})
endif()
else()
# find_package cannot find OpenSSL when cross-compiling
find_library(LIBSSL ssl)
find_library(LIBCRYPTO crypto)
if (LIBSSL AND LIBCRYPTO)
set(SLEEF_OPENSSL_FOUND TRUE)
set(SLEEF_OPENSSL_LIBRARIES ${LIBSSL} ${LIBCRYPTO})
set(SLEEF_OPENSSL_VERSION ${LIBSSL})
endif()
endif()
if (ENFORCE_TESTER3 AND NOT SLEEF_OPENSSL_FOUND)
message(FATAL_ERROR "ENFORCE_TESTER3 is specified and OpenSSL not found")
endif()
if (NOT (RUNNING_ON_APPVEYOR AND SLEEF_CLANG_ON_WINDOWS))
# We rely on Cygwin tools in order to test the builds on
# appveyor. However, if we try to link these libraries, cmake finds
# the Cygwin version of libraries, which causes errors.
# Some toolchains require explicit linking of the libraries following.
find_library(LIB_MPFR mpfr)
find_library(LIBM m)
find_library(LIBGMP gmp)
find_library(LIBRT rt)
find_library(LIBFFTW3 fftw3)
if (LIB_MPFR)
find_path(MPFR_INCLUDE_DIR
NAMES mpfr.h
ONLY_CMAKE_FIND_ROOT_PATH)
endif(LIB_MPFR)
if (LIBFFTW3)
find_path(FFTW3_INCLUDE_DIR
NAMES fftw3.h
ONLY_CMAKE_FIND_ROOT_PATH)
endif(LIBFFTW3)
if (NOT LIBM)
set(LIBM "")
endif()
if (NOT LIBRT)
set(LIBRT "")
endif()
endif(NOT (RUNNING_ON_APPVEYOR AND SLEEF_CLANG_ON_WINDOWS))
# The library currently supports the following SIMD architectures
set(SLEEF_SUPPORTED_EXTENSIONS
AVX512F AVX512FNOFMA AVX2 AVX2128 FMA4 AVX SSE4 SSE2 # x86
ADVSIMD ADVSIMDNOFMA SVE SVENOFMA # Aarch64
NEON32 NEON32VFPV4 # Aarch32
VSX VSXNOFMA # PPC64
ZVECTOR2 ZVECTOR2NOFMA # IBM Z
PUREC_SCALAR PURECFMA_SCALAR # Generic type
CACHE STRING "List of SIMD architectures supported by libsleef."
)
set(SLEEF_SUPPORTED_GNUABI_EXTENSIONS
SSE2 AVX AVX2 AVX512F ADVSIMD SVE
CACHE STRING "List of SIMD architectures supported by libsleef for GNU ABI."
)
set(SLEEFQUAD_SUPPORTED_EXT
PUREC_SCALAR PURECFMA_SCALAR SSE2 AVX FMA4 AVX2 AVX512F ADVSIMD SVE)
# Force set default build type if none was specified
# Note: some sleef code requires the optimisation flags turned on
if(NOT CMAKE_BUILD_TYPE)
message(STATUS "Setting build type to 'Release' (required for full support).")
set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Release" "RelWithDebInfo" "MinSizeRel")
endif()
# Function used to generate safe command arguments for add_custom_command
function(command_arguments PROPNAME)
set(quoted_args "")
foreach(arg ${ARGN})
list(APPEND quoted_args "\"${arg}\"" )
endforeach()
set(${PROPNAME} ${quoted_args} PARENT_SCOPE)
endfunction()
# PLATFORM DETECTION
if((CMAKE_SYSTEM_PROCESSOR MATCHES "x86") OR (CMAKE_SYSTEM_PROCESSOR MATCHES "AMD64") OR (CMAKE_SYSTEM_PROCESSOR MATCHES "amd64") OR (CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$"))
set(SLEEF_ARCH_X86 ON CACHE INTERNAL "True for x86 architecture.")
set(SLEEF_HEADER_LIST
SSE_
SSE2
SSE4
AVX_
AVX
FMA4
AVX2
AVX2128
AVX512F_
AVX512F
AVX512FNOFMA
PUREC_SCALAR
PURECFMA_SCALAR
)
command_arguments(HEADER_PARAMS_SSE_ cinz_ 2 4 __m128d __m128 __m128i __m128i __SSE2__)
command_arguments(HEADER_PARAMS_SSE2 cinz_ 2 4 __m128d __m128 __m128i __m128i __SSE2__ sse2)
command_arguments(HEADER_PARAMS_SSE4 cinz_ 2 4 __m128d __m128 __m128i __m128i __SSE2__ sse4)
command_arguments(HEADER_PARAMS_AVX_ cinz_ 4 8 __m256d __m256 __m128i "struct { __m128i x, y$ Sleef_float32x4_t_2 Description
Sleef_float32x4_t_2 is a data type for storing two float32x4_t values,
which is defined in sleef.h as follows:
Vectorized single precision sine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision combined sine and cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincosf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincosf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision sine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinpif_u05. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cospif_u05. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision combined sine and cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospif_u05. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospif_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision power function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_powf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision natural logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_logf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision natural logarithmic function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_logf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-10 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log10f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-2 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log2f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision logarithm of one plus argument with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log1pf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-e exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-2 exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp2f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-10 exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp10f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision base-e exponential function minus 1 with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expm1f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision square root function with 0.5001 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrtf_u05. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision square root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrtf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision cubic root function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrtf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision cubic root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrtf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision 2D Euclidian distance function with 0.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypotf_u05. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision 2D Euclidian distance function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypotf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acosf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acosf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc tangent function of two variables with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2f_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision arc tangent function of two variables with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2f_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinhf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinhf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_coshf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_coshf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanhf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanhf_u35. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision inverse hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinhf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision inverse hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acoshf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision inverse hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanhf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erff_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision complementary error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erfcf_u15. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tgammaf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision log gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_lgammaf_u10. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for rounding to integer towards zero Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_truncf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for rounding to integer towards negative infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_floorf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for rounding to integer towards positive infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_ceilf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_roundf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_rintf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for fused multiply-accumulation Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmaf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmodf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_remainderf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for obtaining fractional component of an FP number Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_frfrexpf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision signed integral and fractional values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_modff. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for calculating the absolute value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fabsf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for copying signs Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_copysignf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for determining maximum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmaxf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for determining minimum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fminf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function to calculate positive difference of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fdimf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Vectorized single precision function for obtaining the next representable FP value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_nextafterf. This function may less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.
Sleef_float32x4_t_2 Description
Sleef_float32x4_t_2 is a data type for storing two float32x4_t values,
which is defined in sleef.h as follows:
Sleef_float64x2_t_2 Description
Sleef_float64x2_t_2 is a data type for storing two float64x2_t values,
which is defined in sleef.h as follows:
Sleef_svfloat32_t_2 Description
Sleef_svfloat32_t_2 is a data type for storing two svfloat32_t values,
which is defined in sleef.h as follows:
Sleef_svfloat64_t_2 Description
Sleef_svfloat64_t_2 is a data type for storing two svfloat64_t values,
which is defined in sleef.h as follows:
Vectorized double precision sine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sin_u10 with the same accuracy specification.
Vectorized single precision sine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinf_u10 with the same accuracy specification.
Vectorized double precision sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sin_u35 with the same accuracy specification.
Vectorized single precision sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinf_u35 with the same accuracy specification.
Vectorized double precision cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cos_u10 with the same accuracy specification.
Vectorized single precision cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosf_u10 with the same accuracy specification.
Vectorized double precision cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cos_u35 with the same accuracy specification.
Vectorized single precision cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosf_u35 with the same accuracy specification.
Vectorized single precision combined sine and cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincos_u10 with the same accuracy specification.
Vectorized single precision combined sine and cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincosf_u10 with the same accuracy specification.
Vectorized double precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincos_u35 with the same accuracy specification.
Vectorized single precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincosf_u35 with the same accuracy specification.
Vectorized double precision sine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinpi_u05 with the same accuracy specification.
Vectorized single precision sine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinpif_u05 with the same accuracy specification.
Vectorized double precision cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cospi_u05 with the same accuracy specification.
Vectorized single precision cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cospif_u05 with the same accuracy specification.
Vectorized double precision combined sine and cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospi_u05 with the same accuracy specification.
Vectorized single precision combined sine and cosine function with 0.506 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospif_u05 with the same accuracy specification.
Vectorized double precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospi_u35 with the same accuracy specification.
Vectorized single precision combined sine and cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sincospif_u35 with the same accuracy specification.
Vectorized double precision tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tan_u10 with the same accuracy specification.
Vectorized single precision tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanf_u10 with the same accuracy specification.
Vectorized double precision tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tan_u35 with the same accuracy specification.
Vectorized single precision tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanf_u35 with the same accuracy specification.
Vectorized double precision power function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_pow_u10 with the same accuracy specification.
Vectorized single precision power function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_powf_u10 with the same accuracy specification.
Vectorized double precision natural logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log_u10 with the same accuracy specification.
Vectorized single precision natural logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_logf_u10 with the same accuracy specification.
Vectorized double precision natural logarithmic function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log_u35 with the same accuracy specification.
Vectorized single precision natural logarithmic function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_logf_u35 with the same accuracy specification.
Vectorized double precision base-10 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log10_u10 with the same accuracy specification.
Vectorized single precision base-10 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log10f_u10 with the same accuracy specification.
Vectorized double precision base-2 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log2_u10 with the same accuracy specification.
Vectorized single precision base-2 logarithmic function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log2f_u10 with the same accuracy specification.
Vectorized double precision logarithm of one plus argument with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log1p_u10 with the same accuracy specification.
Vectorized single precision logarithm of one plus argument with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_log1pf_u10 with the same accuracy specification.
Vectorized double precision base-e exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp_u10 with the same accuracy specification.
Vectorized single precision base-e exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expf_u10 with the same accuracy specification.
Vectorized double precision base-2 exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp2_u10 with the same accuracy specification.
Vectorized single precision base-2 exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp2f_u10 with the same accuracy specification.
Vectorized double precision base-10 exponential function function with 1.09 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp10_u10 with the same accuracy specification.
Vectorized single precision base-10 exponential function function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_exp10f_u10 with the same accuracy specification.
Vectorized double precision base-e exponential function minus 1 with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expm1_u10 with the same accuracy specification.
Vectorized single precision base-e exponential function minus 1 with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expm1f_u10 with the same accuracy specification.
Vectorized double precision square root function with 0.5001 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrt_u05 with the same accuracy specification.
Vectorized single precision square root function with 0.5001 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrtf_u05 with the same accuracy specification.
Vectorized double precision square root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrt_u35 with the same accuracy specification.
Vectorized single precision square root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sqrtf_u35 with the same accuracy specification.
Vectorized double precision cubic root function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrt_u10 with the same accuracy specification.
Vectorized single precision cubic root function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrtf_u10 with the same accuracy specification.
Vectorized double precision cubic root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrt_u35 with the same accuracy specification.
Vectorized single precision cubic root function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cbrtf_u35 with the same accuracy specification.
Vectorized double precision 2D Euclidian distance function with 0.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypot_u05 with the same accuracy specification.
Vectorized single precision 2D Euclidian distance function with 0.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypotf_u05 with the same accuracy specification.
Vectorized double precision 2D Euclidian distance function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypot_u35 with the same accuracy specification.
Vectorized single precision 2D Euclidian distance function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_hypotf_u35 with the same accuracy specification.
Vectorized double precision arc sine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asin_u10 with the same accuracy specification.
Vectorized single precision arc sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinf_u10 with the same accuracy specification.
Vectorized double precision arc sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asin_u35 with the same accuracy specification.
Vectorized single precision arc sine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinf_u35 with the same accuracy specification.
Vectorized double precision arc cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acos_u10 with the same accuracy specification.
Vectorized single precision arc cosine function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acosf_u10 with the same accuracy specification.
Vectorized double precision arc cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acos_u35 with the same accuracy specification.
Vectorized single precision arc cosine function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acosf_u35 with the same accuracy specification.
Vectorized double precision arc tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan_u10 with the same accuracy specification.
Vectorized single precision arc tangent function with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanf_u10 with the same accuracy specification.
Vectorized double precision arc tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan_u35 with the same accuracy specification.
Vectorized single precision arc tangent function with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanf_u35 with the same accuracy specification.
Vectorized double precision arc tangent function of two variables with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2_u10 with the same accuracy specification.
Vectorized single precision arc tangent function of two variables with 1.0 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2f_u10 with the same accuracy specification.
Vectorized double precision arc tangent function of two variables with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2_u35 with the same accuracy specification.
Vectorized single precision arc tangent function of two variables with 3.5 ULP error bound Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atan2f_u35 with the same accuracy specification.
Vectorized double precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinh_u10 with the same accuracy specification.
Vectorized single precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinhf_u10 with the same accuracy specification.
Vectorized double precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinh_u35 with the same accuracy specification.
Vectorized single precision hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_sinhf_u35 with the same accuracy specification.
Vectorized double precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosh_u10 with the same accuracy specification.
Vectorized single precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_coshf_u10 with the same accuracy specification.
Vectorized double precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_cosh_u35 with the same accuracy specification.
Vectorized single precision hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_coshf_u35 with the same accuracy specification.
Vectorized double precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanh_u10 with the same accuracy specification.
Vectorized single precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanhf_u10 with the same accuracy specification.
Vectorized double precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanh_u35 with the same accuracy specification.
Vectorized single precision hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tanhf_u35 with the same accuracy specification.
Vectorized double precision inverse hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinh_u10 with the same accuracy specification.
Vectorized single precision inverse hyperbolic sine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_asinhf_u10 with the same accuracy specification.
Vectorized double precision inverse hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acosh_u10 with the same accuracy specification.
Vectorized single precision inverse hyperbolic cosine function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_acoshf_u10 with the same accuracy specification.
Vectorized double precision inverse hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanh_u10 with the same accuracy specification.
Vectorized single precision inverse hyperbolic tangent function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_atanhf_u10 with the same accuracy specification.
Vectorized double precision error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erf_u10 with the same accuracy specification.
Vectorized single precision error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erff_u10 with the same accuracy specification.
Vectorized double precision complementary error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erfc_u15 with the same accuracy specification.
Vectorized single precision complementary error function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_erfcf_u15 with the same accuracy specification.
Vectorized double precision gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tgamma_u10 with the same accuracy specification.
Vectorized single precision gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_tgammaf_u10 with the same accuracy specification.
Vectorized double precision log gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_lgamma_u10 with the same accuracy specification.
Vectorized single precision log gamma function Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_lgammaf_u10 with the same accuracy specification.
Vectorized double precision function for rounding to integer towards zero Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_trunc with the same accuracy specification.
Vectorized single precision function for rounding to integer towards zero Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_truncf with the same accuracy specification.
Vectorized double precision function for rounding to integer towards negative infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_floor with the same accuracy specification.
Vectorized single precision function for rounding to integer towards negative infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_floorf with the same accuracy specification.
Vectorized double precision function for rounding to integer towards positive infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_ceil with the same accuracy specification.
Vectorized single precision function for rounding to integer towards positive infinity Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_ceilf with the same accuracy specification.
Vectorized double precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_round with the same accuracy specification.
Vectorized single precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_roundf with the same accuracy specification.
Vectorized double precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_rint with the same accuracy specification.
Vectorized single precision function for rounding to nearest integer Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_rintf with the same accuracy specification.
Vectorized double precision function for fused multiply-accumulation Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fma with the same accuracy specification.
Vectorized single precision function for fused multiply-accumulation Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmaf with the same accuracy specification.
Vectorized double precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmod with the same accuracy specification.
Vectorized single precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmodf with the same accuracy specification.
Vectorized double precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_remainder with the same accuracy specification.
Vectorized single precision FP remainder Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_remainderf with the same accuracy specification.
Vectorized double precision function for multiplying by integral power of 2 Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_ldexp with the same accuracy specification.
Vectorized double precision function for obtaining fractional component of an FP number Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_frfrexp with the same accuracy specification.
Vectorized single precision function for obtaining fractional component of an FP number Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_frfrexpf with the same accuracy specification.
Vectorized double precision function for obtaining integral component of an FP number Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_expfrexp with the same accuracy specification.
Vectorized double precision function for getting integer exponent Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_ilogb with the same accuracy specification.
Vectorized double precision signed integral and fractional values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_modf with the same accuracy specification.
Vectorized single precision signed integral and fractional values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_modff with the same accuracy specification.
Vectorized double precision function for calculating the absolute value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fabs with the same accuracy specification.
Vectorized single precision function for calculating the absolute value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fabsf with the same accuracy specification.
Vectorized double precision function for copying signs Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_copysign with the same accuracy specification.
Vectorized single precision function for copying signs Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_copysignf with the same accuracy specification.
Vectorized double precision function for determining maximum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmax with the same accuracy specification.
Vectorized single precision function for determining maximum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmaxf with the same accuracy specification.
Vectorized double precision function for determining minimum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fmin with the same accuracy specification.
Vectorized single precision function for determining minimum of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fminf with the same accuracy specification.
Vectorized double precision function to calculate positive difference of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fdim with the same accuracy specification.
Vectorized single precision function to calculate positive difference of two values Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_fdimf with the same accuracy specification.
Vectorized double precision function for obtaining the next representable FP value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_nextafter with the same accuracy specification.
Vectorized single precision function for obtaining the next representable FP value Synopsis
#include <sleef.h> Description
This is the vectorized function of Sleef_nextafterf with the same accuracy specification.
Q1: Is the scalar functions in SLEEF faster than the
corresponding functions in the standard C library?
A1: No. Todays standard C libraries are very well optimized,
and there is small room for further optimization. The reason why
SLEEF is fast is that it carries out computation directly on SIMD
registers and ALUs. This is not simple as it sounds, because
conditional branches have to be eliminated in order to take full
advantage of SIMD computation. If the algorithm requires conditional
branches according to the argument, it must prepare for the case
where the elements in the input vector contain both values that
would make a branch happen and not happen. This would spoil the
advantage of SIMD computation, because each element in a vector
would require a different code path.
Q2: Do the trigonometric functions (e.g. sin) in SLEEF return
correct values for the whole range of inputs?
A2: Yes. SLEEF does implement a vectorized version of Payne
Hanek range reduction, and all the trigonometric functions return
a correct value with the specified accuracy.
The GNUABI version of the library (libsleefgnuabi.so) is built for
x86 and aarch64 architectectures. This library provides an API
compatible with libmvec in
glibc, and the API comforms to the x86
vector ABI, AArch64 vector
ABI and Power
Vector ABI. This library is built and installed by default, and
certain compilers call the functions in this library.
The dispatchers in SLEEF are designed to have very low overhead. This
overhead is so small and cannot be observed by microbenchmarking.
Fig. 7.1 shows a simplified code of our dispatcher. There is only
one exported function mainFunc. When
mainFunc is called for the first
time, dispatcherMain is called internally,
since funcPtr is initialized to the pointer to
dispatcherMain (line 14). It then detects if the
CPU supports SSE 4.1 (line 7), and
rewrites funcPtr to a pointer to the function
that utilizes SSE 4.1 or SSE 2, depending on the result of CPU
feature detection (line 10). When
mainFunc is called for the second time, it does
not execute the
dispatcherMain. It just executes the function
pointed by the pointer stored in funcPtr during
the execution of
dispatcherMain.
There are advantages in our dispatcher. The first advantage is that
it does not require any compiler-specific extension. The second
advantage is simplicity. There are only 18 lines of simple
code. Since the dispatchers are completely separated for each
function, there is not much room for bugs to get in.
The third advantage is low overhead. You might think that the
overhead is one function call including execution of the prologue
and the epilogue. However, modern compilers are smart enough to
eliminate redundant execution of the prologue, epilogue and return
instruction. The actual overhead is just one jmp instruction, which
has very small overhead since it is not conditional. This overhead
is likely hidden by out-of-order execution.
The fourth advantage is thread safety. There is only one variable
shared among threads, which is funcPtr. There are
only two possible values for this pointer variable. The first value
is the pointer to the dispatcherMain, and the
second value is the pointer to either funcSSE2
or funcSSE4, depending on the availability of
extensions. Once funcPtr is substituted with the
pointer to funcSSE2
or funcSSE4, it will not be changed in the
future. It should be easy to confirm that the code works in all the
cases.
Fig. 7.1: Simplified code of our dispatcher
ULP stands for "unit in the last place", which is sometimes used for
representing accuracy of calculation. 1 ULP is the distance between
the two closest floating point number, which depends on the exponent
of the FP number. The accuracy of calculation by reputable math
libraries is usually between 0.5 and 1 ULP. Here, the accuracy means
the largest error of calculation. SLEEF math library provides
multiple accuracy choices for most of the math functions. Many
functions have 3.5-ULP and 1-ULP versions, and 3.5-ULP versions are
faster than 1-ULP versions. If you care more about execution speed
than accuracy, it is advised to use the 3.5-ULP versions along with
-ffast-math or "unsafe math optimization" options for the compiler.
Note that 3.5 ULPs of error is small enough in many applications. If
you do not manage the error of computation by carefully ordering
floating point operations in your code, you would easily have that
amount of error in the computation results.
In IEEE 754 standard, underflow does not happen abruptly when the
exponent becomes zero. Instead, when a number to be represented is
smaller than a certain value, a denormal number is produced which
has less precision. This is sometimes called gradual underflow. On
some processor implementation, a flush-to-zero mode is used since it
is easier to implement by hardware. In flush-to-zero mode, numbers
smaller than the smallest normalized number are replaced with
zero. FP operations are not IEEE-754 conformant if a flush-to-zero
mode is used. A flush-to-zero mode influences the accuracy of
calculation in some cases. The smallest normalized precision number
can be referred with DBL_MIN for double precision, and FLT_MIN for
single precision. The naming of these macros is a little bit
confusing because DBL_MIN is not the smallest double precision
number.
You can see known maximum errors in math functions in glibc
at
this page.
In order to evaluate a trigonometric function with a large argument,
an argument reduction method is used to find an FP remainder of
dividing the argument x by π. We devised a
variation of the Payne-Hanek argument reduction method which is
suitable for vector computation. Fig. 7.2
shows an explanatory source
code for this method. See our paper for
the details.
Fig. 7.2: Explanatory source code for our modified Payne Hanek reduction method
It is a soup ladle. A sleef means a soup ladle in Dutch.
These graphs show comparison of the execution time between
SLEEF-3.2 compiled
with GCC-7.2 and Intel SVML included in Intel C Compiler 18.0.1.
The execution time of each function is measured by executing each
function 10^8 times and taking the average time. Each time a
function is executed, a uniformly distributed random number is set
to each element of the argument vector(each element is set a
different value.) The ranges of the random number for each
function are shown below. Argument vectors are generated before
the measurement, and the time to generate random argument vectors
is not included in the execution time.
The accuracy of SVML functions can be chosen by compiler options,
not the function names. "-fimf-max-error=1.0" option is specified
to icc to obtain the 1-ulp-accuracy results, and
"-fimf-max-error=5.0" option is used for the 5-ulp-accuracy
results.
Those results are measured on a PC with Intel Core i7-6700 CPU @
3.40GHz with Turbo Boost turned off. The CPU should be always
running at 3.4GHz during the measurement.
Click graphs to magnify.
In order to build SLEEF, you need CMake, which is an open-source and
cross-platform building tool. In order to test the library, it is
better to have the
GNU MPFR Library, Libssl and
FFTW.
CMake works by allowing the developer to specify build parameters and
rules in a simple text file that cmake then processes to generate
project files for the actual native build tools (e.g. UNIX Makefiles,
Microsoft Visual Studio, Apple XCode, etc). If you are not already
familiar with cmake, please refer to the
official documentation
or
the basic
introductions in the wiki.
1. Make sure cmake is available on the command-line. The command below
should display a version number greater than or equal to 3.5.1.
2. Checkout out the source code from our GitHub repository.
3. Make a separate directory to create an out-of-source build. SLEEF does not
allow for in-tree builds.
4. Run cmake to configure your project and generate the system to build it:
See the list of options and
variables for customizing your build.
5. Now that you have the build files created by cmake, proceed from the top
of the build directory:
6. You can execute the tests by running:
7. Install the library under ../my-sleef/install by running:
Below is the list of common cmake variables that are used to
configure a build for SLEEF.
Below is the list of SLEEF-specific cmake variables.
In order to build the library, you need to install OpenMP. In order
to test the library, you need to install libmpfr, libssl and
libfftw3. Availability of these libraries are checked upon execution
of cmake. Please change the directory to sleef-3.X and run the
following commands.
SLEEF Documentation - Math library reference (AArch32)
Table of contents
Data types for AArch32 architecture
typedef struct {
float32x4_t x, y;
} Sleef_float32x4_t_2;
Trigonometric Functions
float32x4_t Sleef_sinf4_u10(float32x4_t a);
float32x4_t Sleef_sinf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_sinf4_u35(float32x4_t a);
float32x4_t Sleef_sinf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_cosf4_u10(float32x4_t a);
float32x4_t Sleef_cosf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_cosf4_u35(float32x4_t a);
float32x4_t Sleef_cosf4_u35neon(float32x4_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_sincosf4_u10(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u10neon(float32x4_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_sincosf4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_sinpif4_u05(float32x4_t a);
float32x4_t Sleef_sinpif4_u05neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_cospif4_u05(float32x4_t a);
float32x4_t Sleef_cospif4_u05neon(float32x4_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_sincospif4_u05(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u05neon(float32x4_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_sincospif4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_tanf4_u10(float32x4_t a);
float32x4_t Sleef_tanf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_tanf4_u35(float32x4_t a);
float32x4_t Sleef_tanf4_u35neon(float32x4_t a);
Link with -lsleef.
Power, exponential, and logarithmic function
float32x4_t Sleef_powf4_u10(float32x4_t a, float32x4_t b);
float32x4_t Sleef_powf4_u10neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_logf4_u10(float32x4_t a);
float32x4_t Sleef_logf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_logf4_u35(float32x4_t a);
float32x4_t Sleef_logf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_log10f4_u10(float32x4_t a);
float32x4_t Sleef_log10f4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_log2f4_u10(float32x4_t a);
float32x4_t Sleef_log2f4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_log1pf4_u10(float32x4_t a);
float32x4_t Sleef_log1pf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_expf4_u10(float32x4_t a);
float32x4_t Sleef_expf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_exp2f4_u10(float32x4_t a);
float32x4_t Sleef_exp2f4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_exp10f4_u10(float32x4_t a);
float32x4_t Sleef_exp10f4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_expm1f4_u10(float32x4_t a);
float32x4_t Sleef_expm1f4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_sqrtf4(float32x4_t a);
float32x4_t Sleef_sqrtf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_sqrtf4_u35(float32x4_t a);
float32x4_t Sleef_sqrtf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_cbrtf4_u10(float32x4_t a);
float32x4_t Sleef_cbrtf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_cbrtf4_u35(float32x4_t a);
float32x4_t Sleef_cbrtf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_hypotf4_u05(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u05neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_hypotf4_u35(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u35neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
Inverse Trigonometric Functions
float32x4_t Sleef_asinf4_u10(float32x4_t a);
float32x4_t Sleef_asinf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_asinf4_u35(float32x4_t a);
float32x4_t Sleef_asinf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_acosf4_u10(float32x4_t a);
float32x4_t Sleef_acosf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_acosf4_u35(float32x4_t a);
float32x4_t Sleef_acosf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_atanf4_u10(float32x4_t a);
float32x4_t Sleef_atanf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_atanf4_u35(float32x4_t a);
float32x4_t Sleef_atanf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_atan2f4_u10(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u10neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_atan2f4_u35(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u35neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
Hyperbolic function and inverse hyperbolic function
float32x4_t Sleef_sinhf4_u10(float32x4_t a);
float32x4_t Sleef_sinhf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_sinhf4_u35(float32x4_t a);
float32x4_t Sleef_sinhf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_coshf4_u10(float32x4_t a);
float32x4_t Sleef_coshf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_coshf4_u35(float32x4_t a);
float32x4_t Sleef_coshf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_tanhf4_u10(float32x4_t a);
float32x4_t Sleef_tanhf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_tanhf4_u35(float32x4_t a);
float32x4_t Sleef_tanhf4_u35neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_asinhf4_u10(float32x4_t a);
float32x4_t Sleef_asinhf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_acoshf4_u10(float32x4_t a);
float32x4_t Sleef_acoshf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_atanhf4_u10(float32x4_t a);
float32x4_t Sleef_atanhf4_u10neon(float32x4_t a);
Link with -lsleef.
Error and gamma function
float32x4_t Sleef_erff4_u10(float32x4_t a);
float32x4_t Sleef_erff4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_erfcf4_u15(float32x4_t a);
float32x4_t Sleef_erfcf4_u15neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_tgammaf4_u10(float32x4_t a);
float32x4_t Sleef_tgammaf4_u10neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_lgammaf4_u10(float32x4_t a);
float32x4_t Sleef_lgammaf4_u10neon(float32x4_t a);
Link with -lsleef.
Nearest integer function
float32x4_t Sleef_truncf4(float32x4_t a);
float32x4_t Sleef_truncf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_floorf4(float32x4_t a);
float32x4_t Sleef_floorf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_ceilf4(float32x4_t a);
float32x4_t Sleef_ceilf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_roundf4(float32x4_t a);
float32x4_t Sleef_roundf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_rintf4(float32x4_t a);
float32x4_t Sleef_rintf4_neon(float32x4_t a);
Link with -lsleef.
Other function
float32x4_t Sleef_fmaf4(float32x4_t a, float32x4_t b, float32x4_t c);
float32x4_t Sleef_fmaf4_neon(float32x4_t a, float32x4_t b, float32x4_t c);
Link with -lsleef.
float32x4_t Sleef_fmodf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmodf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_remainderf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_remainderf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_frfrexpf4(float32x4_t a);
float32x4_t Sleef_frfrexpf4_neon(float32x4_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_modff4(float32x4_t a);
Sleef_float32x4_t_2 Sleef_modff4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_fabsf4(float32x4_t a);
float32x4_t Sleef_fabsf4_neon(float32x4_t a);
Link with -lsleef.
float32x4_t Sleef_copysignf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_copysignf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_fmaxf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmaxf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_fminf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fminf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_fdimf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fdimf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
float32x4_t Sleef_nextafterf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_nextafterf4_neon(float32x4_t a, float32x4_t b);
Link with -lsleef.
SLEEF Documentation - Math library reference (AArch64)
Table of contents
Data types for AArch64 architecture
typedef struct {
float32x4_t x, y;
} Sleef_float32x4_t_2;
typedef struct {
float64x2_t x, y;
} Sleef_float64x2_t_2;
typedef struct {
svfloat32_t x, y;
} Sleef_svfloat32_t_2;
typedef struct {
svfloat64_t x, y;
} Sleef_svfloat64_t_2;
Trigonometric Functions
double Sleef_sind1_u10purec(double a);
double Sleef_sind1_u10purecfma(double a);
double Sleef_cinz_sind1_u10purec(double a);
double Sleef_finz_sind1_u10purecfma(double a);
float64x2_t Sleef_sind2_u10(float64x2_t a);
float64x2_t Sleef_sind2_u10advsimd(float64x2_t a);
float64x2_t Sleef_sind2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sind2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sind2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_sindx_u10sve(svfloat64_t a);
svfloat64_t Sleef_sindx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sindx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sindx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sinf1_u10purec(float a);
float Sleef_sinf1_u10purecfma(float a);
float Sleef_cinz_sinf1_u10purec(float a);
float Sleef_finz_sinf1_u10purecfma(float a);
float32x4_t Sleef_sinf4_u10(float32x4_t a);
float32x4_t Sleef_sinf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_sinf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sinf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sinf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_sinfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_sinfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sinfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sinfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_sind1_u35purec(double a);
double Sleef_sind1_u35purecfma(double a);
double Sleef_cinz_sind1_u35purec(double a);
double Sleef_finz_sind1_u35purecfma(double a);
float64x2_t Sleef_sind2_u35(float64x2_t a);
float64x2_t Sleef_sind2_u35advsimd(float64x2_t a);
float64x2_t Sleef_sind2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sind2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sind2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_sindx_u35sve(svfloat64_t a);
svfloat64_t Sleef_sindx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sindx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sindx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sinf1_u35purec(float a);
float Sleef_sinf1_u35purecfma(float a);
float Sleef_cinz_sinf1_u35purec(float a);
float Sleef_finz_sinf1_u35purecfma(float a);
float32x4_t Sleef_sinf4_u35(float32x4_t a);
float32x4_t Sleef_sinf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_sinf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sinf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sinf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_sinfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_sinfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sinfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sinfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_cosd1_u10purec(double a);
double Sleef_cosd1_u10purecfma(double a);
double Sleef_cinz_cosd1_u10purec(double a);
double Sleef_finz_cosd1_u10purecfma(double a);
float64x2_t Sleef_cosd2_u10(float64x2_t a);
float64x2_t Sleef_cosd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_cosd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_cosd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_cosd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_cosdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_cosdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_cosdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_cosdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_cosf1_u10purec(float a);
float Sleef_cosf1_u10purecfma(float a);
float Sleef_cinz_cosf1_u10purec(float a);
float Sleef_finz_cosf1_u10purecfma(float a);
float32x4_t Sleef_cosf4_u10(float32x4_t a);
float32x4_t Sleef_cosf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_cosf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_cosf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_cosf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_cosfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_cosfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_cosfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_cosfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_cosd1_u35purec(double a);
double Sleef_cosd1_u35purecfma(double a);
double Sleef_cinz_cosd1_u35purec(double a);
double Sleef_finz_cosd1_u35purecfma(double a);
float64x2_t Sleef_cosd2_u35(float64x2_t a);
float64x2_t Sleef_cosd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_cosd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_cosd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_cosd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_cosdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_cosdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_cosdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_cosdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_cosf1_u35purec(float a);
float Sleef_cosf1_u35purecfma(float a);
float Sleef_cinz_cosf1_u35purec(float a);
float Sleef_finz_cosf1_u35purecfma(float a);
float32x4_t Sleef_cosf4_u35(float32x4_t a);
float32x4_t Sleef_cosf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_cosf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_cosf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_cosf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_cosfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_cosfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_cosfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_cosfx_u35sve(svfloat32_t a);
Link with -lsleef.
Sleef_double2 Sleef_sincosd1_u10purec(double a);
Sleef_double2 Sleef_sincosd1_u10purecfma(double a);
Sleef_double2 Sleef_cinz_sincosd1_u10purec(double a);
Sleef_double2 Sleef_finz_sincosd1_u10purecfma(double a);
Sleef_float64x2_t_2 Sleef_sincosd2_u10(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincosd2_u10advsimd(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincosd2_u10advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_cinz_sincosd2_u10advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_finz_sincosd2_u10advsimd(float64x2_t a);
Sleef_svfloat64_t_2 Sleef_sincosdx_u10sve(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_sincosdx_u10svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_cinz_sincosdx_u10svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_finz_sincosdx_u10sve(svfloat64_t a);
Link with -lsleef.
Sleef_float2 Sleef_sincosf1_u10purec(float a);
Sleef_float2 Sleef_sincosf1_u10purecfma(float a);
Sleef_float2 Sleef_cinz_sincosf1_u10purec(float a);
Sleef_float2 Sleef_finz_sincosf1_u10purecfma(float a);
Sleef_float32x4_t_2 Sleef_sincosf4_u10(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u10advsimd(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u10advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_cinz_sincosf4_u10advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_finz_sincosf4_u10advsimd(float32x4_t a);
Sleef_svfloat32_t_2 Sleef_sincosfx_u10sve(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_sincosfx_u10svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_cinz_sincosfx_u10svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_finz_sincosfx_u10sve(svfloat32_t a);
Link with -lsleef.
Sleef_double2 Sleef_sincosd1_u35purec(double a);
Sleef_double2 Sleef_sincosd1_u35purecfma(double a);
Sleef_double2 Sleef_cinz_sincosd1_u35purec(double a);
Sleef_double2 Sleef_finz_sincosd1_u35purecfma(double a);
Sleef_float64x2_t_2 Sleef_sincosd2_u35(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincosd2_u35advsimd(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincosd2_u35advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_cinz_sincosd2_u35advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_finz_sincosd2_u35advsimd(float64x2_t a);
Sleef_svfloat64_t_2 Sleef_sincosdx_u35sve(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_sincosdx_u35svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_cinz_sincosdx_u35svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_finz_sincosdx_u35sve(svfloat64_t a);
Link with -lsleef.
Sleef_float2 Sleef_sincosf1_u35purec(float a);
Sleef_float2 Sleef_sincosf1_u35purecfma(float a);
Sleef_float2 Sleef_cinz_sincosf1_u35purec(float a);
Sleef_float2 Sleef_finz_sincosf1_u35purecfma(float a);
Sleef_float32x4_t_2 Sleef_sincosf4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u35advsimd(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u35advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_cinz_sincosf4_u35advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_finz_sincosf4_u35advsimd(float32x4_t a);
Sleef_svfloat32_t_2 Sleef_sincosfx_u35sve(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_sincosfx_u35svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_cinz_sincosfx_u35svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_finz_sincosfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_sinpid1_u05purec(double a);
double Sleef_sinpid1_u05purecfma(double a);
double Sleef_cinz_sinpid1_u05purec(double a);
double Sleef_finz_sinpid1_u05purecfma(double a);
float64x2_t Sleef_sinpid2_u05(float64x2_t a);
float64x2_t Sleef_sinpid2_u05advsimd(float64x2_t a);
float64x2_t Sleef_sinpid2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sinpid2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sinpid2_u05advsimd(float64x2_t a);
svfloat64_t Sleef_sinpidx_u05sve(svfloat64_t a);
svfloat64_t Sleef_sinpidx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sinpidx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sinpidx_u05sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sinpif1_u05purec(float a);
float Sleef_sinpif1_u05purecfma(float a);
float Sleef_cinz_sinpif1_u05purec(float a);
float Sleef_finz_sinpif1_u05purecfma(float a);
float32x4_t Sleef_sinpif4_u05(float32x4_t a);
float32x4_t Sleef_sinpif4_u05advsimd(float32x4_t a);
float32x4_t Sleef_sinpif4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sinpif4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sinpif4_u05advsimd(float32x4_t a);
svfloat32_t Sleef_sinpifx_u05sve(svfloat32_t a);
svfloat32_t Sleef_sinpifx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sinpifx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sinpifx_u05sve(svfloat32_t a);
Link with -lsleef.
double Sleef_cospid1_u05purec(double a);
double Sleef_cospid1_u05purecfma(double a);
double Sleef_cinz_cospid1_u05purec(double a);
double Sleef_finz_cospid1_u05purecfma(double a);
float64x2_t Sleef_cospid2_u05(float64x2_t a);
float64x2_t Sleef_cospid2_u05advsimd(float64x2_t a);
float64x2_t Sleef_cospid2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_cospid2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_cospid2_u05advsimd(float64x2_t a);
svfloat64_t Sleef_cospidx_u05sve(svfloat64_t a);
svfloat64_t Sleef_cospidx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_cospidx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_cospidx_u05sve(svfloat64_t a);
Link with -lsleef.
float Sleef_cospif1_u05purec(float a);
float Sleef_cospif1_u05purecfma(float a);
float Sleef_cinz_cospif1_u05purec(float a);
float Sleef_finz_cospif1_u05purecfma(float a);
float32x4_t Sleef_cospif4_u05(float32x4_t a);
float32x4_t Sleef_cospif4_u05advsimd(float32x4_t a);
float32x4_t Sleef_cospif4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_cospif4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_cospif4_u05advsimd(float32x4_t a);
svfloat32_t Sleef_cospifx_u05sve(svfloat32_t a);
svfloat32_t Sleef_cospifx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_cospifx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_cospifx_u05sve(svfloat32_t a);
Link with -lsleef.
Sleef_double2 Sleef_sincospid1_u05purec(double a);
Sleef_double2 Sleef_sincospid1_u05purecfma(double a);
Sleef_double2 Sleef_cinz_sincospid1_u05purec(double a);
Sleef_double2 Sleef_finz_sincospid1_u05purecfma(double a);
Sleef_float64x2_t_2 Sleef_sincospid2_u05(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincospid2_u05advsimd(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincospid2_u05advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_cinz_sincospid2_u05advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_finz_sincospid2_u05advsimd(float64x2_t a);
Sleef_svfloat64_t_2 Sleef_sincospidx_u05sve(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_sincospidx_u05svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_cinz_sincospidx_u05svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_finz_sincospidx_u05sve(svfloat64_t a);
Link with -lsleef.
Sleef_float2 Sleef_sincospif1_u05purec(float a);
Sleef_float2 Sleef_sincospif1_u05purecfma(float a);
Sleef_float2 Sleef_cinz_sincospif1_u05purec(float a);
Sleef_float2 Sleef_finz_sincospif1_u05purecfma(float a);
Sleef_float32x4_t_2 Sleef_sincospif4_u05(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u05advsimd(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u05advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_cinz_sincospif4_u05advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_finz_sincospif4_u05advsimd(float32x4_t a);
Sleef_svfloat32_t_2 Sleef_sincospifx_u05sve(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_sincospifx_u05svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_cinz_sincospifx_u05svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_finz_sincospifx_u05sve(svfloat32_t a);
Link with -lsleef.
Sleef_double2 Sleef_sincospid1_u35purec(double a);
Sleef_double2 Sleef_sincospid1_u35purecfma(double a);
Sleef_double2 Sleef_cinz_sincospid1_u35purec(double a);
Sleef_double2 Sleef_finz_sincospid1_u35purecfma(double a);
Sleef_float64x2_t_2 Sleef_sincospid2_u35(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincospid2_u35advsimd(float64x2_t a);
Sleef_float64x2_t_2 Sleef_sincospid2_u35advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_cinz_sincospid2_u35advsimdnofma(float64x2_t a);
Sleef_float64x2_t_2 Sleef_finz_sincospid2_u35advsimd(float64x2_t a);
Sleef_svfloat64_t_2 Sleef_sincospidx_u35sve(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_sincospidx_u35svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_cinz_sincospidx_u35svenofma(svfloat64_t a);
Sleef_svfloat64_t_2 Sleef_finz_sincospidx_u35sve(svfloat64_t a);
Link with -lsleef.
Sleef_float2 Sleef_sincospif1_u35purec(float a);
Sleef_float2 Sleef_sincospif1_u35purecfma(float a);
Sleef_float2 Sleef_cinz_sincospif1_u35purec(float a);
Sleef_float2 Sleef_finz_sincospif1_u35purecfma(float a);
Sleef_float32x4_t_2 Sleef_sincospif4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u35advsimd(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u35advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_cinz_sincospif4_u35advsimdnofma(float32x4_t a);
Sleef_float32x4_t_2 Sleef_finz_sincospif4_u35advsimd(float32x4_t a);
Sleef_svfloat32_t_2 Sleef_sincospifx_u35sve(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_sincospifx_u35svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_cinz_sincospifx_u35svenofma(svfloat32_t a);
Sleef_svfloat32_t_2 Sleef_finz_sincospifx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_tand1_u10purec(double a);
double Sleef_tand1_u10purecfma(double a);
double Sleef_cinz_tand1_u10purec(double a);
double Sleef_finz_tand1_u10purecfma(double a);
float64x2_t Sleef_tand2_u10(float64x2_t a);
float64x2_t Sleef_tand2_u10advsimd(float64x2_t a);
float64x2_t Sleef_tand2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_tand2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_tand2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_tandx_u10sve(svfloat64_t a);
svfloat64_t Sleef_tandx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_tandx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_tandx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_tanf1_u10purec(float a);
float Sleef_tanf1_u10purecfma(float a);
float Sleef_cinz_tanf1_u10purec(float a);
float Sleef_finz_tanf1_u10purecfma(float a);
float32x4_t Sleef_tanf4_u10(float32x4_t a);
float32x4_t Sleef_tanf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_tanf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_tanf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_tanf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_tanfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_tanfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_tanfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_tanfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_tand1_u35purec(double a);
double Sleef_tand1_u35purecfma(double a);
double Sleef_cinz_tand1_u35purec(double a);
double Sleef_finz_tand1_u35purecfma(double a);
float64x2_t Sleef_tand2_u35(float64x2_t a);
float64x2_t Sleef_tand2_u35advsimd(float64x2_t a);
float64x2_t Sleef_tand2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_tand2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_tand2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_tandx_u35sve(svfloat64_t a);
svfloat64_t Sleef_tandx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_tandx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_tandx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_tanf1_u35purec(float a);
float Sleef_tanf1_u35purecfma(float a);
float Sleef_cinz_tanf1_u35purec(float a);
float Sleef_finz_tanf1_u35purecfma(float a);
float32x4_t Sleef_tanf4_u35(float32x4_t a);
float32x4_t Sleef_tanf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_tanf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_tanf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_tanf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_tanfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_tanfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_tanfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_tanfx_u35sve(svfloat32_t a);
Link with -lsleef.
Power, exponential, and logarithmic function
double Sleef_powd1_u10purec(double a, double b);
double Sleef_powd1_u10purecfma(double a, double b);
double Sleef_cinz_powd1_u10purec(double a, double b);
double Sleef_finz_powd1_u10purecfma(double a, double b);
float64x2_t Sleef_powd2_u10(float64x2_t a, float64x2_t b);
float64x2_t Sleef_powd2_u10advsimd(float64x2_t a, float64x2_t b);
float64x2_t Sleef_powd2_u10advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_cinz_powd2_u10advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_finz_powd2_u10advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_powdx_u10sve(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_powdx_u10svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_cinz_powdx_u10svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_finz_powdx_u10sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float Sleef_powf1_u10purec(float a, float b);
float Sleef_powf1_u10purecfma(float a, float b);
float Sleef_cinz_powf1_u10purec(float a, float b);
float Sleef_finz_powf1_u10purecfma(float a, float b);
float32x4_t Sleef_powf4_u10(float32x4_t a, float32x4_t b);
float32x4_t Sleef_powf4_u10advsimd(float32x4_t a, float32x4_t b);
float32x4_t Sleef_powf4_u10advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_cinz_powf4_u10advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_finz_powf4_u10advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_powfx_u10sve(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_powfx_u10svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_cinz_powfx_u10svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_finz_powfx_u10sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
double Sleef_logd1_u10purec(double a);
double Sleef_logd1_u10purecfma(double a);
double Sleef_cinz_logd1_u10purec(double a);
double Sleef_finz_logd1_u10purecfma(double a);
float64x2_t Sleef_logd2_u10(float64x2_t a);
float64x2_t Sleef_logd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_logd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_logd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_logd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_logdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_logdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_logdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_logdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_logf1_u10purec(float a);
float Sleef_logf1_u10purecfma(float a);
float Sleef_cinz_logf1_u10purec(float a);
float Sleef_finz_logf1_u10purecfma(float a);
float32x4_t Sleef_logf4_u10(float32x4_t a);
float32x4_t Sleef_logf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_logf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_logf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_logf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_logfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_logfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_logfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_logfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_logd1_u35purec(double a);
double Sleef_logd1_u35purecfma(double a);
double Sleef_cinz_logd1_u35purec(double a);
double Sleef_finz_logd1_u35purecfma(double a);
float64x2_t Sleef_logd2_u35(float64x2_t a);
float64x2_t Sleef_logd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_logd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_logd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_logd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_logdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_logdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_logdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_logdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_logf1_u35purec(float a);
float Sleef_logf1_u35purecfma(float a);
float Sleef_cinz_logf1_u35purec(float a);
float Sleef_finz_logf1_u35purecfma(float a);
float32x4_t Sleef_logf4_u35(float32x4_t a);
float32x4_t Sleef_logf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_logf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_logf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_logf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_logfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_logfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_logfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_logfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_log10d1_u10purec(double a);
double Sleef_log10d1_u10purecfma(double a);
double Sleef_cinz_log10d1_u10purec(double a);
double Sleef_finz_log10d1_u10purecfma(double a);
float64x2_t Sleef_log10d2_u10(float64x2_t a);
float64x2_t Sleef_log10d2_u10advsimd(float64x2_t a);
float64x2_t Sleef_log10d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_log10d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_log10d2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_log10dx_u10sve(svfloat64_t a);
svfloat64_t Sleef_log10dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_log10dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_log10dx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_log10f1_u10purec(float a);
float Sleef_log10f1_u10purecfma(float a);
float Sleef_cinz_log10f1_u10purec(float a);
float Sleef_finz_log10f1_u10purecfma(float a);
float32x4_t Sleef_log10f4_u10(float32x4_t a);
float32x4_t Sleef_log10f4_u10advsimd(float32x4_t a);
float32x4_t Sleef_log10f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_log10f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_log10f4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_log10fx_u10sve(svfloat32_t a);
svfloat32_t Sleef_log10fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_log10fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_log10fx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_log2d1_u10purec(double a);
double Sleef_log2d1_u10purecfma(double a);
double Sleef_cinz_log2d1_u10purec(double a);
double Sleef_finz_log2d1_u10purecfma(double a);
float64x2_t Sleef_log2d2_u10(float64x2_t a);
float64x2_t Sleef_log2d2_u10advsimd(float64x2_t a);
float64x2_t Sleef_log2d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_log2d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_log2d2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_log2dx_u10sve(svfloat64_t a);
svfloat64_t Sleef_log2dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_log2dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_log2dx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_log2f1_u10purec(float a);
float Sleef_log2f1_u10purecfma(float a);
float Sleef_cinz_log2f1_u10purec(float a);
float Sleef_finz_log2f1_u10purecfma(float a);
float32x4_t Sleef_log2f4_u10(float32x4_t a);
float32x4_t Sleef_log2f4_u10advsimd(float32x4_t a);
float32x4_t Sleef_log2f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_log2f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_log2f4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_log2fx_u10sve(svfloat32_t a);
svfloat32_t Sleef_log2fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_log2fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_log2fx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_log1pd1_u10purec(double a);
double Sleef_log1pd1_u10purecfma(double a);
double Sleef_cinz_log1pd1_u10purec(double a);
double Sleef_finz_log1pd1_u10purecfma(double a);
float64x2_t Sleef_log1pd2_u10(float64x2_t a);
float64x2_t Sleef_log1pd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_log1pd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_log1pd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_log1pd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_log1pdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_log1pdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_log1pdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_log1pdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_log1pf1_u10purec(float a);
float Sleef_log1pf1_u10purecfma(float a);
float Sleef_cinz_log1pf1_u10purec(float a);
float Sleef_finz_log1pf1_u10purecfma(float a);
float32x4_t Sleef_log1pf4_u10(float32x4_t a);
float32x4_t Sleef_log1pf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_log1pf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_log1pf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_log1pf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_log1pfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_log1pfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_log1pfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_log1pfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_expd1_u10purec(double a);
double Sleef_expd1_u10purecfma(double a);
double Sleef_cinz_expd1_u10purec(double a);
double Sleef_finz_expd1_u10purecfma(double a);
float64x2_t Sleef_expd2_u10(float64x2_t a);
float64x2_t Sleef_expd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_expd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_expd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_expd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_expdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_expdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_expdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_expdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_expf1_u10purec(float a);
float Sleef_expf1_u10purecfma(float a);
float Sleef_cinz_expf1_u10purec(float a);
float Sleef_finz_expf1_u10purecfma(float a);
float32x4_t Sleef_expf4_u10(float32x4_t a);
float32x4_t Sleef_expf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_expf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_expf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_expf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_expfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_expfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_expfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_expfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_exp2d1_u10purec(double a);
double Sleef_exp2d1_u10purecfma(double a);
double Sleef_cinz_exp2d1_u10purec(double a);
double Sleef_finz_exp2d1_u10purecfma(double a);
float64x2_t Sleef_exp2d2_u10(float64x2_t a);
float64x2_t Sleef_exp2d2_u10advsimd(float64x2_t a);
float64x2_t Sleef_exp2d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_exp2d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_exp2d2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_exp2dx_u10sve(svfloat64_t a);
svfloat64_t Sleef_exp2dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_exp2dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_exp2dx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_exp2f1_u10purec(float a);
float Sleef_exp2f1_u10purecfma(float a);
float Sleef_cinz_exp2f1_u10purec(float a);
float Sleef_finz_exp2f1_u10purecfma(float a);
float32x4_t Sleef_exp2f4_u10(float32x4_t a);
float32x4_t Sleef_exp2f4_u10advsimd(float32x4_t a);
float32x4_t Sleef_exp2f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_exp2f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_exp2f4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_exp2fx_u10sve(svfloat32_t a);
svfloat32_t Sleef_exp2fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_exp2fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_exp2fx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_exp10d1_u10purec(double a);
double Sleef_exp10d1_u10purecfma(double a);
double Sleef_cinz_exp10d1_u10purec(double a);
double Sleef_finz_exp10d1_u10purecfma(double a);
float64x2_t Sleef_exp10d2_u10(float64x2_t a);
float64x2_t Sleef_exp10d2_u10advsimd(float64x2_t a);
float64x2_t Sleef_exp10d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_exp10d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_exp10d2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_exp10dx_u10sve(svfloat64_t a);
svfloat64_t Sleef_exp10dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_exp10dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_exp10dx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_exp10f1_u10purec(float a);
float Sleef_exp10f1_u10purecfma(float a);
float Sleef_cinz_exp10f1_u10purec(float a);
float Sleef_finz_exp10f1_u10purecfma(float a);
float32x4_t Sleef_exp10f4_u10(float32x4_t a);
float32x4_t Sleef_exp10f4_u10advsimd(float32x4_t a);
float32x4_t Sleef_exp10f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_exp10f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_exp10f4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_exp10fx_u10sve(svfloat32_t a);
svfloat32_t Sleef_exp10fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_exp10fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_exp10fx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_expm1d1_u10purec(double a);
double Sleef_expm1d1_u10purecfma(double a);
double Sleef_cinz_expm1d1_u10purec(double a);
double Sleef_finz_expm1d1_u10purecfma(double a);
float64x2_t Sleef_expm1d2_u10(float64x2_t a);
float64x2_t Sleef_expm1d2_u10advsimd(float64x2_t a);
float64x2_t Sleef_expm1d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_expm1d2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_expm1d2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_expm1dx_u10sve(svfloat64_t a);
svfloat64_t Sleef_expm1dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_expm1dx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_expm1dx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_expm1f1_u10purec(float a);
float Sleef_expm1f1_u10purecfma(float a);
float Sleef_cinz_expm1f1_u10purec(float a);
float Sleef_finz_expm1f1_u10purecfma(float a);
float32x4_t Sleef_expm1f4_u10(float32x4_t a);
float32x4_t Sleef_expm1f4_u10advsimd(float32x4_t a);
float32x4_t Sleef_expm1f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_expm1f4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_expm1f4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_expm1fx_u10sve(svfloat32_t a);
svfloat32_t Sleef_expm1fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_expm1fx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_expm1fx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_sqrtd1_u05purec(double a);
double Sleef_sqrtd1_u05purecfma(double a);
double Sleef_cinz_sqrtd1_u05purec(double a);
double Sleef_finz_sqrtd1_u05purecfma(double a);
float64x2_t Sleef_sqrtd2_u05(float64x2_t a);
float64x2_t Sleef_sqrtd2_u05advsimd(float64x2_t a);
float64x2_t Sleef_sqrtd2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sqrtd2_u05advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sqrtd2_u05advsimd(float64x2_t a);
svfloat64_t Sleef_sqrtdx_u05sve(svfloat64_t a);
svfloat64_t Sleef_sqrtdx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sqrtdx_u05svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sqrtdx_u05sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sqrtf1_u05purec(float a);
float Sleef_sqrtf1_u05purecfma(float a);
float Sleef_cinz_sqrtf1_u05purec(float a);
float Sleef_finz_sqrtf1_u05purecfma(float a);
float32x4_t Sleef_sqrtf4_u05(float32x4_t a);
float32x4_t Sleef_sqrtf4_u05advsimd(float32x4_t a);
float32x4_t Sleef_sqrtf4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sqrtf4_u05advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sqrtf4_u05advsimd(float32x4_t a);
svfloat32_t Sleef_sqrtfx_u05sve(svfloat32_t a);
svfloat32_t Sleef_sqrtfx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sqrtfx_u05svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sqrtfx_u05sve(svfloat32_t a);
Link with -lsleef.
double Sleef_sqrtd1_u35purec(double a);
double Sleef_sqrtd1_u35purecfma(double a);
double Sleef_cinz_sqrtd1_u35purec(double a);
double Sleef_finz_sqrtd1_u35purecfma(double a);
float64x2_t Sleef_sqrtd2_u35(float64x2_t a);
float64x2_t Sleef_sqrtd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_sqrtd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sqrtd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sqrtd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_sqrtdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_sqrtdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sqrtdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sqrtdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sqrtf1_u35purec(float a);
float Sleef_sqrtf1_u35purecfma(float a);
float Sleef_cinz_sqrtf1_u35purec(float a);
float Sleef_finz_sqrtf1_u35purecfma(float a);
float32x4_t Sleef_sqrtf4_u35(float32x4_t a);
float32x4_t Sleef_sqrtf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_sqrtf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sqrtf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sqrtf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_sqrtfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_sqrtfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sqrtfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sqrtfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_cbrtd1_u10purec(double a);
double Sleef_cbrtd1_u10purecfma(double a);
double Sleef_cinz_cbrtd1_u10purec(double a);
double Sleef_finz_cbrtd1_u10purecfma(double a);
float64x2_t Sleef_cbrtd2_u10(float64x2_t a);
float64x2_t Sleef_cbrtd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_cbrtd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_cbrtd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_cbrtd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_cbrtdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_cbrtdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_cbrtdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_cbrtdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_cbrtf1_u10purec(float a);
float Sleef_cbrtf1_u10purecfma(float a);
float Sleef_cinz_cbrtf1_u10purec(float a);
float Sleef_finz_cbrtf1_u10purecfma(float a);
float32x4_t Sleef_cbrtf4_u10(float32x4_t a);
float32x4_t Sleef_cbrtf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_cbrtf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_cbrtf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_cbrtf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_cbrtfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_cbrtfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_cbrtfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_cbrtfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_cbrtd1_u35purec(double a);
double Sleef_cbrtd1_u35purecfma(double a);
double Sleef_cinz_cbrtd1_u35purec(double a);
double Sleef_finz_cbrtd1_u35purecfma(double a);
float64x2_t Sleef_cbrtd2_u35(float64x2_t a);
float64x2_t Sleef_cbrtd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_cbrtd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_cbrtd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_cbrtd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_cbrtdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_cbrtdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_cbrtdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_cbrtdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_cbrtf1_u35purec(float a);
float Sleef_cbrtf1_u35purecfma(float a);
float Sleef_cinz_cbrtf1_u35purec(float a);
float Sleef_finz_cbrtf1_u35purecfma(float a);
float32x4_t Sleef_cbrtf4_u35(float32x4_t a);
float32x4_t Sleef_cbrtf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_cbrtf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_cbrtf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_cbrtf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_cbrtfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_cbrtfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_cbrtfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_cbrtfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_hypotd1_u05purec(double a, double b);
double Sleef_hypotd1_u05purecfma(double a, double b);
double Sleef_cinz_hypotd1_u05purec(double a, double b);
double Sleef_finz_hypotd1_u05purecfma(double a, double b);
float64x2_t Sleef_hypotd2_u05(float64x2_t a, float64x2_t b);
float64x2_t Sleef_hypotd2_u05advsimd(float64x2_t a, float64x2_t b);
float64x2_t Sleef_hypotd2_u05advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_cinz_hypotd2_u05advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_finz_hypotd2_u05advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_hypotdx_u05sve(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_hypotdx_u05svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_cinz_hypotdx_u05svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_finz_hypotdx_u05sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float Sleef_hypotf1_u05purec(float a, float b);
float Sleef_hypotf1_u05purecfma(float a, float b);
float Sleef_cinz_hypotf1_u05purec(float a, float b);
float Sleef_finz_hypotf1_u05purecfma(float a, float b);
float32x4_t Sleef_hypotf4_u05(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u05advsimd(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u05advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_cinz_hypotf4_u05advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_finz_hypotf4_u05advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_hypotfx_u05sve(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_hypotfx_u05svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_cinz_hypotfx_u05svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_finz_hypotfx_u05sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
double Sleef_hypotd1_u35purec(double a, double b);
double Sleef_hypotd1_u35purecfma(double a, double b);
double Sleef_cinz_hypotd1_u35purec(double a, double b);
double Sleef_finz_hypotd1_u35purecfma(double a, double b);
float64x2_t Sleef_hypotd2_u35(float64x2_t a, float64x2_t b);
float64x2_t Sleef_hypotd2_u35advsimd(float64x2_t a, float64x2_t b);
float64x2_t Sleef_hypotd2_u35advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_cinz_hypotd2_u35advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_finz_hypotd2_u35advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_hypotdx_u35sve(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_hypotdx_u35svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_cinz_hypotdx_u35svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_finz_hypotdx_u35sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float Sleef_hypotf1_u35purec(float a, float b);
float Sleef_hypotf1_u35purecfma(float a, float b);
float Sleef_cinz_hypotf1_u35purec(float a, float b);
float Sleef_finz_hypotf1_u35purecfma(float a, float b);
float32x4_t Sleef_hypotf4_u35(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u35advsimd(float32x4_t a, float32x4_t b);
float32x4_t Sleef_hypotf4_u35advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_cinz_hypotf4_u35advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_finz_hypotf4_u35advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_hypotfx_u35sve(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_hypotfx_u35svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_cinz_hypotfx_u35svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_finz_hypotfx_u35sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
Inverse Trigonometric Functions
double Sleef_asind1_u10purec(double a);
double Sleef_asind1_u10purecfma(double a);
double Sleef_cinz_asind1_u10purec(double a);
double Sleef_finz_asind1_u10purecfma(double a);
float64x2_t Sleef_asind2_u10(float64x2_t a);
float64x2_t Sleef_asind2_u10advsimd(float64x2_t a);
float64x2_t Sleef_asind2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_asind2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_asind2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_asindx_u10sve(svfloat64_t a);
svfloat64_t Sleef_asindx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_asindx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_asindx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_asinf1_u10purec(float a);
float Sleef_asinf1_u10purecfma(float a);
float Sleef_cinz_asinf1_u10purec(float a);
float Sleef_finz_asinf1_u10purecfma(float a);
float32x4_t Sleef_asinf4_u10(float32x4_t a);
float32x4_t Sleef_asinf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_asinf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_asinf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_asinf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_asinfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_asinfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_asinfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_asinfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_asind1_u35purec(double a);
double Sleef_asind1_u35purecfma(double a);
double Sleef_cinz_asind1_u35purec(double a);
double Sleef_finz_asind1_u35purecfma(double a);
float64x2_t Sleef_asind2_u35(float64x2_t a);
float64x2_t Sleef_asind2_u35advsimd(float64x2_t a);
float64x2_t Sleef_asind2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_asind2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_asind2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_asindx_u35sve(svfloat64_t a);
svfloat64_t Sleef_asindx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_asindx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_asindx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_asinf1_u35purec(float a);
float Sleef_asinf1_u35purecfma(float a);
float Sleef_cinz_asinf1_u35purec(float a);
float Sleef_finz_asinf1_u35purecfma(float a);
float32x4_t Sleef_asinf4_u35(float32x4_t a);
float32x4_t Sleef_asinf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_asinf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_asinf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_asinf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_asinfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_asinfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_asinfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_asinfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_acosd1_u10purec(double a);
double Sleef_acosd1_u10purecfma(double a);
double Sleef_cinz_acosd1_u10purec(double a);
double Sleef_finz_acosd1_u10purecfma(double a);
float64x2_t Sleef_acosd2_u10(float64x2_t a);
float64x2_t Sleef_acosd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_acosd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_acosd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_acosd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_acosdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_acosdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_acosdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_acosdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_acosf1_u10purec(float a);
float Sleef_acosf1_u10purecfma(float a);
float Sleef_cinz_acosf1_u10purec(float a);
float Sleef_finz_acosf1_u10purecfma(float a);
float32x4_t Sleef_acosf4_u10(float32x4_t a);
float32x4_t Sleef_acosf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_acosf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_acosf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_acosf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_acosfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_acosfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_acosfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_acosfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_acosd1_u35purec(double a);
double Sleef_acosd1_u35purecfma(double a);
double Sleef_cinz_acosd1_u35purec(double a);
double Sleef_finz_acosd1_u35purecfma(double a);
float64x2_t Sleef_acosd2_u35(float64x2_t a);
float64x2_t Sleef_acosd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_acosd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_acosd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_acosd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_acosdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_acosdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_acosdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_acosdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_acosf1_u35purec(float a);
float Sleef_acosf1_u35purecfma(float a);
float Sleef_cinz_acosf1_u35purec(float a);
float Sleef_finz_acosf1_u35purecfma(float a);
float32x4_t Sleef_acosf4_u35(float32x4_t a);
float32x4_t Sleef_acosf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_acosf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_acosf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_acosf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_acosfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_acosfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_acosfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_acosfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_atand1_u10purec(double a);
double Sleef_atand1_u10purecfma(double a);
double Sleef_cinz_atand1_u10purec(double a);
double Sleef_finz_atand1_u10purecfma(double a);
float64x2_t Sleef_atand2_u10(float64x2_t a);
float64x2_t Sleef_atand2_u10advsimd(float64x2_t a);
float64x2_t Sleef_atand2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_atand2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_atand2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_atandx_u10sve(svfloat64_t a);
svfloat64_t Sleef_atandx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_atandx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_atandx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_atanf1_u10purec(float a);
float Sleef_atanf1_u10purecfma(float a);
float Sleef_cinz_atanf1_u10purec(float a);
float Sleef_finz_atanf1_u10purecfma(float a);
float32x4_t Sleef_atanf4_u10(float32x4_t a);
float32x4_t Sleef_atanf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_atanf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_atanf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_atanf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_atanfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_atanfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_atanfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_atanfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_atand1_u35purec(double a);
double Sleef_atand1_u35purecfma(double a);
double Sleef_cinz_atand1_u35purec(double a);
double Sleef_finz_atand1_u35purecfma(double a);
float64x2_t Sleef_atand2_u35(float64x2_t a);
float64x2_t Sleef_atand2_u35advsimd(float64x2_t a);
float64x2_t Sleef_atand2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_atand2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_atand2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_atandx_u35sve(svfloat64_t a);
svfloat64_t Sleef_atandx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_atandx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_atandx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_atanf1_u35purec(float a);
float Sleef_atanf1_u35purecfma(float a);
float Sleef_cinz_atanf1_u35purec(float a);
float Sleef_finz_atanf1_u35purecfma(float a);
float32x4_t Sleef_atanf4_u35(float32x4_t a);
float32x4_t Sleef_atanf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_atanf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_atanf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_atanf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_atanfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_atanfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_atanfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_atanfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_atan2d1_u10purec(double a, double b);
double Sleef_atan2d1_u10purecfma(double a, double b);
double Sleef_cinz_atan2d1_u10purec(double a, double b);
double Sleef_finz_atan2d1_u10purecfma(double a, double b);
float64x2_t Sleef_atan2d2_u10(float64x2_t a, float64x2_t b);
float64x2_t Sleef_atan2d2_u10advsimd(float64x2_t a, float64x2_t b);
float64x2_t Sleef_atan2d2_u10advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_cinz_atan2d2_u10advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_finz_atan2d2_u10advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_atan2dx_u10sve(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_atan2dx_u10svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_cinz_atan2dx_u10svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_finz_atan2dx_u10sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float Sleef_atan2f1_u10purec(float a, float b);
float Sleef_atan2f1_u10purecfma(float a, float b);
float Sleef_cinz_atan2f1_u10purec(float a, float b);
float Sleef_finz_atan2f1_u10purecfma(float a, float b);
float32x4_t Sleef_atan2f4_u10(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u10advsimd(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u10advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_cinz_atan2f4_u10advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_finz_atan2f4_u10advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_atan2fx_u10sve(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_atan2fx_u10svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_cinz_atan2fx_u10svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_finz_atan2fx_u10sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
double Sleef_atan2d1_u35purec(double a, double b);
double Sleef_atan2d1_u35purecfma(double a, double b);
double Sleef_cinz_atan2d1_u35purec(double a, double b);
double Sleef_finz_atan2d1_u35purecfma(double a, double b);
float64x2_t Sleef_atan2d2_u35(float64x2_t a, float64x2_t b);
float64x2_t Sleef_atan2d2_u35advsimd(float64x2_t a, float64x2_t b);
float64x2_t Sleef_atan2d2_u35advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_cinz_atan2d2_u35advsimdnofma(float64x2_t a, float64x2_t b);
float64x2_t Sleef_finz_atan2d2_u35advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_atan2dx_u35sve(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_atan2dx_u35svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_cinz_atan2dx_u35svenofma(svfloat64_t a, svfloat64_t b);
svfloat64_t Sleef_finz_atan2dx_u35sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float Sleef_atan2f1_u35purec(float a, float b);
float Sleef_atan2f1_u35purecfma(float a, float b);
float Sleef_cinz_atan2f1_u35purec(float a, float b);
float Sleef_finz_atan2f1_u35purecfma(float a, float b);
float32x4_t Sleef_atan2f4_u35(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u35advsimd(float32x4_t a, float32x4_t b);
float32x4_t Sleef_atan2f4_u35advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_cinz_atan2f4_u35advsimdnofma(float32x4_t a, float32x4_t b);
float32x4_t Sleef_finz_atan2f4_u35advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_atan2fx_u35sve(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_atan2fx_u35svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_cinz_atan2fx_u35svenofma(svfloat32_t a, svfloat32_t b);
svfloat32_t Sleef_finz_atan2fx_u35sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
Hyperbolic function and inverse hyperbolic function
double Sleef_sinhd1_u10purec(double a);
double Sleef_sinhd1_u10purecfma(double a);
double Sleef_cinz_sinhd1_u10purec(double a);
double Sleef_finz_sinhd1_u10purecfma(double a);
float64x2_t Sleef_sinhd2_u10(float64x2_t a);
float64x2_t Sleef_sinhd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_sinhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sinhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sinhd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_sinhdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_sinhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sinhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sinhdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sinhf1_u10purec(float a);
float Sleef_sinhf1_u10purecfma(float a);
float Sleef_cinz_sinhf1_u10purec(float a);
float Sleef_finz_sinhf1_u10purecfma(float a);
float32x4_t Sleef_sinhf4_u10(float32x4_t a);
float32x4_t Sleef_sinhf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_sinhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sinhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sinhf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_sinhfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_sinhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sinhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sinhfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_sinhd1_u35purec(double a);
double Sleef_sinhd1_u35purecfma(double a);
double Sleef_cinz_sinhd1_u35purec(double a);
double Sleef_finz_sinhd1_u35purecfma(double a);
float64x2_t Sleef_sinhd2_u35(float64x2_t a);
float64x2_t Sleef_sinhd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_sinhd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_sinhd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_sinhd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_sinhdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_sinhdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_sinhdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_sinhdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_sinhf1_u35purec(float a);
float Sleef_sinhf1_u35purecfma(float a);
float Sleef_cinz_sinhf1_u35purec(float a);
float Sleef_finz_sinhf1_u35purecfma(float a);
float32x4_t Sleef_sinhf4_u35(float32x4_t a);
float32x4_t Sleef_sinhf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_sinhf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_sinhf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_sinhf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_sinhfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_sinhfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_sinhfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_sinhfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_coshd1_u10purec(double a);
double Sleef_coshd1_u10purecfma(double a);
double Sleef_cinz_coshd1_u10purec(double a);
double Sleef_finz_coshd1_u10purecfma(double a);
float64x2_t Sleef_coshd2_u10(float64x2_t a);
float64x2_t Sleef_coshd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_coshd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_coshd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_coshd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_coshdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_coshdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_coshdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_coshdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_coshf1_u10purec(float a);
float Sleef_coshf1_u10purecfma(float a);
float Sleef_cinz_coshf1_u10purec(float a);
float Sleef_finz_coshf1_u10purecfma(float a);
float32x4_t Sleef_coshf4_u10(float32x4_t a);
float32x4_t Sleef_coshf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_coshf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_coshf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_coshf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_coshfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_coshfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_coshfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_coshfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_coshd1_u35purec(double a);
double Sleef_coshd1_u35purecfma(double a);
double Sleef_cinz_coshd1_u35purec(double a);
double Sleef_finz_coshd1_u35purecfma(double a);
float64x2_t Sleef_coshd2_u35(float64x2_t a);
float64x2_t Sleef_coshd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_coshd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_coshd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_coshd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_coshdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_coshdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_coshdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_coshdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_coshf1_u35purec(float a);
float Sleef_coshf1_u35purecfma(float a);
float Sleef_cinz_coshf1_u35purec(float a);
float Sleef_finz_coshf1_u35purecfma(float a);
float32x4_t Sleef_coshf4_u35(float32x4_t a);
float32x4_t Sleef_coshf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_coshf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_coshf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_coshf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_coshfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_coshfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_coshfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_coshfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_tanhd1_u10purec(double a);
double Sleef_tanhd1_u10purecfma(double a);
double Sleef_cinz_tanhd1_u10purec(double a);
double Sleef_finz_tanhd1_u10purecfma(double a);
float64x2_t Sleef_tanhd2_u10(float64x2_t a);
float64x2_t Sleef_tanhd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_tanhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_tanhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_tanhd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_tanhdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_tanhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_tanhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_tanhdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_tanhf1_u10purec(float a);
float Sleef_tanhf1_u10purecfma(float a);
float Sleef_cinz_tanhf1_u10purec(float a);
float Sleef_finz_tanhf1_u10purecfma(float a);
float32x4_t Sleef_tanhf4_u10(float32x4_t a);
float32x4_t Sleef_tanhf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_tanhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_tanhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_tanhf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_tanhfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_tanhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_tanhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_tanhfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_tanhd1_u35purec(double a);
double Sleef_tanhd1_u35purecfma(double a);
double Sleef_cinz_tanhd1_u35purec(double a);
double Sleef_finz_tanhd1_u35purecfma(double a);
float64x2_t Sleef_tanhd2_u35(float64x2_t a);
float64x2_t Sleef_tanhd2_u35advsimd(float64x2_t a);
float64x2_t Sleef_tanhd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_tanhd2_u35advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_tanhd2_u35advsimd(float64x2_t a);
svfloat64_t Sleef_tanhdx_u35sve(svfloat64_t a);
svfloat64_t Sleef_tanhdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_tanhdx_u35svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_tanhdx_u35sve(svfloat64_t a);
Link with -lsleef.
float Sleef_tanhf1_u35purec(float a);
float Sleef_tanhf1_u35purecfma(float a);
float Sleef_cinz_tanhf1_u35purec(float a);
float Sleef_finz_tanhf1_u35purecfma(float a);
float32x4_t Sleef_tanhf4_u35(float32x4_t a);
float32x4_t Sleef_tanhf4_u35advsimd(float32x4_t a);
float32x4_t Sleef_tanhf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_tanhf4_u35advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_tanhf4_u35advsimd(float32x4_t a);
svfloat32_t Sleef_tanhfx_u35sve(svfloat32_t a);
svfloat32_t Sleef_tanhfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_tanhfx_u35svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_tanhfx_u35sve(svfloat32_t a);
Link with -lsleef.
double Sleef_asinhd1_u10purec(double a);
double Sleef_asinhd1_u10purecfma(double a);
double Sleef_cinz_asinhd1_u10purec(double a);
double Sleef_finz_asinhd1_u10purecfma(double a);
float64x2_t Sleef_asinhd2_u10(float64x2_t a);
float64x2_t Sleef_asinhd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_asinhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_asinhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_asinhd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_asinhdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_asinhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_asinhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_asinhdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_asinhf1_u10purec(float a);
float Sleef_asinhf1_u10purecfma(float a);
float Sleef_cinz_asinhf1_u10purec(float a);
float Sleef_finz_asinhf1_u10purecfma(float a);
float32x4_t Sleef_asinhf4_u10(float32x4_t a);
float32x4_t Sleef_asinhf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_asinhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_asinhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_asinhf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_asinhfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_asinhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_asinhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_asinhfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_acoshd1_u10purec(double a);
double Sleef_acoshd1_u10purecfma(double a);
double Sleef_cinz_acoshd1_u10purec(double a);
double Sleef_finz_acoshd1_u10purecfma(double a);
float64x2_t Sleef_acoshd2_u10(float64x2_t a);
float64x2_t Sleef_acoshd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_acoshd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_acoshd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_acoshd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_acoshdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_acoshdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_acoshdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_acoshdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_acoshf1_u10purec(float a);
float Sleef_acoshf1_u10purecfma(float a);
float Sleef_cinz_acoshf1_u10purec(float a);
float Sleef_finz_acoshf1_u10purecfma(float a);
float32x4_t Sleef_acoshf4_u10(float32x4_t a);
float32x4_t Sleef_acoshf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_acoshf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_acoshf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_acoshf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_acoshfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_acoshfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_acoshfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_acoshfx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_atanhd1_u10purec(double a);
double Sleef_atanhd1_u10purecfma(double a);
double Sleef_cinz_atanhd1_u10purec(double a);
double Sleef_finz_atanhd1_u10purecfma(double a);
float64x2_t Sleef_atanhd2_u10(float64x2_t a);
float64x2_t Sleef_atanhd2_u10advsimd(float64x2_t a);
float64x2_t Sleef_atanhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_atanhd2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_atanhd2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_atanhdx_u10sve(svfloat64_t a);
svfloat64_t Sleef_atanhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_atanhdx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_atanhdx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_atanhf1_u10purec(float a);
float Sleef_atanhf1_u10purecfma(float a);
float Sleef_cinz_atanhf1_u10purec(float a);
float Sleef_finz_atanhf1_u10purecfma(float a);
float32x4_t Sleef_atanhf4_u10(float32x4_t a);
float32x4_t Sleef_atanhf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_atanhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_atanhf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_atanhf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_atanhfx_u10sve(svfloat32_t a);
svfloat32_t Sleef_atanhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_atanhfx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_atanhfx_u10sve(svfloat32_t a);
Link with -lsleef.
Error and gamma function
float Sleef_erfd1_u10purec(float a);
float Sleef_erfd1_u10purecfma(float a);
float Sleef_cinz_erfd1_u10purec(float a);
float Sleef_finz_erfd1_u10purecfma(float a);
(SP2) Sleef_erfd2_u10((SP2) a);
(SP2) Sleef_erfd2_u10advsimd((SP2) a);
(SP2) Sleef_erfd2_u10advsimdnofma((SP2) a);
(SP2) Sleef_cinz_erfd2_u10advsimdnofma((SP2) a);
(SP2) Sleef_finz_erfd2_u10advsimd((SP2) a);
svfloat32_t Sleef_erfdx_u10sve(svfloat32_t a);
svfloat32_t Sleef_erfdx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_erfdx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_erfdx_u10sve(svfloat32_t a);
Link with -lsleef.
float Sleef_erff1_u10purec(float a);
float Sleef_erff1_u10purecfma(float a);
float Sleef_cinz_erff1_u10purec(float a);
float Sleef_finz_erff1_u10purecfma(float a);
float32x4_t Sleef_erff4_u10(float32x4_t a);
float32x4_t Sleef_erff4_u10advsimd(float32x4_t a);
float32x4_t Sleef_erff4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_erff4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_erff4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_erffx_u10sve(svfloat32_t a);
svfloat32_t Sleef_erffx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_erffx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_erffx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_erfcd1_u15purec(double a);
double Sleef_erfcd1_u15purecfma(double a);
double Sleef_cinz_erfcd1_u15purec(double a);
double Sleef_finz_erfcd1_u15purecfma(double a);
float64x2_t Sleef_erfcd2_u15(float64x2_t a);
float64x2_t Sleef_erfcd2_u15advsimd(float64x2_t a);
float64x2_t Sleef_erfcd2_u15advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_erfcd2_u15advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_erfcd2_u15advsimd(float64x2_t a);
svfloat64_t Sleef_erfcdx_u15sve(svfloat64_t a);
svfloat64_t Sleef_erfcdx_u15svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_erfcdx_u15svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_erfcdx_u15sve(svfloat64_t a);
Link with -lsleef.
float Sleef_erfcf1_u15purec(float a);
float Sleef_erfcf1_u15purecfma(float a);
float Sleef_cinz_erfcf1_u15purec(float a);
float Sleef_finz_erfcf1_u15purecfma(float a);
float32x4_t Sleef_erfcf4_u15(float32x4_t a);
float32x4_t Sleef_erfcf4_u15advsimd(float32x4_t a);
float32x4_t Sleef_erfcf4_u15advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_erfcf4_u15advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_erfcf4_u15advsimd(float32x4_t a);
svfloat32_t Sleef_erfcfx_u15sve(svfloat32_t a);
svfloat32_t Sleef_erfcfx_u15svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_erfcfx_u15svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_erfcfx_u15sve(svfloat32_t a);
Link with -lsleef.
double Sleef_tgammad1_u10purec(double a);
double Sleef_tgammad1_u10purecfma(double a);
double Sleef_cinz_tgammad1_u10purec(double a);
double Sleef_finz_tgammad1_u10purecfma(double a);
float64x2_t Sleef_tgammad2_u10(float64x2_t a);
float64x2_t Sleef_tgammad2_u10advsimd(float64x2_t a);
float64x2_t Sleef_tgammad2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_tgammad2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_tgammad2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_tgammadx_u10sve(svfloat64_t a);
svfloat64_t Sleef_tgammadx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_tgammadx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_tgammadx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_tgammaf1_u10purec(float a);
float Sleef_tgammaf1_u10purecfma(float a);
float Sleef_cinz_tgammaf1_u10purec(float a);
float Sleef_finz_tgammaf1_u10purecfma(float a);
float32x4_t Sleef_tgammaf4_u10(float32x4_t a);
float32x4_t Sleef_tgammaf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_tgammaf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_tgammaf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_tgammaf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_tgammafx_u10sve(svfloat32_t a);
svfloat32_t Sleef_tgammafx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_tgammafx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_tgammafx_u10sve(svfloat32_t a);
Link with -lsleef.
double Sleef_lgammad1_u10purec(double a);
double Sleef_lgammad1_u10purecfma(double a);
double Sleef_cinz_lgammad1_u10purec(double a);
double Sleef_finz_lgammad1_u10purecfma(double a);
float64x2_t Sleef_lgammad2_u10(float64x2_t a);
float64x2_t Sleef_lgammad2_u10advsimd(float64x2_t a);
float64x2_t Sleef_lgammad2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_cinz_lgammad2_u10advsimdnofma(float64x2_t a);
float64x2_t Sleef_finz_lgammad2_u10advsimd(float64x2_t a);
svfloat64_t Sleef_lgammadx_u10sve(svfloat64_t a);
svfloat64_t Sleef_lgammadx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_cinz_lgammadx_u10svenofma(svfloat64_t a);
svfloat64_t Sleef_finz_lgammadx_u10sve(svfloat64_t a);
Link with -lsleef.
float Sleef_lgammaf1_u10purec(float a);
float Sleef_lgammaf1_u10purecfma(float a);
float Sleef_cinz_lgammaf1_u10purec(float a);
float Sleef_finz_lgammaf1_u10purecfma(float a);
float32x4_t Sleef_lgammaf4_u10(float32x4_t a);
float32x4_t Sleef_lgammaf4_u10advsimd(float32x4_t a);
float32x4_t Sleef_lgammaf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_cinz_lgammaf4_u10advsimdnofma(float32x4_t a);
float32x4_t Sleef_finz_lgammaf4_u10advsimd(float32x4_t a);
svfloat32_t Sleef_lgammafx_u10sve(svfloat32_t a);
svfloat32_t Sleef_lgammafx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_cinz_lgammafx_u10svenofma(svfloat32_t a);
svfloat32_t Sleef_finz_lgammafx_u10sve(svfloat32_t a);
Link with -lsleef.
Nearest integer function
float64x2_t Sleef_truncd2(float64x2_t a);
float64x2_t Sleef_truncd2_advsimd(float64x2_t a);
svfloat64_t Sleef_truncdx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_truncf4(float32x4_t a);
float32x4_t Sleef_truncf4_advsimd(float32x4_t a);
svfloat32_t Sleef_truncfx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_floord2(float64x2_t a);
float64x2_t Sleef_floord2_advsimd(float64x2_t a);
svfloat64_t Sleef_floordx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_floorf4(float32x4_t a);
float32x4_t Sleef_floorf4_advsimd(float32x4_t a);
svfloat32_t Sleef_floorfx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_ceild2(float64x2_t a);
float64x2_t Sleef_ceild2_advsimd(float64x2_t a);
svfloat64_t Sleef_ceildx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_ceilf4(float32x4_t a);
float32x4_t Sleef_ceilf4_advsimd(float32x4_t a);
svfloat32_t Sleef_ceilfx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_roundd2(float64x2_t a);
float64x2_t Sleef_roundd2_advsimd(float64x2_t a);
svfloat64_t Sleef_rounddx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_roundf4(float32x4_t a);
float32x4_t Sleef_roundf4_advsimd(float32x4_t a);
svfloat32_t Sleef_roundfx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_rintd2(float64x2_t a);
float64x2_t Sleef_rintd2_advsimd(float64x2_t a);
svfloat64_t Sleef_rintdx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_rintf4(float32x4_t a);
float32x4_t Sleef_rintf4_advsimd(float32x4_t a);
svfloat32_t Sleef_rintfx_sve(svfloat32_t a);
Link with -lsleef.
Other function
float64x2_t Sleef_fmad2(float64x2_t a, float64x2_t b, float64x2_t c);
float64x2_t Sleef_fmad2_advsimd(float64x2_t a, float64x2_t b, float64x2_t c);
svfloat64_t Sleef_fmadx_sve(svfloat64_t a, svfloat64_t b, svfloat64_t c);
Link with -lsleef.
float32x4_t Sleef_fmaf4(float32x4_t a, float32x4_t b, float32x4_t c);
float32x4_t Sleef_fmaf4_advsimd(float32x4_t a, float32x4_t b, svfloat32_t c);
svfloat32_t Sleef_fmafx_sve(svfloat32_t a, svfloat32_t b, svfloat32_t c);
Link with -lsleef.
float64x2_t Sleef_fmodd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_fmodd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_fmoddx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_fmodf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmodf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_fmodfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_remainderd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_remainderd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_remainderdx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_remainderf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_remainderf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_remainderfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_ldexpd2(float64x2_t a, int32x2_t b);
float64x2_t Sleef_ldexpd2_advsimd(float64x2_t a, int32x2_t b);
svfloat64_t Sleef_ldexpdx_sve(svfloat64_t a, svint32_t b);
Link with -lsleef.
float64x2_t Sleef_frfrexpd2(float64x2_t a);
float64x2_t Sleef_frfrexpd2_advsimd(float64x2_t a);
svfloat64_t Sleef_frfrexpdx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_frfrexpf4(float32x4_t a);
float32x4_t Sleef_frfrexpf4_advsimd(float32x4_t a);
svfloat32_t Sleef_frfrexpfx_sve(svfloat32_t a);
Link with -lsleef.
int32x2_t Sleef_expfrexpd2(float64x2_t a);
int32x2_t Sleef_expfrexpd2_advsimd(float64x2_t a);
svint32_t Sleef_expfrexpdx_sve(svfloat64_t a);
Link with -lsleef.
int32x2_t Sleef_ilogbd2(float64x2_t a);
int32x2_t Sleef_ilogbd2_advsimd(float64x2_t a);
svint32_t Sleef_ilogbdx_sve(svfloat64_t a);
Link with -lsleef.
Sleef_float64x2_t_2 Sleef_modfd2(float64x2_t a);
Sleef_float64x2_t_2 Sleef_modfd2_advsimd(float64x2_t a);
Sleef_svfloat64_t_2 Sleef_modfdx_sve(svfloat64_t a);
Link with -lsleef.
Sleef_float32x4_t_2 Sleef_modff4(float32x4_t a);
Sleef_float32x4_t_2 Sleef_modff4_advsimd(float32x4_t a);
Sleef_svfloat32_t_2 Sleef_modffx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_fabsd2(float64x2_t a);
float64x2_t Sleef_fabsd2_advsimd(float64x2_t a);
svfloat64_t Sleef_fabsdx_sve(svfloat64_t a);
Link with -lsleef.
float32x4_t Sleef_fabsf4(float32x4_t a);
float32x4_t Sleef_fabsf4_advsimd(float32x4_t a);
svfloat32_t Sleef_fabsfx_sve(svfloat32_t a);
Link with -lsleef.
float64x2_t Sleef_copysignd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_copysignd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_copysigndx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_copysignf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_copysignf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_copysignfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_fmaxd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_fmaxd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_fmaxdx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_fmaxf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmaxf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_fmaxfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_fmind2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_fmind2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_fmindx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_fminf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fminf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_fminfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_fdimd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_fdimd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_fdimdx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_fdimf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fdimf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_fdimfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
float64x2_t Sleef_nextafterd2(float64x2_t a, float64x2_t b);
float64x2_t Sleef_nextafterd2_advsimd(float64x2_t a, float64x2_t b);
svfloat64_t Sleef_nextafterdx_sve(svfloat64_t a, svfloat64_t b);
Link with -lsleef.
float32x4_t Sleef_nextafterf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_nextafterf4_advsimd(float32x4_t a, float32x4_t b);
svfloat32_t Sleef_nextafterfx_sve(svfloat32_t a, svfloat32_t b);
Link with -lsleef.
SLEEF Documentation - Additional Notes
Table of contents
Frequently asked questions
About the GNUABI version of the library
How the dispatchers work
static double (*funcPtr)(double arg);
static double dispatcherMain(double arg) {
double (*p)(double arg) = funcSSE2;
#if the compiler supports SSE4.1
if (SSE4.1 is available on the CPU) p = funcSSE4;
#endif
funcPtr = p;
return (*funcPtr)(arg);
}
static double (*funcPtr)(double arg) = dispatcherMain;
double mainFunc(double arg) {
return (*funcPtr)(arg);
}
ULP, gradual underflow and flush-to-zero mode
Explanatory source code for our modified Payne Hanek reduction method
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <mpfr.h>
typedef struct { double x, y; } double2;
double2 dd(double d) { double2 r = { d, 0 }; return r; }
int64_t d2i(double d) { union { double f; int64_t i; } tmp = {.f = d }; return tmp.i; }
double i2d(int64_t i) { union { double f; int64_t i; } tmp = {.i = i }; return tmp.f; }
double upper(double d) { return i2d(d2i(d) & 0xfffffffff8000000LL); }
double clearlsb(double d) { return i2d(d2i(d) & 0xfffffffffffffffeLL); }
double2 ddrenormalize(double2 t) {
double2 s = dd(t.x + t.y);
s.y = t.x - s.x + t.y;
return s;
}
double2 ddadd(double2 x, double2 y) {
double2 r = dd(x.x + y.x);
double v = r.x - x.x;
r.y = (x.x - (r.x - v)) + (y.x - v) + (x.y + y.y);
return r;
}
double2 ddmul(double x, double y) {
double2 r = dd(x * y);
r.y = fma(x, y, -r.x);
return r;
}
double2 ddmul2(double2 x, double2 y) {
double2 r = ddmul(x.x, y.x);
r.y += x.x * y.y + x.y * y.x;
return r;
}
// This function computes remainder(a, PI/2)
double2 modifiedPayneHanek(double a) {
double table[4];
int scale = fabs(a) > 1e+200 ? -128 : 0;
a = ldexp(a, scale);
// Table genration
mpfr_set_default_prec(2048);
mpfr_t pi, m;
mpfr_inits(pi, m, NULL);
mpfr_const_pi(pi, GMP_RNDN);
mpfr_d_div(m, 2, pi, GMP_RNDN);
mpfr_set_exp(m, mpfr_get_exp(m) + (ilogb(a) - 53 - scale));
mpfr_frac(m, m, GMP_RNDN);
mpfr_set_exp(m, mpfr_get_exp(m) - (ilogb(a) - 53));
for(int i=0;i<4;i++) {
table[i] = clearlsb(mpfr_get_d(m, GMP_RNDN));
mpfr_sub_d(m, m, table[i], GMP_RNDN);
}
mpfr_clears(pi, m, NULL);
// Main computation
double2 x = dd(0);
for(int i=0;i<4;i++) {
x = ddadd(x, ddmul(a, table[i]));
x.x = x.x - round(x.x);
x = ddrenormalize(x);
}
double2 pio2 = { 3.141592653589793*0.5, 1.2246467991473532e-16*0.5 };
x = ddmul2(x, pio2);
return fabs(a) < 0.785398163397448279 ? dd(a) : x;
}
About the logo
sleef-3.5.1/doc/html/apple-touch-icon.png 0000664 0000000 0000000 00000004332 13730031441 0020202 0 ustar 00root root 0000000 0000000 ‰PNG
IHDR hÿ‹ pHYs 5Ô 5Ô^eå PLTEþþþ•••¼¼¼oooÞÞÞIII¨¨¨5r! hIDATx^í™»w²JÆ7È@+j¤Œ¡UñÒb$¦ˆ˜_Ô´B.þûßÃ0ÄKâûIqÖYç)Èà·ž}™
&pQÿ Ùf5 EbàòÇðÿäÈvb¤ÂÞÌuß´-(;¢-¡†6_z°âËuáÀNt«°Ô7>ÜxRìºã§DW»9šÐΖ;×`I~±£¿" ä“r=€ÀÈ®»¦wr@“€`倣ìzC’)èÐ &•$ ˆ]ÈUË@i⨸ à Ûvtý c=Î(hv‚X€:$å ”ƒòhf à,¨#@ª Á°ˆÌÒõ¤ e'ÕÁ9¢—3`êòÈìäÈ íH©äŽÐ€ƒî‹š¥ÄsäéÊ<Õ¼¤h&jf뺡EÕéô.@j äB™CA¢HËíÏ€d· ¡™ -ó‹OQr\¢ú1ˆˆälÉA´ÇydºŽ«I=á#Ðй£±??"G'j€Ð!mOBC±ÈQG„¦¸¥ÈˆL(é…$üRN’½phÍô¢f"O—Ê/Ÿ–_Ô,Ñï šä—àt¾!2< q>7ÌT3ˆÞ”ƒ€õ¹‹cC€ÜŒ”5( À+0$@±14É® ÅeG²0$@l܈ª)¤Ž)h˜{â©¶ò’ P[<â‡÷Ôã³Jc“µVÉvšÚCI®Ûǰ¤ˆW×ý†÷®K,ãn~¸c@×m„¡»&m·?<ÕVÞÔBãw¼£º\r±\8 ÇAžj>Ñ„ºð2ßÜe§¹Äª‹b
2=šeC·Š”Œ•þñ¡OK_‘!£
C +ýZØù7
1CfE†>+2”âjÝJI
•:g3Î7Ýr{¡“T·ÏrÖso6\º&Ô†ÚΣóvht¾ÃjœÍ´ºW<5‚™ÌaåÔê !Œ.ºéZyJÓø„ú
›(…0솆.•^b § jQì2¼ƒa;Zm&_+¯³ŽÑ†¿W;K?c
ÚIËg ²A_Š>[ZO‰îæà±Ú;˽ˆšu–
s$@;)ôÕS<º{fèà4.m²zT{c –#“ƒÚ¯¤N13”&6\P€åÌ‘ÒË@R”¶sÀù0Ñ(HîsC©yôöe¾÷¥q×ûêËñÔ€æº=ŠÍñ½·šÀ®Õ_
¶ÌÐá§M&›†(„ìÐEˆCÜíÒ&qvÎc»ãÖ]/L6ªoÝõRŸê
ÆP5† ®3„+2ô1¸Ö
? õÌ+'cãçµèÊQmül¾†æÇ3´îë¿dÈJq.m¥HwZÑ/†~-½ÕöZ/À?gˆ–þw)~!VúëÝj¤H!9
ð†`¹†ÖæO·úÕP’+2²ÿQ†PUZü[
AU†d:«‰,5+Ju5†^飣
ÙV5©F©Ñý‡E–¤•päT¯*2Wr*Š¥ú¾šU™4ª‰ÌÖ?+ŠL¯¦Ö?,E²ÜÁ‰|Õkub™H‘äë>0uêÀ%õ.@œD':ty7:zAÝA¯Uò…‰³$dµ¦:A–néÀ5™ß_Ï£ª]¨¨åû¾Î•bpt=i”@ž²ÖÞîÛ¦êÍÂîÛx¶yˆü¯ÚBŽî·H¨”ëY;Bð|ú"˜X+^Í”{J¤zs¹œª×T÷§þ1©.-"˜k8\P€ðCÄ@Š×.ƒdÝ8Ú˜8XÂCB,Ôp¾>
Ъ%.‹€Š\™%òÔ7˜HÌ(^‚£ét*Q}‡+OëÁp9R=õiÖí?lkÚˆä(
Æ„¡ àÒ2{&ÜßÖš¾ìï?òó‹ñÒ°î>3LH/ƒÄÚ€k4€iG F’ÿ¼
4·§EdSrS ”:ôغ„ÄoËÿ²í4ýÛ!"·üi94ö“t÷— MoùßAŽõ
„‚¶÷;Hâ»L8úúê·Jôû_|ߟ~9$Øã)(À§ ©ÿìœÕdáE÷€€x6Ð{
‰)wmÛ¸ µží¤¢ŸühE@êç۪ߜ6Í•=
ÖÍn³¡~´a<Ã4%¹þrhÏAØ€¾ ÑTŸÒiD¿»ªx
ƒEmŸýØ"7[å>:õšù¾QÐÎf Hú0 g<àŽèÍ¥$¥' ”hÀ@k
öÄ Á¾H6Û…9È •u°Æ@sxU3Ð;PÄÅž¥#ͰZ›´;æ}4ôw«4|\MVƒÎVÝ<=üyßÖ6Ázn1|ˆ-’Å–ˆæ&qR|Wx´À€}B.”°ØŽ˜#dÀUz¬—ÅbKI@B¾åžÝˆåkO©r¬ÿV^+a‰Uÿo%'|‹ Kd à¿!«å³>ä=pšk™?æ~|§y%µÎ7«ˆì(×ÍîʃB
–ëgcósK–ˆÌ„oê`$n½øNÃb3RÛ9‰L€>•í}´šî°ì?‘wùòº½Eþô86çðÈÈØ¢‘Ö“FªàI`J½šàyØWêK(„Xlº‘çÈ?YÇf ˆÎ§ÀÔzMP=6ÊŸ¤[”ìô™ÖÁ]ÚPP›`6²%ö$)™§ (1Ð;¨uÒ
eKänáèÌww‚ž,GÔÚÖS÷<‡j>@IÈÑK–Nÿ[E*ðõ8]>ß?Êó½¶Y>#ÿIömßiÝì®Û¾‚ çºp“Ã6oÂBûp°»þúB©2*wÒÃÇ IEND®B`‚ sleef-3.5.1/doc/html/benchmark.xhtml 0000664 0000000 0000000 00000012131 13730031441 0017331 0 ustar 00root root 0000000 0000000
SLEEF Documentation - Benchmark Results
Table of contents
Benchmark results
Fig. 6.1: Execution time of double precision trigonometric functions
Fig. 6.2: Execution time of single precision trigonometric functions
Fig. 6.3: Execution time of double precision log, exp, pow and inverse trigonometric functions
Fig. 6.4: Execution time of single precision log, exp, pow and inverse trigonometric functions
SLEEF Documentation - Compiling and installing the library
Table of contents
Preliminaries
Quick start
$ cmake --version
$ git clone https://github.com/shibatch/sleef
$ cd sleef
$ mkdir build && cd build
$ cmake ..
$ make
$ make test
$ make install
Common CMake variables
SLEEF-specific CMake variables
Compiling and installing the library on Linux
$ sudo apt-get install libmpfr-dev libssl-dev libfftw3-dev
$ mkdir build
$ cd build
$ cmake -DCMAKE_INSTALL_PREFIX=/usr ..
$ make
$ make test
$ sudo make install
Parallel build is only supported with Ninja.
In order to uninstall the libraries and headers, run the following command.
$ sudo xargs rm -v < install_manifest.txt
You can build the library with link time opimization(LTO) support with the following commands. Note that you can only build static libraries with LTO support. You also have to use the same compiler with the same version to build the library and other source codes.
$ CC=gcc cmake -DBUILD_SHARED_LIBS=FALSE -DENABLE_LTO=TRUE ..
In order to build the library with thinLTO support with clang, you need to specify LLVM AR command that exactly corresponds to the clang compiler.
$ CC=clang-9 cmake -DBUILD_SHARED_LIBS=FALSE -DENABLE_LTO=TRUE -DLLVM_AR_COMMAND=llvm-ar-9 ..
Header files for inlining the whole SLEEF functions can be built with the following commands. With these header files, it may be easier to inline the whole SLEEF functions than using LTO. You have to specify "-ffp-contract=off" compiler option when compiling a source code that includes one of these header files.
$ cmake -DBUILD_INLINE_HEADERS=TRUE ..
If you are using Debian 10(Buster), Ubuntu 18.04(Bionic) or later, then you can install the library through apt-get. The DFT library will not be installed.
$ sudo apt-get update $ sudo apt-get install libsleef-dev
You need Visual Studio 2019. Open developer command prompt for VS2019 and change directory to sleef-3.X. When configuring a build with cmake, you need to use a specific generator: `cmake -G"Visual Studio 16 2019" ..` This generator will create a proper solution `SLEEF.sln` under the build directory. You can still use `cmake --build .` to build the library without opening Visual Studio.
Below is an example of commands for building SLEEF with Visual Studio.
D:\sleef-3.X> mkdir build D:\sleef-3.X> cd build D:\sleef-3.X\build> cmake -G"Visual Studio 15 2017 Win64" .. &:: If you are using VS2017 D:\sleef-3.X\build> cmake -G"Visual Studio 16 2019" .. &:: If you are using VS2019 D:\sleef-3.X\build> cmake --build . --config Release -- /maxcpucount:1
You need Visual Studio 2019. Install ninja via VS2019 installer. Download and install clang on Windows from llvm.org. Below is an example of commands for building SLEEF with Clang on Windows.
D:\sleef-3.X> "c:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat" D:\sleef-3.X> mkdir build D:\sleef-3.X> cd build D:\sleef-3.X\build> cmake -GNinja -DCMAKE_C_COMPILER:PATH="C:\Program Files\LLVM\bin\clang.exe" .. D:\sleef-3.X\build> ninja
Now, let's try compiling the source code shown in Fig. 2.1.
#include <stdio.h>
#include <x86intrin.h>
#include <sleef.h>
int main(int argc, char **argv) {
double a[] = {2, 10};
double b[] = {3, 20};
__m128d va, vb, vc;
va = _mm_loadu_pd(a);
vb = _mm_loadu_pd(b);
vc = Sleef_powd2_u10(va, vb);
double c[2];
_mm_storeu_pd(c, vc);
printf("pow(%g, %g) = %g\n", a[0], b[0], c[0]);
printf("pow(%g, %g) = %g\n", a[1], b[1], c[1]);
}
Fig. 2.1: Source code for testing
Fig.2.2 shows typical commands for compiling and executing the hello code on Linux computers.
$ gcc hellox86.c -o hellox86 -lsleef $ ./hellox86 pow(2, 3) = 8 pow(10, 20) = 1e+20 $ █
Fig. 2.2: Commands for compiling and executing hellox86.c
You may need to set LD_LIBRARY_PATH environment variable appropriately. If you are trying to execute the program on Mac OSX or Windows, try copying the DLLs to the current directory.
Below is an example CMakeLists.txt for compiling the above hellox86.c. CMake will automatically download SLEEF from GitHub repository, and thus there is no need to include SLEEF in your software package. If you prefer importing SLEEF as a submodule in git, you can use SOURCE_DIR option instead of GIT_REPOSITORY option for ExternalProject_Add.
cmake_minimum_required(VERSION 3.5.1)
include(ExternalProject)
find_package(Git REQUIRED)
ExternalProject_Add(libsleef
GIT_REPOSITORY https://github.com/shibatch/sleef
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/contrib
)
include_directories(${CMAKE_BINARY_DIR}/contrib/include)
link_directories(${CMAKE_BINARY_DIR}/contrib/lib)
add_executable(hellox86 hellox86.c)
add_dependencies(hellox86 libsleef)
target_link_libraries(hellox86 sleef)
Fig. 2.3: Example CMakeLists.txt
sleef-3.5.1/doc/html/convention.png 0000664 0000000 0000000 00000064204 13730031441 0017221 0 ustar 00root root 0000000 0000000 ‰PNG IHDR D ð õÂÛH 0PLTE±QtÔŸÏÖØÆíØxxxŸŸŸþþþOOO’ÿzzÿ»µµÿLLqÁr°Ü>J`1 hIDATx^ìœ1oÛFÇHÓzÈrŒÌ”hM,D ‘Ü–zóZ CÖ˜wöµ@`eëèà~œlý àí4¸€6²û/RÔU'>-KÿÉ2!êîô~÷Þ½÷(¦·[²Ÿj{º¾ÆÇ!ç¡=ÃÞEý¥·]ýáL¯©Ÿu•¶Ñ‰1F;(äü®+5⹌bØ»¨+v£·[‰1wz=ýÁnž!¢×Žˆr [Çä˵ñ]Eô+{)ôVˬ¨