Single & Double Precision Math library reference (AArch32)

Table of contents

Data types for AArch32 architecture

Sleef_float32x4_t_2

Sleef_float32x4_t_2 is a data type for storing two float32x4_t values, which is defined in sleef.h as follows:

typedef struct {
  float32x4_t x, y;
} Sleef_float32x4_t_2;

Trigonometric Functions

Vectorized single precision sine function with 1.0 ULP error bound 

#include <sleef.h>

float32x4_t Sleef_sinf4_u10(float32x4_t a);
float32x4_t Sleef_sinf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sinf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_sinf4_u35(float32x4_t a);
float32x4_t Sleef_sinf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sinf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_cosf4_u10(float32x4_t a);
float32x4_t Sleef_cosf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_cosf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_cosf4_u35(float32x4_t a);
float32x4_t Sleef_cosf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_cosf_u35. This function may be 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 

#include <sleef.h>

Sleef_float32x4_t_2 Sleef_sincosf4_u10(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sincosf_u10. This function may be 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 

#include <sleef.h>

Sleef_float32x4_t_2 Sleef_sincosf4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincosf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sincosf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_sinpif4_u05(float32x4_t a);
float32x4_t Sleef_sinpif4_u05neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sinpif_u05. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_cospif4_u05(float32x4_t a);
float32x4_t Sleef_cospif4_u05neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_cospif_u05. This function may be 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 

#include <sleef.h>

Sleef_float32x4_t_2 Sleef_sincospif4_u05(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u05neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sincospif_u05. This function may be 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 

#include <sleef.h>

Sleef_float32x4_t_2 Sleef_sincospif4_u35(float32x4_t a);
Sleef_float32x4_t_2 Sleef_sincospif4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sincospif_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_tanf4_u10(float32x4_t a);
float32x4_t Sleef_tanf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_tanf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_tanf4_u35(float32x4_t a);
float32x4_t Sleef_tanf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_tanf_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Power, exponential, and logarithmic function

Vectorized single precision power function with 1.0 ULP error bound 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_powf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_logf4_u10(float32x4_t a);
float32x4_t Sleef_logf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_logf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_logf4_u35(float32x4_t a);
float32x4_t Sleef_logf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_logf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_log10f4_u10(float32x4_t a);
float32x4_t Sleef_log10f4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_log10f_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_log2f4_u10(float32x4_t a);
float32x4_t Sleef_log2f4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_log2f_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_log1pf4_u10(float32x4_t a);
float32x4_t Sleef_log1pf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_log1pf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_expf4_u10(float32x4_t a);
float32x4_t Sleef_expf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_expf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_exp2f4_u10(float32x4_t a);
float32x4_t Sleef_exp2f4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_exp2f_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_exp10f4_u10(float32x4_t a);
float32x4_t Sleef_exp10f4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_exp10f_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_expm1f4_u10(float32x4_t a);
float32x4_t Sleef_expm1f4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_expm1f_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_sqrtf4(float32x4_t a);
float32x4_t Sleef_sqrtf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sqrtf_u05. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_sqrtf4_u35(float32x4_t a);
float32x4_t Sleef_sqrtf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sqrtf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_cbrtf4_u10(float32x4_t a);
float32x4_t Sleef_cbrtf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_cbrtf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_cbrtf4_u35(float32x4_t a);
float32x4_t Sleef_cbrtf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_cbrtf_u35. This function may be 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 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_hypotf_u05. This function may be 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 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_hypotf_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Inverse Trigonometric Functions

Vectorized single precision arc sine function with 3.5 ULP error bound 

#include <sleef.h>

float32x4_t Sleef_asinf4_u10(float32x4_t a);
float32x4_t Sleef_asinf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_asinf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_asinf4_u35(float32x4_t a);
float32x4_t Sleef_asinf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_asinf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_acosf4_u10(float32x4_t a);
float32x4_t Sleef_acosf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_acosf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_acosf4_u35(float32x4_t a);
float32x4_t Sleef_acosf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_acosf_u35. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_atanf4_u10(float32x4_t a);
float32x4_t Sleef_atanf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_atanf_u10. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_atanf4_u35(float32x4_t a);
float32x4_t Sleef_atanf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_atanf_u35. This function may be 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 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_atan2f_u10. This function may be 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 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_atan2f_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Hyperbolic function and inverse hyperbolic function

Vectorized single precision hyperbolic sine function 

#include <sleef.h>

float32x4_t Sleef_sinhf4_u10(float32x4_t a);
float32x4_t Sleef_sinhf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sinhf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision hyperbolic sine function 

#include <sleef.h>

float32x4_t Sleef_sinhf4_u35(float32x4_t a);
float32x4_t Sleef_sinhf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_sinhf_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision hyperbolic cosine function 

#include <sleef.h>

float32x4_t Sleef_coshf4_u10(float32x4_t a);
float32x4_t Sleef_coshf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_coshf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision hyperbolic cosine function 

#include <sleef.h>

float32x4_t Sleef_coshf4_u35(float32x4_t a);
float32x4_t Sleef_coshf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_coshf_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision hyperbolic tangent function 

#include <sleef.h>

float32x4_t Sleef_tanhf4_u10(float32x4_t a);
float32x4_t Sleef_tanhf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_tanhf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision hyperbolic tangent function 

#include <sleef.h>

float32x4_t Sleef_tanhf4_u35(float32x4_t a);
float32x4_t Sleef_tanhf4_u35neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_tanhf_u35. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision inverse hyperbolic sine function 

#include <sleef.h>

float32x4_t Sleef_asinhf4_u10(float32x4_t a);
float32x4_t Sleef_asinhf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_asinhf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision inverse hyperbolic cosine function 

#include <sleef.h>

float32x4_t Sleef_acoshf4_u10(float32x4_t a);
float32x4_t Sleef_acoshf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_acoshf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision inverse hyperbolic tangent function 

#include <sleef.h>

float32x4_t Sleef_atanhf4_u10(float32x4_t a);
float32x4_t Sleef_atanhf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_atanhf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Error and gamma function

Vectorized single precision error function 

#include <sleef.h>

float32x4_t Sleef_erff4_u10(float32x4_t a);
float32x4_t Sleef_erff4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_erff_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision complementary error function 

#include <sleef.h>

float32x4_t Sleef_erfcf4_u15(float32x4_t a);
float32x4_t Sleef_erfcf4_u15neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_erfcf_u15. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision gamma function 

#include <sleef.h>

float32x4_t Sleef_tgammaf4_u10(float32x4_t a);
float32x4_t Sleef_tgammaf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_tgammaf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision log gamma function 

#include <sleef.h>

float32x4_t Sleef_lgammaf4_u10(float32x4_t a);
float32x4_t Sleef_lgammaf4_u10neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_lgammaf_u10. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Nearest integer function

Vectorized single precision function for rounding to integer towards zero 

#include <sleef.h>

float32x4_t Sleef_truncf4(float32x4_t a);
float32x4_t Sleef_truncf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_truncf. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_floorf4(float32x4_t a);
float32x4_t Sleef_floorf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_floorf. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_ceilf4(float32x4_t a);
float32x4_t Sleef_ceilf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_ceilf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for rounding to nearest integer 

#include <sleef.h>

float32x4_t Sleef_roundf4(float32x4_t a);
float32x4_t Sleef_roundf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_roundf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for rounding to nearest integer 

#include <sleef.h>

float32x4_t Sleef_rintf4(float32x4_t a);
float32x4_t Sleef_rintf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_rintf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Other function

Vectorized single precision function for fused multiply-accumulation 

#include <sleef.h>

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.

These are the vectorized functions of Sleef_fmaf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision FP remainder 

#include <sleef.h>

float32x4_t Sleef_fmodf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmodf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_fmodf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision FP remainder 

#include <sleef.h>

float32x4_t Sleef_remainderf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_remainderf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_remainderf. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_frfrexpf4(float32x4_t a);
float32x4_t Sleef_frfrexpf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_frfrexpf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision signed integral and fractional values 

#include <sleef.h>

Sleef_float32x4_t_2 Sleef_modff4(float32x4_t a);
Sleef_float32x4_t_2 Sleef_modff4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_modff. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for calculating the absolute value 

#include <sleef.h>

float32x4_t Sleef_fabsf4(float32x4_t a);
float32x4_t Sleef_fabsf4_neon(float32x4_t a);

Link with -lsleef.

These are the vectorized functions of Sleef_fabsf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for copying signs 

#include <sleef.h>

float32x4_t Sleef_copysignf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_copysignf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_copysignf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for determining maximum of two values 

#include <sleef.h>

float32x4_t Sleef_fmaxf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fmaxf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_fmaxf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.

Vectorized single precision function for determining minimum of two values 

#include <sleef.h>

float32x4_t Sleef_fminf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fminf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_fminf. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_fdimf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_fdimf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_fdimf. This function may be 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 

#include <sleef.h>

float32x4_t Sleef_nextafterf4(float32x4_t a, float32x4_t b);
float32x4_t Sleef_nextafterf4_neon(float32x4_t a, float32x4_t b);

Link with -lsleef.

These are the vectorized functions of Sleef_nextafterf. This function may be less accurate than the scalar function since AArch32 NEON is not IEEE 754-compliant.