1 /*
2  * Single-precision vector log10 function.
3  *
4  * Copyright (c) 2020-2023, Arm Limited.
5  * SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception
6  */
7 
8 #include "v_math.h"
9 #include "mathlib.h"
10 #include "pl_sig.h"
11 #include "pl_test.h"
12 
13 #if V_SUPPORTED
14 
15 #define P(i) v_f32 (__v_log10f_poly[i])
16 
17 #define Ln2 v_f32 (0x1.62e43p-1f) /* 0x3f317218.  */
18 #define InvLn10 v_f32 (0x1.bcb7b2p-2f)
19 #define Min v_u32 (0x00800000)
20 #define Max v_u32 (0x7f800000)
21 #define Mask v_u32 (0x007fffff)
22 #define Off v_u32 (0x3f2aaaab) /* 0.666667.  */
23 
24 VPCS_ATTR
25 NOINLINE static v_f32_t
26 specialcase (v_f32_t x, v_f32_t y, v_u32_t cmp)
27 {
28   /* Fall back to scalar code.  */
29   return v_call_f32 (log10f, x, y, cmp);
30 }
31 
32 /* Our fast implementation of v_log10f uses a similar approach as v_logf.
33    With the same offset as v_logf (i.e., 2/3) it delivers about 3.3ulps with
34    order 9. This is more efficient than using a low order polynomial computed in
35    double precision.
36    Maximum error: 3.305ulps (nearest rounding.)
37    __v_log10f(0x1.555c16p+0) got 0x1.ffe2fap-4
38 			    want 0x1.ffe2f4p-4 -0.304916 ulp err 2.80492.  */
39 VPCS_ATTR
40 v_f32_t V_NAME (log10f) (v_f32_t x)
41 {
42   v_f32_t n, o, p, q, r, r2, y;
43   v_u32_t u, cmp;
44 
45   u = v_as_u32_f32 (x);
46   cmp = v_cond_u32 (u - Min >= Max - Min);
47 
48   /* x = 2^n * (1+r), where 2/3 < 1+r < 4/3.  */
49   u -= Off;
50   n = v_to_f32_s32 (v_as_s32_u32 (u) >> 23); /* signextend.  */
51   u &= Mask;
52   u += Off;
53   r = v_as_f32_u32 (u) - v_f32 (1.0f);
54 
55   /* y = log10(1+r) + n*log10(2).  */
56   r2 = r * r;
57   /* (n*ln2 + r)*InvLn10 + r2*(P0 + r*P1 + r2*(P2 + r*P3 + r2*(P4 + r*P5 +
58      r2*(P6+r*P7))).  */
59   o = v_fma_f32 (P (7), r, P (6));
60   p = v_fma_f32 (P (5), r, P (4));
61   q = v_fma_f32 (P (3), r, P (2));
62   y = v_fma_f32 (P (1), r, P (0));
63   p = v_fma_f32 (o, r2, p);
64   q = v_fma_f32 (p, r2, q);
65   y = v_fma_f32 (q, r2, y);
66   /* Using p = Log10(2)*n + r*InvLn(10) is slightly faster
67      but less accurate.  */
68   p = v_fma_f32 (Ln2, n, r);
69   y = v_fma_f32 (y, r2, p * InvLn10);
70 
71   if (unlikely (v_any_u32 (cmp)))
72     return specialcase (x, y, cmp);
73   return y;
74 }
75 VPCS_ALIAS
76 
77 PL_SIG (V, F, 1, log10, 0.01, 11.1)
78 PL_TEST_ULP (V_NAME (log10f), 2.81)
79 PL_TEST_EXPECT_FENV_ALWAYS (V_NAME (log10f))
80 PL_TEST_INTERVAL (V_NAME (log10f), 0, 0xffff0000, 10000)
81 PL_TEST_INTERVAL (V_NAME (log10f), 0x1p-4, 0x1p4, 500000)
82 #endif
83