Lines Matching defs:log
926 * acosh(x) = log [ x + sqrt(x*x-1) ]
928 * acosh(x) := log(x)+ln2, if x is large; else
929 * acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
950 return log(x) + ln2; /* acosh(huge)=log(2x) */
956 return log(2.0 * x - one / (x + sqrt(t - one)));
1060 * asinh(x) = sign(x) * log [ |x| + sqrt(x*x+1) ]
1063 * := sign(x)*(log(x)+ln2)) for large |x|, else
1064 * := sign(x)*log(2|x|+1/(|x|+sqrt(x*x+1))) if|x|>2, else
1082 w = log(fabs(x)) + ln2;
1085 w = log(2.0 * t + one / (sqrt(x * x + one) + t));
1541 * atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
1584 /* log(x)
1592 * 2. Approximation of log(1+f).
1593 * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
1608 * In order to guarantee error in log below 1ulp, we compute log
1610 * log(1+f) = f - s*(f - R) (if f is not too large)
1611 * log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
1613 * 3. Finally, log(x) = k*ln2 + log(1+f).
1620 * log(x) is NaN with signal if x < 0 (including -INF) ;
1621 * log(+INF) is +INF; log(0) is -INF with signal;
1622 * log(NaN) is that NaN with no signal.
1634 double log(double x) {
1658 return -std::numeric_limits<double>::infinity(); /* log(+-0)=-inf */
1661 return std::numeric_limits<double>::signaling_NaN(); /* log(-#) = NaN */
1725 * log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u),
1727 * (Note: when x > 2**53, one can simply return log(x))
1730 * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
1745 * In order to guarantee error in log below 1ulp, we compute log
1770 * Note: Assuming log() return accurate answer, the following
1775 * return log(u)*(x/(u-1.0));
1880 * Return log(1+f) - f for 1+f in ~[sqrt(2)/2, sqrt(2)].
1892 * 2. Approximation of log(1+f).
1893 * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)
1908 * In order to guarantee error in log below 1ulp, we compute log
1910 * log(1+f) = f - s*(f - R) (if f is not too large)
1911 * log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)
1913 * 3. Finally, log(x) = k*ln2 + log(1+f).
1920 * log(x) is NaN with signal if x < 0 (including -INF) ;
1921 * log(+INF) is +INF; log(0) is -INF with signal;
1922 * log(NaN) is that NaN with no signal.
1984 return -std::numeric_limits<double>::infinity(); /* log(+-0)=-inf */
1987 return std::numeric_limits<double>::signaling_NaN(); /* log(-#) = NaN */
1994 if (hx == 0x3FF00000 && lx == 0) return 0.0; /* log(1) = +0 */
2055 * ivln10 = 1/log(10) rounded.
2060 * log10(x) := n*log10_2hi + (n*log10_2lo + ivln10*log(x))
2066 * [1/log(10)] rounded to 53 bits has error .198 ulps;
2091 return -std::numeric_limits<double>::infinity(); /* log(+-0)=-inf */
2094 return std::numeric_limits<double>::quiet_NaN(); /* log(-#) = NaN */
2102 if (hx == 0x3FF00000 && lx == 0) return 0.0; /* log(1) = +0 */
2111 double z = y * log10_2lo + ivln10 * log(x);
2572 // |x| in [22, log(maxdouble)], return half*exp(|x|)
2575 // |x| in [log(maxdouble), overflowthreshold]
2645 // poly coefs for (3/2)*(log(x)-2s-2/3*s**3
2775 log(x) by x-x^2/2+x^3/3-x^4/4 */
2818 /* compute log(ax) */
2938 // |x| in [22, log(maxdouble)], return 0.5 * exp(|x|)
2940 // |x| in [log(maxdouble), overflowthreshold]