X-Git-Url: https://ginac.de/CLN/cln.git//cln.git?a=blobdiff_plain;f=src%2Ffloat%2Ftranscendental%2Fcl_LF_catalanconst.cc;h=a68219b6262c8c03634579c898046e10158a6f87;hb=3af2cde18b3aabed4c808b0113daa81c2263b0bd;hp=28fbd2bc799e9de2e6a9caeb1e4d99c5c28259dc;hpb=308a067c421bca5b1966f58b9b06483b8903834e;p=cln.git

diff --git a/src/float/transcendental/cl_LF_catalanconst.cc b/src/float/transcendental/cl_LF_catalanconst.cc
index 28fbd2b..a68219b 100644
--- a/src/float/transcendental/cl_LF_catalanconst.cc
+++ b/src/float/transcendental/cl_LF_catalanconst.cc
@@ -1,19 +1,19 @@
 // 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 {
 
@@ -26,7 +26,7 @@ const cl_LF compute_catalanconst_ramanujan (uintC len)
 	// 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;
@@ -42,7 +42,7 @@ const cl_LF compute_catalanconst_ramanujan (uintC len)
 	              + 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).
 
@@ -80,20 +80,20 @@ const cl_LF compute_catalanconst_ramanujan_fast (uintC len)
 	//   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);
@@ -115,7 +115,7 @@ const cl_LF compute_catalanconst_expintegral1 (uintC len)
 		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).
 
@@ -123,7 +123,7 @@ const cl_LF compute_catalanconst_expintegral1 (uintC len)
 // 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;
@@ -147,14 +147,14 @@ const cl_LF compute_catalanconst_expintegral2 (uintC len)
 		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);
@@ -198,14 +198,14 @@ const cl_LF compute_catalanconst_cvz1 (uintC len)
 	}
 	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));
@@ -217,7 +217,7 @@ const cl_LF compute_catalanconst_cvz2 (uintC len)
 		                        ? 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 =
@@ -227,7 +227,7 @@ const cl_LF compute_catalanconst_cvz2 (uintC len)
 		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)).
 
@@ -266,7 +266,7 @@ const cl_LF compute_catalanconst_lupas (uintC len)
 	} 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);
 }
@@ -300,22 +300,22 @@ const cl_LF compute_catalanconst (uintC 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