/src/moddable/xs/tools/fdlibm/e_log.c

Source

/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunSoft, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice 
 * is preserved.
 * ====================================================
 */

/* log(x)
 * Return the logrithm of x
 *
 * Method :                  
 *   1. Argument Reduction: find k and f such that 
 *      x = 2^k * (1+f), 
 *     where  sqrt(2)/2 < 1+f < sqrt(2) .
 *
 *   2. Approximation of log(1+f).
 *  Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
 *     = 2s + 2/3 s**3 + 2/5 s**5 + .....,
 *         = 2s + s*R
 *      We use a special Reme algorithm on [0,0.1716] to generate 
 *  a polynomial of degree 14 to approximate R The maximum error 
 *  of this polynomial approximation is bounded by 2**-58.45. In
 *  other words,
 *            2      4      6      8      10      12      14
 *      R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s  +Lg6*s  +Lg7*s
 *    (the values of Lg1 to Lg7 are listed in the program)
 *  and
 *      |      2          14          |     -58.45
 *      | Lg1*s +...+Lg7*s    -  R(z) | <= 2 
 *      |                             |
 *  Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.
 *  In order to guarantee error in log below 1ulp, we compute log
 *  by
 *    log(1+f) = f - s*(f - R)  (if f is not too large)
 *    log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
 *  
 *  3. Finally,  log(x) = k*ln2 + log(1+f).  
 *          = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))
 *     Here ln2 is split into two floating point number: 
 *      ln2_hi + ln2_lo,
 *     where n*ln2_hi is always exact for |n| < 2000.
 *
 * Special cases:
 *  log(x) is NaN with signal if x < 0 (including -INF) ; 
 *  log(+INF) is +INF; log(0) is -INF with signal;
 *  log(NaN) is that NaN with no signal.
 *
 * Accuracy:
 *  according to an error analysis, the error is always less than
 *  1 ulp (unit in the last place).
 *
 * Constants:
 * The hexadecimal values are the intended ones for the following 
 * constants. The decimal values may be used, provided that the 
 * compiler will convert from decimal to binary accurately enough 
 * to produce the hexadecimal values shown.
 */

#include "math_private.h"

static const double
ln2_hi  =  6.93147180369123816490e-01,  /* 3fe62e42 fee00000 */
ln2_lo  =  1.90821492927058770002e-10,  /* 3dea39ef 35793c76 */
two54   =  1.80143985094819840000e+16,  /* 43500000 00000000 */
Lg1 = 6.666666666666735130e-01,  /* 3FE55555 55555593 */
Lg2 = 3.999999999940941908e-01,  /* 3FD99999 9997FA04 */
Lg3 = 2.857142874366239149e-01,  /* 3FD24924 94229359 */
Lg4 = 2.222219843214978396e-01,  /* 3FCC71C5 1D8E78AF */
Lg5 = 1.818357216161805012e-01,  /* 3FC74664 96CB03DE */
Lg6 = 1.531383769920937332e-01,  /* 3FC39A09 D078C69F */
Lg7 = 1.479819860511658591e-01;  /* 3FC2F112 DF3E5244 */

static const double zero   =  0.0;
static volatile double vzero = 0.0;

double
__ieee754_log(double x)
{
  double hfsq,f,s,z,R,w,t1,t2,dk;
  int32_t k,hx,i,j;
  u_int32_t lx;

  EXTRACT_WORDS(hx,lx,x);

  k=0;
  if (hx < 0x00100000) {     /* x < 2**-1022  */
      if (((hx&0x7fffffff)|lx)==0) 
    return -two54/vzero;    /* log(+-0)=-inf */
      if (hx<0) return (x-x)/zero;  /* log(-#) = NaN */
      k -= 54; x *= two54; /* subnormal number, scale up x */
      GET_HIGH_WORD(hx,x);
  } 
  if (hx >= 0x7ff00000) return x+x;
  k += (hx>>20)-1023;
  hx &= 0x000fffff;
  i = (hx+0x95f64)&0x100000;
  SET_HIGH_WORD(x,hx|(i^0x3ff00000));  /* normalize x or x/2 */
  k += (i>>20);
  f = x-1.0;
  if((0x000fffff&(2+hx))<3) { /* -2**-20 <= f < 2**-20 */
      if(f==zero) {
    if(k==0) {
        return zero;
    } else {
        dk=(double)k;
        return dk*ln2_hi+dk*ln2_lo;
    }
      }
      R = f*f*(0.5-0.33333333333333333*f);
      if(k==0) return f-R; else {dk=(double)k;
             return dk*ln2_hi-((R-dk*ln2_lo)-f);}
  }
  s = f/(2.0+f); 
  dk = (double)k;
  z = s*s;
  i = hx-0x6147a;
  w = z*z;
  j = 0x6b851-hx;
  t1= w*(Lg2+w*(Lg4+w*Lg6)); 
  t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7))); 
  i |= j;
  R = t2+t1;
  if(i>0) {
      hfsq=0.5*f*f;
      if(k==0) return f-(hfsq-s*(hfsq+R)); else
         return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
  } else {
      if(k==0) return f-s*(f-R); else
         return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
  }
}

Coverage Report

Created: 2025-10-29 06:26

