// catalanconst().
// General includes.
-#include "cl_sysdep.h"
+#include "base/cl_sysdep.h"
// Specification.
-#include "cl_F_tran.h"
+#include "float/transcendental/cl_F_tran.h"
// Implementation.
#include "cln/lfloat.h"
-#include "cl_LF_tran.h"
-#include "cl_LF.h"
+#include "float/transcendental/cl_LF_tran.h"
+#include "float/lfloat/cl_LF.h"
#include "cln/integer.h"
-#include "cl_alloca.h"
+#include "base/cl_alloca.h"
namespace cln {
// Every summand gives 0.6 new decimal digits in precision.
// The sum is best evaluated using fixed-point arithmetic,
// so that the precision is reduced for the later summands.
- var uintC actuallen = len + 2; // 2 Schutz-Digits
+ var uintC actuallen = len + 2; // 2 guard digits
var sintC scale = intDsize*actuallen;
var cl_I sum = 0;
var cl_I n = 0;
+ The(cl_LF)(pi(actuallen))
* ln(cl_I_to_LF(2,actuallen)+sqrt(cl_I_to_LF(3,actuallen))),
-3);
- return shorten(g,len); // verkürzen und fertig
+ return shorten(g,len); // verkürzen und fertig
}
// Bit complexity (N := len): O(N^2).
// p(n) = n for n>0, q(n) = 2*(2*n+1) for n>0.
var uintC N = (intDsize/2)*actuallen;
// 4^-N <= 2^(-intDsize*actuallen).
- var cl_LF fsum = eval_rational_series(N,series,actuallen);
+ var cl_LF fsum = eval_rational_series<false>(N,series,actuallen,actuallen);
var cl_LF g =
scale_float(The(cl_LF)(3*fsum)
+ The(cl_LF)(pi(actuallen))
* ln(cl_I_to_LF(2,actuallen)+sqrt(cl_I_to_LF(3,actuallen))),
-3);
- return shorten(g,len); // verkürzen und fertig
+ return shorten(g,len); // verkürzen und fertig
}
// Bit complexity (N := len): O(log(N)^2*M(N)).
const cl_LF compute_catalanconst_expintegral1 (uintC len)
{
// We compute f(x) classically and g(x) using the partial sums of f(x).
- var uintC actuallen = len+2; // 2 Schutz-Digits
+ var uintC actuallen = len+2; // 2 guard digits
var uintC x = (uintC)(0.693148*intDsize*actuallen)+1;
var uintC N = (uintC)(2.718281828*x);
var cl_LF fterm = cl_I_to_LF(1,actuallen);
gsum = gsum + gterm;
}
var cl_LF result = gsum/fsum;
- return shorten(result,len); // verkürzen und fertig
+ return shorten(result,len); // verkürzen und fertig
}
// Bit complexity (N = len): O(N^2).
// the sums.
const cl_LF compute_catalanconst_expintegral2 (uintC len)
{
- var uintC actuallen = len+2; // 2 Schutz-Digits
+ var uintC actuallen = len+2; // 2 guard digits
var uintC x = (uintC)(0.693148*intDsize*actuallen)+1;
var uintC N = (uintC)(2.718281828*x);
CL_ALLOCA_STACK;
args[n].q.~cl_I();
args[n].d.~cl_I();
}
- return shorten(result,len); // verkürzen und fertig
+ return shorten(result,len); // verkürzen und fertig
}
// Bit complexity (N = len): O(log(N)^2*M(N)).
// Using Cohen-Villegas-Zagier acceleration, but without binary splitting.
const cl_LF compute_catalanconst_cvz1 (uintC len)
{
- var uintC actuallen = len+2; // 2 Schutz-Digits
+ var uintC actuallen = len+2; // 2 guard digits
var uintC N = (uintC)(0.39321985*intDsize*actuallen)+1;
#if 0
var cl_LF fterm = cl_I_to_LF(2*(cl_I)N*(cl_I)N,actuallen);
}
var cl_LF result = gsum/cl_I_to_LF(1+fsum,actuallen);
#endif
- return shorten(result,len); // verkürzen und fertig
+ return shorten(result,len); // verkürzen und fertig
}
// Bit complexity (N = len): O(N^2).
// Using Cohen-Villegas-Zagier acceleration, with binary splitting.
const cl_LF compute_catalanconst_cvz2 (uintC len)
{
- var uintC actuallen = len+2; // 2 Schutz-Digits
+ var uintC actuallen = len+2; // 2 guard digits
var uintC N = (uintC)(0.39321985*intDsize*actuallen)+1;
CL_ALLOCA_STACK;
var cl_pqd_series_term* args = (cl_pqd_series_term*) cl_alloca(N*sizeof(cl_pqd_series_term));
? square((cl_I)(2*n+1))
: -square((cl_I)(2*n+1)));
}
- var cl_pqd_series_result sums;
+ var cl_pqd_series_result<cl_I> sums;
eval_pqd_series_aux(N,args,sums);
// Here we need U/(1+S) = V/D(Q+T).
var cl_LF result =
args[n].q.~cl_I();
args[n].d.~cl_I();
}
- return shorten(result,len); // verkürzen und fertig
+ return shorten(result,len); // verkürzen und fertig
}
// Bit complexity (N = len): O(log(N)^2*M(N)).
} series;
var uintC actuallen = len + 2; // 2 guard digits
var uintC N = (intDsize/2)*actuallen;
- var cl_LF fsum = eval_rational_series(N,series,actuallen);
+ var cl_LF fsum = eval_rational_series<false>(N,series,actuallen,actuallen);
var cl_LF g = fsum*cl_I_to_LF(19,actuallen)/cl_I_to_LF(18,actuallen);
return shorten(g,len);
}
const cl_LF catalanconst (uintC len)
{
- var uintC oldlen = TheLfloat(cl_LF_catalanconst)->len; // vorhandene Länge
+ var uintC oldlen = TheLfloat(cl_LF_catalanconst())->len; // vorhandene Länge
if (len < oldlen)
- return shorten(cl_LF_catalanconst,len);
+ return shorten(cl_LF_catalanconst(),len);
if (len == oldlen)
- return cl_LF_catalanconst;
+ return cl_LF_catalanconst();
- // TheLfloat(cl_LF_catalanconst)->len um mindestens einen konstanten Faktor
- // > 1 wachsen lassen, damit es nicht zu häufig nachberechnet wird:
+ // TheLfloat(cl_LF_catalanconst())->len um mindestens einen konstanten Faktor
+ // > 1 wachsen lassen, damit es nicht zu häufig nachberechnet wird:
var uintC newlen = len;
oldlen += floor(oldlen,2); // oldlen * 3/2
if (newlen < oldlen)
newlen = oldlen;
- // gewünschte > vorhandene Länge -> muß nachberechnen:
- cl_LF_catalanconst = compute_catalanconst(newlen);
- return (len < newlen ? shorten(cl_LF_catalanconst,len) : cl_LF_catalanconst);
+ // gewünschte > vorhandene Länge -> muß nachberechnen:
+ cl_LF_catalanconst() = compute_catalanconst(newlen);
+ return (len < newlen ? shorten(cl_LF_catalanconst(),len) : cl_LF_catalanconst());
}
} // namespace cln