1 /* 2 * Single-precision vector log(1+x) function. 3 * 4 * Copyright (c) 2022-2023, Arm Limited. 5 * SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception 6 */ 7 8 #include "v_math.h" 9 #include "pl_sig.h" 10 #include "pl_test.h" 11 #include "poly_advsimd_f32.h" 12 13 const static struct data 14 { 15 float32x4_t poly[8], ln2; 16 uint32x4_t tiny_bound, minus_one, four, thresh; 17 int32x4_t three_quarters; 18 } data = { 19 .poly = { /* Generated using FPMinimax in [-0.25, 0.5]. First two coefficients 20 (1, -0.5) are not stored as they can be generated more 21 efficiently. */ 22 V4 (0x1.5555aap-2f), V4 (-0x1.000038p-2f), V4 (0x1.99675cp-3f), 23 V4 (-0x1.54ef78p-3f), V4 (0x1.28a1f4p-3f), V4 (-0x1.0da91p-3f), 24 V4 (0x1.abcb6p-4f), V4 (-0x1.6f0d5ep-5f) }, 25 .ln2 = V4 (0x1.62e43p-1f), 26 .tiny_bound = V4 (0x34000000), /* asuint32(0x1p-23). ulp=0.5 at 0x1p-23. */ 27 .thresh = V4 (0x4b800000), /* asuint32(INFINITY) - tiny_bound. */ 28 .minus_one = V4 (0xbf800000), 29 .four = V4 (0x40800000), 30 .three_quarters = V4 (0x3f400000) 31 }; 32 33 static inline float32x4_t 34 eval_poly (float32x4_t m, const float32x4_t *p) 35 { 36 /* Approximate log(1+m) on [-0.25, 0.5] using split Estrin scheme. */ 37 float32x4_t p_12 = vfmaq_f32 (v_f32 (-0.5), m, p[0]); 38 float32x4_t p_34 = vfmaq_f32 (p[1], m, p[2]); 39 float32x4_t p_56 = vfmaq_f32 (p[3], m, p[4]); 40 float32x4_t p_78 = vfmaq_f32 (p[5], m, p[6]); 41 42 float32x4_t m2 = vmulq_f32 (m, m); 43 float32x4_t p_02 = vfmaq_f32 (m, m2, p_12); 44 float32x4_t p_36 = vfmaq_f32 (p_34, m2, p_56); 45 float32x4_t p_79 = vfmaq_f32 (p_78, m2, p[7]); 46 47 float32x4_t m4 = vmulq_f32 (m2, m2); 48 float32x4_t p_06 = vfmaq_f32 (p_02, m4, p_36); 49 return vfmaq_f32 (p_06, m4, vmulq_f32 (m4, p_79)); 50 } 51 52 static float32x4_t NOINLINE VPCS_ATTR 53 special_case (float32x4_t x, float32x4_t y, uint32x4_t special) 54 { 55 return v_call_f32 (log1pf, x, y, special); 56 } 57 58 /* Vector log1pf approximation using polynomial on reduced interval. Accuracy 59 is roughly 2.02 ULP: 60 log1pf(0x1.21e13ap-2) got 0x1.fe8028p-3 want 0x1.fe802cp-3. */ 61 VPCS_ATTR float32x4_t V_NAME_F1 (log1p) (float32x4_t x) 62 { 63 const struct data *d = ptr_barrier (&data); 64 65 uint32x4_t ix = vreinterpretq_u32_f32 (x); 66 uint32x4_t ia = vreinterpretq_u32_f32 (vabsq_f32 (x)); 67 uint32x4_t special_cases 68 = vorrq_u32 (vcgeq_u32 (vsubq_u32 (ia, d->tiny_bound), d->thresh), 69 vcgeq_u32 (ix, d->minus_one)); 70 float32x4_t special_arg = x; 71 72 #if WANT_SIMD_EXCEPT 73 if (unlikely (v_any_u32 (special_cases))) 74 /* Side-step special lanes so fenv exceptions are not triggered 75 inadvertently. */ 76 x = v_zerofy_f32 (x, special_cases); 77 #endif 78 79 /* With x + 1 = t * 2^k (where t = m + 1 and k is chosen such that m 80 is in [-0.25, 0.5]): 81 log1p(x) = log(t) + log(2^k) = log1p(m) + k*log(2). 82 83 We approximate log1p(m) with a polynomial, then scale by 84 k*log(2). Instead of doing this directly, we use an intermediate 85 scale factor s = 4*k*log(2) to ensure the scale is representable 86 as a normalised fp32 number. */ 87 88 float32x4_t m = vaddq_f32 (x, v_f32 (1.0f)); 89 90 /* Choose k to scale x to the range [-1/4, 1/2]. */ 91 int32x4_t k 92 = vandq_s32 (vsubq_s32 (vreinterpretq_s32_f32 (m), d->three_quarters), 93 v_s32 (0xff800000)); 94 uint32x4_t ku = vreinterpretq_u32_s32 (k); 95 96 /* Scale x by exponent manipulation. */ 97 float32x4_t m_scale 98 = vreinterpretq_f32_u32 (vsubq_u32 (vreinterpretq_u32_f32 (x), ku)); 99 100 /* Scale up to ensure that the scale factor is representable as normalised 101 fp32 number, and scale m down accordingly. */ 102 float32x4_t s = vreinterpretq_f32_u32 (vsubq_u32 (d->four, ku)); 103 m_scale = vaddq_f32 (m_scale, vfmaq_f32 (v_f32 (-1.0f), v_f32 (0.25f), s)); 104 105 /* Evaluate polynomial on the reduced interval. */ 106 float32x4_t p = eval_poly (m_scale, d->poly); 107 108 /* The scale factor to be applied back at the end - by multiplying float(k) 109 by 2^-23 we get the unbiased exponent of k. */ 110 float32x4_t scale_back = vcvtq_f32_s32 (vshrq_n_s32 (k, 23)); 111 112 /* Apply the scaling back. */ 113 float32x4_t y = vfmaq_f32 (p, scale_back, d->ln2); 114 115 if (unlikely (v_any_u32 (special_cases))) 116 return special_case (special_arg, y, special_cases); 117 return y; 118 } 119 120 PL_SIG (V, F, 1, log1p, -0.9, 10.0) 121 PL_TEST_ULP (V_NAME_F1 (log1p), 1.53) 122 PL_TEST_EXPECT_FENV (V_NAME_F1 (log1p), WANT_SIMD_EXCEPT) 123 PL_TEST_SYM_INTERVAL (V_NAME_F1 (log1p), 0.0, 0x1p-23, 30000) 124 PL_TEST_SYM_INTERVAL (V_NAME_F1 (log1p), 0x1p-23, 1, 50000) 125 PL_TEST_INTERVAL (V_NAME_F1 (log1p), 1, inf, 50000) 126 PL_TEST_INTERVAL (V_NAME_F1 (log1p), -1.0, -inf, 1000) 127