Line	Count	Source
1
2		/*
3		* ====================================================
4		* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
5		*
6		* Developed at SunSoft, a Sun Microsystems, Inc. business.
7		* Permission to use, copy, modify, and distribute this
8		* software is freely granted, provided that this notice
9		* is preserved.
10		* ====================================================
11		*/
12
13		/* log(x)
14		* Return the logrithm of x
15		*
16		* Method :
17		* 1. Argument Reduction: find k and f such that
18		* x = 2^k * (1+f),
19		* where sqrt(2)/2 < 1+f < sqrt(2) .
20		*
21		* 2. Approximation of log(1+f).
22		* Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
23		* = 2s + 2/3 s3 + 2/5 s5 + .....,
24		* = 2s + s*R
25		* We use a special Reme algorithm on [0,0.1716] to generate
26		* a polynomial of degree 14 to approximate R The maximum error
27		* of this polynomial approximation is bounded by 2**-58.45. In
28		* other words,
29		* 2 4 6 8 10 12 14
30		* R(z) ~ Lg1s +Lg2s +Lg3s +Lg4s +Lg5s +Lg6s +Lg7*s
31		* (the values of Lg1 to Lg7 are listed in the program)
32		* and
33		* \| 2 14 \| -58.45
34		* \| Lg1s +...+Lg7s - R(z) \| <= 2
35		* \| \|
36		* Note that 2s = f - sf = f - hfsq + shfsq, where hfsq = f*f/2.
37		* In order to guarantee error in log below 1ulp, we compute log
38		* by
39		* log(1+f) = f - s*(f - R) (if f is not too large)
40		* log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
41		*
42		* 3. Finally, log(x) = k*ln2 + log(1+f).
43		* = kln2_hi+(f-(hfsq-(s(hfsq+R)+k*ln2_lo)))
44		* Here ln2 is split into two floating point number:
45		* ln2_hi + ln2_lo,
46		* where n*ln2_hi is always exact for \|n\| < 2000.
47		*
48		* Special cases:
49		* log(x) is NaN with signal if x < 0 (including -INF) ;
50		* log(+INF) is +INF; log(0) is -INF with signal;
51		* log(NaN) is that NaN with no signal.
52		*
53		* Accuracy:
54		* according to an error analysis, the error is always less than
55		* 1 ulp (unit in the last place).
56		*
57		* Constants:
58		* The hexadecimal values are the intended ones for the following
59		* constants. The decimal values may be used, provided that the
60		* compiler will convert from decimal to binary accurately enough
61		* to produce the hexadecimal values shown.
62		*/
63
64		#include "math_private.h"
65
66		static const double
67		ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */
68		ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */
69		two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */
70		Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */
71		Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */
72		Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */
73		Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */
74		Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */
75		Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */
76		Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
77
78		static const double zero = 0.0;
79		static volatile double vzero = 0.0;
80
81		double
82		__ieee754_log(double x)
83	853k	{
84	853k	double hfsq,f,s,z,R,w,t1,t2,dk;
85	853k	int32_t k,hx,i,j;
86	853k	u_int32_t lx;
87
88	853k	EXTRACT_WORDS(hx,lx,x);
89
90	853k	k=0;
91	853k	if (hx < 0x00100000) { /* x < 2*-1022 /
92	18	if (((hx&0x7fffffff)\|lx)==0)
93	7	return -two54/vzero; /* log(+-0)=-inf */
94	11	if (hx<0) return (x-x)/zero; /* log(-#) = NaN */
95	0	k -= 54; x = two54; / subnormal number, scale up x */
96	0	GET_HIGH_WORD(hx,x);
97	0	}
98	853k	if (hx >= 0x7ff00000) return x+x;
99	853k	k += (hx>>20)-1023;
100	853k	hx &= 0x000fffff;
101	853k	i = (hx+0x95f64)&0x100000;
102	853k	SET_HIGH_WORD(x,hx\|(i^0x3ff00000)); /* normalize x or x/2 */
103	853k	k += (i>>20);
104	853k	f = x-1.0;
105	853k	if((0x000fffff&(2+hx))<3) { /* -2-20 <= f < 2-20 */
106	483k	if(f==zero) {
107	480k	if(k==0) {
108	1	return zero;
109	480k	} else {
110	480k	dk=(double)k;
111	480k	return dkln2_hi+dkln2_lo;
112	480k	}
113	480k	}
114	2.27k	R = ff(0.5-0.33333333333333333*f);
115	2.27k	if(k==0) return f-R; else {dk=(double)k;
116	2.27k	return dkln2_hi-((R-dkln2_lo)-f);}
117	2.27k	}
118	370k	s = f/(2.0+f);
119	370k	dk = (double)k;
120	370k	z = s*s;
121	370k	i = hx-0x6147a;
122	370k	w = z*z;
123	370k	j = 0x6b851-hx;
124	370k	t1= w(Lg2+w(Lg4+w*Lg6));
125	370k	t2= z(Lg1+w(Lg3+w(Lg5+wLg7)));
126	370k	i \|= j;
127	370k	R = t2+t1;
128	370k	if(i>0) {
129	342	hfsq=0.5ff;
130	342	if(k==0) return f-(hfsq-s*(hfsq+R)); else
131	342	return dkln2_hi-((hfsq-(s(hfsq+R)+dk*ln2_lo))-f);
132	370k	} else {
133	370k	if(k==0) return f-s*(f-R); else
134	370k	return dkln2_hi-((s(f-R)-dk*ln2_lo)-f);
135	370k	}
136	370k	}