#include "cl_LF.h"
#include "cln/integer.h"
-#undef MAYBE_INLINE
-#define MAYBE_INLINE inline
+#include "cl_inline.h"
#include "cl_LF_zerop.cc"
#include "cl_LF_minusp.cc"
#include "cl_LF_exponent.cc"
const cl_LF lnx_naive (const cl_LF& x)
{
var cl_LF y = x-cl_float(1,x);
- if (zerop(y)) // y=0.0 -> y als Ergebnis
+ if (zerop_inline(y)) // y=0.0 -> y als Ergebnis
return y;
- var uintL actuallen = TheLfloat(x)->len;
- var uintL d = float_digits(x);
- var sintL e = float_exponent(y);
- if (e <= -(sintL)d) // e <= -d ?
+ var uintC actuallen = TheLfloat(x)->len;
+ var uintC d = float_digits(x);
+ var sintE e = float_exponent_inline(y);
+ if (e <= -(sintC)d) // e <= -d ?
return y; // ja -> y als Ergebnis
{ Mutable(cl_LF,x);
- var uintL k = 0; // Rekursionszähler k:=0
+ var uintL k = 0; // Rekursionszähler k:=0
// Bei e <= -1-limit_slope*floor(sqrt(d)) kann die Potenzreihe
// angewandt werden.
- // Wähle für ln(1+y), naive1: limit_slope = 1.0,
- // für ln(1+y), naive2: limit_slope = 11/16 = 0.7,
- // für atanh(z), naive1: limit_slope = 0.6,
- // für atanh(z), naive1: limit_slope = 0.5.
- var sintL e_limit = -1-floor(isqrt(d),2); // -1-floor(sqrt(d))
+ // Wähle für ln(1+y), naive1: limit_slope = 1.0,
+ // für ln(1+y), naive2: limit_slope = 11/16 = 0.7,
+ // für atanh(z), naive1: limit_slope = 0.6,
+ // für atanh(z), naive1: limit_slope = 0.5.
+ var sintL e_limit = -1-floor(isqrtC(d),2); // -1-floor(sqrt(d))
while (e > e_limit) {
- // e > -1-floor(sqrt(d)) -> muß |y| verkleinern.
+ // e > -1-floor(sqrt(d)) -> muß |y| verkleinern.
x = sqrt(x); // x := (sqrt x)
y = x-cl_float(1,x); // y := (- x 1) und
- e = float_exponent(y); // e neu berechnen
+ e = float_exponent_inline(y); // e neu berechnen
k = k+1; // k:=k+1
}
if (0) {
} else {
// naive2:
// floating-point representation with smooth precision reduction
- var cl_LF eps = scale_float(b,-(sintL)d-10);
+ var cl_LF eps = scale_float(b,-(sintC)d-10);
loop {
var cl_LF new_sum = sum + LF_to_LF(b/(cl_I)i,actuallen); // (+ sum (/ b i))
if (new_sum == sum) // = sum ?
} else {
// naive2:
// floating-point representation with smooth precision reduction
- var cl_LF eps = scale_float(b,-(sintL)d-10);
+ var cl_LF eps = scale_float(b,-(sintC)d-10);
loop {
var cl_LF new_sum = sum + LF_to_LF(b/(cl_I)i,actuallen); // (+ sum (/ b i))
if (new_sum == sum) // = sum ?
var cl_F y = x-cl_float(1,x);
if (zerop(y)) // y=0.0 -> y als Ergebnis
return y;
- var uintL d = float_digits(x);
- var sintL e = float_exponent(y);
- if (e <= -(sintL)d) // e <= -d ?
+ var uintC d = float_digits(x);
+ var sintE e = float_exponent(y);
+ if (e <= -(sintC)d) // e <= -d ?
return y; // ja -> y als Ergebnis
{ Mutable(cl_F,x);
- var uintL k = 0; // Rekursionszähler k:=0
+ var uintL k = 0; // Rekursionszähler k:=0
// Bei e <= -1-floor(sqrt(d)) kann die Potenzreihe angewandt werden.
- var sintL e_limit = -1-isqrt(d); // -1-floor(sqrt(d))
+ var sintL e_limit = -1-isqrtC(d); // -1-floor(sqrt(d))
while (e > e_limit) {
- // e > -1-floor(sqrt(d)) -> muß |y| verkleinern.
+ // e > -1-floor(sqrt(d)) -> muß |y| verkleinern.
x = sqrt(x); // x := (sqrt x)
y = x-cl_float(1,x); // y := (- x 1) und
e = float_exponent(y); // e neu berechnen
// x1 = (-1)^sign * 2^exponent * mantissa
if (zerop(x1_.mantissa))
break;
- var uintL lm = integer_length(x1_.mantissa);
- var uintL me = cl_I_to_UL(- x1_.exponent);
+ var uintC lm = integer_length(x1_.mantissa);
+ var uintE me = cl_I_to_UE(- x1_.exponent);
var cl_I p;
- var uintL lq;
- var cl_boolean last_step = cl_false;
+ var uintE lq;
+ var bool last_step = false;
if (lm >= me) { // |x'| >= 1/2 ?
p = x1_.sign; // 1 or -1
lq = 1;
} else {
- var uintL n = me - lm; // |x'| < 2^-n with n maximal
+ var uintE n = me - lm; // |x'| < 2^-n with n maximal
// Set p to the first n bits of |x'|:
if (lm > n) {
p = x1_.mantissa >> (lm - n);
// after the next big multiplication. This saves one
// big multiplication at the end.
if (2*n >= lm)
- last_step = cl_true;
+ last_step = true;
}
- y = y + scale_float(cl_I_to_LF(p,len),-(sintL)lq);
+ y = y + scale_float(cl_I_to_LF(p,len),-(sintE)lq);
if (last_step)
break;
x = x * cl_exp_aux(-p,lq,len);