// cl_coshsinh_aux().
// 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 "cln/abort.h"
+#include "base/cl_alloca.h"
+#include "cln/exception.h"
#undef floor
#include <cmath>
{
{ Mutable(cl_I,p);
var uintE lp = integer_length(p); // now |p| < 2^lp.
- if (!(lp <= lq)) cl_abort();
+ if (!(lp <= lq)) throw runtime_exception();
lp = lq - lp; // now |p/2^lq| < 2^-lp.
// Minimize lq (saves computation time).
{
// a(n) = 1, b(n) = 1,
// p(0) = p, p(n) = p^2 for n>0,
// q(0) = 2^lq, q(n) = (2*n)*(2*n+1)*(2^lq)^2 for n>0.
- var uintC actuallen = len+1; // 1 Schutz-Digit
- // How many terms to we need for M bits of precision? N/2 terms suffice,
+ var uintC actuallen = len+1; // 1 guard digit
+ // How many terms do we need for M bits of precision? N/2 terms suffice,
// provided that
// 1/(2^(N*lp)*N!) < 2^-M
// <== N*(log(N)-1)+N*lp*log(2) > M*log(2)
CL_ALLOCA_STACK;
var cl_I* pv = (cl_I*) cl_alloca(N*sizeof(cl_I));
var cl_I* qv = (cl_I*) cl_alloca(N*sizeof(cl_I));
- var uintC* qsv = (uintC*) cl_alloca(N*sizeof(uintC));
var uintC n;
var cl_I p2 = square(p);
var cl_LF sinhsum;
init1(cl_I, qv[n]) (((cl_I)n*(cl_I)(2*n+1)) << (2*lq+1));
}
var cl_pq_series series;
- series.pv = pv; series.qv = qv; series.qsv = qsv;
- sinhsum = eval_rational_series(N,series,actuallen);
+ series.pv = pv; series.qv = qv;
+ sinhsum = eval_rational_series<true>(N,series,actuallen);
for (n = 0; n < N; n++) {
pv[n].~cl_I();
qv[n].~cl_I();
init1(cl_I, qv[n]) (((cl_I)n*(cl_I)(2*n-1)) << (2*lq+1));
}
var cl_pq_series series;
- series.pv = pv; series.qv = qv; series.qsv = qsv;
- coshsum = eval_rational_series(N,series,actuallen);
+ series.pv = pv; series.qv = qv;
+ coshsum = eval_rational_series<true>(N,series,actuallen);
for (n = 0; n < N; n++) {
pv[n].~cl_I();
qv[n].~cl_I();
#else // TRIVIAL_SPEEDUP
var cl_LF coshsum = sqrt(cl_I_to_LF(1,actuallen) + square(sinhsum));
#endif
- return cl_LF_cosh_sinh_t(shorten(coshsum,len),shorten(sinhsum,len)); // verkürzen und fertig
+ return cl_LF_cosh_sinh_t(shorten(coshsum,len),shorten(sinhsum,len)); // verkürzen und fertig
}}
// Bit complexity (N = len, and if p has length O(log N) and ql = O(log N)):
// O(log(N)*M(N)).