31#include "lx_interval.hpp"
41lx_interval::lx_interval(
const real& n,
const string &s)
noexcept
57 const real c1 = 3.3219280948873623;
58 const real c2 = 2.711437152598000E+015;
59 const real c3 = 10000.0;
69 cxscthrow(REAL_NOT_ALLOWED(
70 "lx_interval(const real&, const string& )"));
72 string str1 =
"[", str2 =
"]";
73 q = s.find_first_of(str1);
74 p = s.find_first_of(str2);
75 if (q == -1 || p == -1)
76 cxscthrow(NO_BRACKETS_IN_STRING(
77 "lx_interval(const real&, const string& )"));
78 stagprec = stagprec +1;
90 y = std::floor(_double(y));
93 cxscthrow(REAL_NOT_ALLOWED(
94 "lx_interval(const real&, const string& )"));
95 u =
power( lx_interval(0,l_interval(10)),r );
96 v = lx_interval(ay,l_interval(1));
99 v = lx_interval(ay-c3,l_interval(1));
104 u = u*lx_interval(0,x);
113void scale_down(lx_interval &a)
130void scale_up(lx_interval &a)
148l_interval & l_interval::operator = (
const lx_interval &a)
noexcept
153 l_real lrI(Inf(al)), lrS(Sup(al));
155 if (exa<-100000)
return (*
this) = al;
158 cxscthrow(OVERFLOW_ERROR(
"LX_INTERVAL_UNREALIZABLE_AS_L_INTERVAL: l_interval & operator = (const lx_interval &a)"));
160 if (Inf(al)<0 && lrI>=0)
161 al = SetInf(al,
l_real(0));
162 if (Sup(al)>0 && lrS<=0)
163 al = SetSup(al,
l_real(0));
197 if (
abs(r)<2147483647)
207 Times2pown(ai,-3000);
230 cxscthrow(OVERFLOW_ERROR(
231 "lx_interval expo2zero(lx_interval &)"));
233 res = lx_interval(0.0,la);
239lx_interval::lx_interval(
const lx_real& a,
const lx_real& b)
noexcept
244 bool a_zero(eq_zero(a)), b_zero(eq_zero(b));
246 if (a_zero || b_zero)
250 li = l_interval(0,lr_part(b));
254 li = l_interval(lr_part(a),0);
260 na = expo(a_); nb = expo(b_);
266 li = l_interval(lr_part(a_),lr_part(b_));
275 h = times2powr(lr,-d);
276 li = l_interval(lr_part(a_),Sup(h));
286 h = times2powr(lr,-d);
287 li = l_interval(Inf(h),lr_part(b_));
292lx_interval operator + (
const lx_interval &a,
const lx_interval &b)
noexcept
294 const real c1 = 10000.0;
295 int stagsave = stagprec,
300 if (stagprec>stagmax) stagprec = stagmax;
303 lx_interval res,A(a),B(b);
311 a1 = li_part(A); b1 = li_part(B);
315 if (exa<-100000)
return b;
316 if (exb<-100000)
return a;
365 res = lx_interval(n,a1);
372lx_interval
operator * (
const lx_interval &a,
const lx_interval &b)
noexcept
374 int stagsave = stagprec,
379 if (stagprec > stagmax) stagprec = stagmax;
382 lx_interval a_(a),b_(b),res(0);
387 scale_down(a_); scale_down(b_);
389 al = li_part(a_); bl = li_part(b_);
393 if (exa>-100000 && exb>-100000)
406 d = 1022 - (exa+exb);
413 d = exa + exb - 1022;
459 if (na+nb<-Max_Int_R)
461 diff = (Max_Int_R + na) + nb;
470 res = lx_interval(Max_Int_N,al);
475 res = lx_interval(na,al);
489 res = lx_interval(Max_Int_N,al);
499lx_interval
operator / (
const lx_interval &a,
const lx_interval &b)
502 int stagsave = stagprec,
506 if (stagprec>stagmax) stagprec = stagmax;
510 lx_interval a_(a),b_(b),res;
517 al = li_part(a_); bl = li_part(b_);
523 cxscthrow(ERROR_LINTERVAL_DIV_BY_ZERO(
"lx_interval operator/(const lx_interval &a, const lx_interval &b)"));
525 if (exa < -100000)
return a;
528 bool bl_point( point_intv(bl) );
537 if (0<=exb && exb<=511)
563 if ( (al==0 && z!=0) || Inf(al)>Sup(al) )
564 cxscthrow(OVERFLOW_ERROR(
"TOO_WIDE_INTERVAL_OPERANDS_IN: lx_interval operator / (const lx_interval &a, const lx_interval &b)"));
566 if (na-nb<-Max_Int_R)
568 diff = (Max_Int_R - nb) + na;
577 res = lx_interval(Max_Int_N,al);
584 res = lx_interval(na,al);
598 res = lx_interval(Max_Int_N,al);
609std::string & operator >> (std::string &s, lx_interval &a)
noexcept
620 s = skipwhitespacessinglechar (s,
'{');
622 s = skipwhitespacessinglechar (s,
',');
625 a = lx_interval(exr,s);
631void operator >> (
const std::string &s, lx_interval &a)
noexcept
638void operator >> (
const char *s, lx_interval &a)
noexcept
644bool StrContains(
const string &s,
const char &a,
const char &b)
650 return (ia>=0 || ib>=0);
653std::istream & operator >> (std::istream &s, lx_interval &a)
noexcept
664 skipeolnflag = inpdotflag =
true;
665 c = skipwhitespacessinglechar (s,
'{');
666 if (inpdotflag) s.putback(c);
668 c = skipwhitespacessinglechar (s,
',');
669 if (inpdotflag) s.putback(c);
670 skipeolnflag = inpdotflag =
true;
671 s >> str >> RestoreOpt;
673 while ( !StrContains(str,
']',
'}') )
675 c = skipwhitespaces (s);
676 if (inpdotflag && c !=
'}') s.putback(c);
683 a = lx_interval(exr,str);
687 skipeolnflag =
false; inpdotflag =
true;
688 c = skipwhitespaces (s);
689 if (inpdotflag && c !=
'}')
698void Bin2Dec(
const lx_interval& a, real& p, l_interval& m)
705 const real c1 = 0.301029995663981195;
706 const real c2 = 9.007199254738000E+015;
707 const real c3 = 10000.0;
715 stagprec = stagprec + 1;
727 p = std::floor(_double(p));
729 u = lx_interval(y,l_interval(1));
730 v =
power( lx_interval(0,l_interval(10)),
abs(p) );
733 u = lx_interval(y-c3,l_interval(1));
738 u = u*lx_interval(0,x);
742 l = std::floor(_double(l)) + 1;
744 u = lx_interval(k,l_interval(1)) /
745 power( lx_interval(0,l_interval(10)),l );
746 u = u * lx_interval(0,m);
755std::ostream& operator << (std::ostream& s,
const lx_interval& a)
noexcept
769 << SaveOpt << SetPrecision(0,0) << Fixed << p << RestoreOpt
777std::string & operator << (std::string &s,
const lx_interval &a)
noexcept
781 std::stringstream ss;
784 ss << SaveOpt << SetPrecision(0,0) << Fixed << a.ex << RestoreOpt;
818 if (n_>1020) n_ = 1020;
819 if (n_<-1074) n_ = -1074;
846 lx_real::lx_real(
const real& n,
const string &s)
noexcept
855 const real c1 = 3.3219280948873623;
856 const real c2 = 2.711437152598000E+015;
857 const real c3 = 10000.0;
867 cxscthrow(REAL_NOT_ALLOWED(
868 "lx_real(const real&, const string& )"));
869 stagprec = stagprec +1;
880 y = std::floor(_double(y));
883 cxscthrow(REAL_NOT_ALLOWED(
884 "lx_real(const real&, const string& )"));
885 u =
power( lx_interval(0,l_interval(10)),r );
886 v = lx_interval(ay,l_interval(1));
889 v = lx_interval(ay-c3,l_interval(1));
894 u = u*lx_interval(0,l_interval(x));
895 lr =
mid(li_part(u));
903 std::string & operator >> (std::string &s, lx_real &a)
noexcept
912 s = skipwhitespacessinglechar (s,
'{');
914 s = skipwhitespacessinglechar (s,
',');
923 void operator >> (
const std::string &s, lx_real &a)
noexcept
930 void operator >> (
const char *s, lx_real &a)
noexcept
936 bool Str_Contains(
const string &s,
const char &a,
const char &b)
942 return (ia>=0 || ib>=0);
945 std::istream & operator >> (std::istream &s, lx_real &a)
noexcept
955 skipeolnflag = inpdotflag =
true;
956 c = skipwhitespacessinglechar (s,
'{');
957 if (inpdotflag) s.putback(c);
959 c = skipwhitespacessinglechar (s,
',');
960 if (inpdotflag) s.putback(c);
961 skipeolnflag = inpdotflag =
true;
962 s >> str >> RestoreOpt;
963 while ( !Str_Contains(str,
']',
'}') )
965 c = skipwhitespaces (s);
966 if (inpdotflag && c !=
'}') s.putback(c);
973 a = lx_real(exr,str);
977 skipeolnflag =
false; inpdotflag =
true;
978 c = skipwhitespaces (s);
979 if (inpdotflag && c !=
'}')
986bool operator == (
const lx_real &a,
const lx_real &b)
noexcept
988 const real c1 = 1e20;
989 l_real ar(lr_part(a)), br(lr_part(b));
990 real na(expo(a)), nb(expo(b));
992 bool a_0(exa<-100000), b_0(exb<-100000), res;
995 if (a_0 || b_0) res = (a_0 == b_0);
1003 if (
abs(nb)>Max_Int_R)
1007 Times2pown(ar,z,-d);
1009 if (
abs(na)>Max_Int_R)
1012 res = (na==nb && ar==br);
1017bool operator > (
const lx_real &a,
const lx_real &b)
noexcept
1019 l_real lra(lr_part(a)), lrb(lr_part(b));
1020 bool zero_a(eq_zero(a)), zero_b(eq_zero(b)), bl(
false);
1026 if (zero_a)
return sm_zero(b);
1027 if (zero_b)
return gr_zero(a);
1029 na = expo(a); nb = expo(b);
1039 bl = (sign(lra)>0) ?
true :
false;
1044 Times2pown(lra,z,D);
1052 bl = (sign(lrb)<0) ?
true :
false;
1057 Times2pown(lrb,z,D);
1065void scale_up(lx_real &a)
noexcept
1076 if (d>0 && a.ex >= -Max_Int_R+d)
1078 Times2pown(a.lr,z,d);
1083void scale_down(lx_real &a)
noexcept
1094 if (d<0 && a.ex <= Max_Int_R+d)
1096 Times2pown(a.lr,z,d);
1107 int stagsave = stagprec,
1108 p(StagPrec(x)),ex_gr;
1116 res = lx_real(ex,lr);
1122 if (ex_gr>-10000000)
1129 lr[p] = succ(lr[p]);
1131 res = lx_real(ex,lr);
1138 res = lx_real(-Max_Int_R,lr);
1140 stagprec = stagsave;
1150 int stagsave = stagprec,
1151 p(StagPrec(x)),ex_gr;
1159 res = lx_real(ex,lr);
1165 if (ex_gr>-10000000)
1172 lr[p] = pred(lr[p]);
1174 res = lx_real(ex,lr);
1181 res = lx_real(-Max_Int_R,lr);
1183 stagprec = stagsave;
1187lx_real operator + (
const lx_real &a,
const lx_real &b)
noexcept
1192 const int c2 = 1022,
1194 int stagsave = stagprec,
1199 if (stagprec>stagmax) stagprec = stagmax;
1201 lx_real res(0),A(a),B(b);
1203 a1 = lr_part(A); b1 = lr_part(B);
1207 if (exa<c3)
return b;
1208 if (exb<c3)
return a;
1230 res = lx_real(n,a1);
1232 stagprec = stagsave;
1241 int stagsave = stagprec,
1246 if (stagprec > stagmax) stagprec = stagmax;
1249 lx_real a_(a),b_(b),res(0);
1251 scale_down(a_); scale_down(b_);
1253 al = lr_part(a_); bl = lr_part(b_);
1257 if (exa>-100000 && exb>-100000)
1259 if (exa+exb <= 1022)
1263 Times2pown(al,-exa);
1270 d = 1022 - (exa+exb);
1277 d = exa + exb - 1022;
1323 if (na+nb<-Max_Int_R)
1325 diff = (Max_Int_R + na) + nb;
1326 Times2pown(al,diff);
1327 res = lx_real(-Max_Int_R,al);
1332 res = lx_real(na,al);
1336 stagprec = stagsave;
1343 int stagsave = stagprec,
1347 if (stagprec>stagmax) stagprec = stagmax;
1350 lx_real a_(a),b_(b),res;
1354 al = lr_part(a_); bl = lr_part(b_);
1360 cxscthrow(DIV_BY_ZERO(
"lx_real operator/(const lx_real &a, const lx_real &b)"));
1362 if (exa < -100000)
return a;
1368 if (0<=exb && exb<=511)
1373 Times2pown(bl,-exb);
1385 if (na-nb<-Max_Int_R)
1387 diff = (Max_Int_R - nb) + na;
1388 Times2pown(al,diff);
1389 res = lx_real(-Max_Int_R,al);
1394 res = lx_real(na,al);
1397 stagprec = stagsave;
1403l_real & l_real::operator = (
const lx_real& a)
noexcept
1406 real p(expo(a)), exr;
1409 if (exar<-100000)
return (*
this) = ar;
1412 cxscthrow(OVERFLOW_ERROR(
1413 "LX_REAL_UNREALIZABLE_AS_L_REAL: l_real & operator = (const lx_real& a)"));
1419real & real::operator = (
const lx_real& a)
noexcept
1433real expo_RelDiam(
const l_interval &x)
1447 l_real r1(Inf(x)),r2(Sup(x));
1448 t = lx_interval(r2) - lx_interval(r1);
1454 R = Sup( t / lx_interval(
AbsMin(x) ) );
1456 n = expo(R) +
expo_gr(lr_part(R));
1465lx_interval
sqrt(
const lx_interval &a)
noexcept
1467 int stagsave = stagprec,
1469 if (stagprec>stagmax) stagprec = stagmax;
1473 real na(expo(a)),r(0);
1476 if (exa<-100000) res = 0.0;
1499 res = lx_interval(na,la);
1502 stagprec = stagsave;
1507lx_interval
sqr(
const lx_interval &x)
noexcept
1509 int stagsave = stagprec,
1511 if (stagprec>stagmax) stagprec = stagmax;
1518 else if (Sup(xl) <= 0.0)
1520 y = lx_interval(expo(x),
l_interval(-Sup(xl),-Inf(xl)));
1524 if (
abs(Inf(xl)) >=
abs(Sup(xl)))
1530 stagprec = stagsave;
1535lx_interval Lnp1(
const lx_interval &x)
noexcept
1542 lx_interval res(0),z2,zeta,Ri,Two;
1553 if (expox < 3-27*p-ex) N = 0;
1557 N = (int) _double( (53*p-4)/(2*(1-m)) );
1561 Two = lx_interval(2);
1562 Ri = lx_interval( Sup(
abs(zeta)) );
1570 res = Two / (2*N+1);
1571 for (
int i=N-1; i>=0; --i)
1572 res = res*z2 + Two/(2*i+1);
1574 Ri =
power(Ri,N+1)/(N+1);
1577 res += lx_interval(lx_real(0),Sup(Ri));
1584lx_interval Ln_(
const lx_interval &x)
noexcept
1587 l_interval lx(li_part(x));
1600 if (Sup(
abs(lx))<1e-7)
1615 eps = (
ln(eps) + 6*ln_N[8])/ln_N[0];
1616 k = (int) _double(eps);
1619 for (
int j=1; j<=k; j++)
1630lx_interval
ln(
const lx_interval &x)
noexcept
1632 int stagsave = stagprec,
1634 if (stagprec>stagmax) stagprec = stagmax;
1638 if (Inf(li_part(x))<=0) cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
1639 "lx_interval ln(const lx_interval &)"));
1642 r = expo_RelDiam(li_part(x));
1647 res = lx_interval(Inf(x));
1649 a = lx_interval(Sup(x));
1651 res = lx_interval(Inf(res),Sup(a));
1656 stagprec = stagsave;
1662lx_interval
log2(
const lx_interval &x)
noexcept
1664 int stagsave = stagprec,
1666 if (stagprec>stagmax) stagprec = stagmax;
1670 stagprec = stagsave;
1676lx_interval
log10(
const lx_interval &x)
noexcept
1678 int stagsave = stagprec,
1680 if (stagprec>stagmax) stagprec = stagmax;
1684 stagprec = stagsave;
1690lx_interval Lnp1_(
const lx_interval &x)
noexcept
1692 const real r = 1e-7;
1695 res = (Inf(x)>-r && Sup(x)<r)? Lnp1(x) : Ln_(1.0+x);
1700lx_interval
lnp1(
const lx_interval &x)
noexcept
1702 int stagsave = stagprec,
1704 if (stagprec>stagmax) stagprec = stagmax;
1708 if (Inf(x)<= -1) cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
1709 "lx_interval lnp1(const lx_interval &)"));
1713 r = expo_RelDiam(li_part(x));
1718 res = lx_interval(Inf(x));
1720 a = lx_interval(Sup(x));
1722 res = lx_interval(Inf(res),Sup(a));
1727 stagprec = stagsave;
1737lx_interval Power_(
const lx_interval &x,
const real &n)
noexcept
1743 real one(1.0),zhi(2.0),N(n),r;
1746 lx_interval y,neu,X(x);
1748 if (x == one) y = x;
1750 if (N == 0.0) y = one;
1755 if (N == 2) y =
sqr(x);
1769 dbl = _double(N/zhi);
1770 dbl = std::floor(dbl);
1784lx_interval
power(
const lx_interval &x,
const real &n)
noexcept
1786 int stagsave = stagprec,
1789 cxscthrow(REAL_NOT_ALLOWED(
"lx_interval power(const lx_interval&, const real&)"));
1791 if (stagprec > stagmax)
1797 r = expo_RelDiam(li_part(x));
1802 res = lx_interval(Inf(x));
1803 res = Power_(res,n);
1804 a = lx_interval(Sup(x));
1811 stagprec = stagsave;
1820int Poly_N_Exp(
const lx_interval &x)
1824 lx_interval absx(
abs(x));
1827 real S(-53*StagPrec(x)*ln_N[0]),
1834 c =
add_real(m,expo(absx))*ln_N[0];
1838 D = D + c - ln_N[N-1];
1846lx_interval Exp_(
const lx_interval &x)
noexcept
1851 lx_interval res(1.0),absx,T;
1858 if (Sup(x) <= -6243314768166103.0)
1859 res = lx_interval(lx_real(0),lx_real(-Max_Int_R,l_real(
minreal)));
1863 n = (int) _double( (9*ln_N[8] + m*ln_N[0])/ln_N[0]);
1872 lx_interval *Koff =
new lx_interval[N+1];
1874 for (
int k=1; k<=N; k++)
1875 Koff[k] = Koff[k-1]/k;
1878 for (
int k=N-1; k>=0; k--)
1879 res = res*T + Koff[k];
1882 for (
int k=1; k<=N+1; k++)
1883 Koff[0] = Koff[0]*k;
1884 T = lx_interval( Sup(
abs(T)) );
1885 T = (
power(T,N+1)/Koff[0])/(1-T);
1888 res = res + lx_interval(-S,S);
1891 for (
int k=1; k<=n; k++)
1899lx_interval
exp(
const lx_interval &x)
noexcept
1901 int stagsave = stagprec,
1904 if (stagprec > stagmax)
1906 if (stagprec<3) stagprec = 3;
1911 if (Sup(x)>6243314768166065.0)
1912 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
1913 "lx_interval exp(const lx_interval &x)"));
1914 r = expo_RelDiam(li_part(x));
1919 res = lx_interval(Inf(x));
1921 a = lx_interval(Sup(x));
1923 res = lx_interval(Inf(res),Sup(a));
1928 stagprec = stagsave;
1934lx_interval
exp2(
const lx_interval &x)
noexcept
1936 int stagsave = stagprec,
1938 if (stagprec>stagmax) stagprec = stagmax;
1939 if (stagprec<3) stagprec = 3;
1944 stagprec = stagsave;
1950lx_interval
exp10(
const lx_interval &x)
noexcept
1952 int stagsave = stagprec,
1954 if (stagprec>stagmax) stagprec = stagmax;
1955 if (stagprec<3) stagprec = 3;
1960 stagprec = stagsave;
1966lx_interval
pow(
const lx_interval &x,
const lx_interval &e)
noexcept
1973 int stagsave = stagprec,
1976 lx_real supabse = Sup(
abs(e));
1982 if (supabse < Max_Int_R)
1991 else y =
power(x,r);
1997 if (stagprec < stagmax) stagprec++;
1998 else stagprec = stagmax;
2000 stagprec = stagsave;
2007lx_interval
xp1_pow_y(
const lx_interval &x,
const lx_interval &y)
noexcept
2009 int stagsave = stagprec,
2011 if (stagprec>stagmax) stagprec = stagmax;
2012 lx_interval res, su(1.0+x);
2014 if (point_intv(su) && Sup(su) == 1.0)
2017 if (point_intv(y) && Sup(y) == 1.0)
2020 if (point_intv(y) && Sup(y) == 0.0)
2024 if (stagprec < stagmax) stagprec++;
2025 else stagprec = stagmax;
2027 stagprec = stagsave;
2034int Poly_N_Expm1(
const lx_interval &x)
2038 lx_interval absx(
abs(x));
2040 real S(-53*stagprec*ln_N[0]),
2052 D = D + c - ln_N[N];
2058lx_interval Expm1(
const lx_interval &x)
2063 lx_interval res(0),Fak,D;
2066 N = Poly_N_Expm1(x);
2068 lx_interval *Koff =
new lx_interval[N+1];
2070 for (
int k=1; k<=N; k++)
2071 Koff[k] = Koff[k-1]/(k+1);
2074 for (
int k=N-1; k>=0; k--)
2075 res = res*x + Koff[k];
2078 for (
int k=1; k<=N+2; k++)
2080 D = lx_interval( Sup(
abs(x)) );
2081 D = (
power(D,N+1)/Fak)/(1-D);
2084 res = res + lx_interval(-S,S);
2090lx_interval EXPm1(
const lx_interval &x)
noexcept
2095 int stagsave = stagprec,
2098 if (Sup(
abs(x))<1e-7)
2102 if (stagprec < stagmax) stagprec++;
2105 stagprec = stagsave;
2111lx_interval
expm1(
const lx_interval &x)
noexcept
2114 int stagsave = stagprec,
2116 if (stagprec > stagmax)
2122 r = expo_RelDiam(li_part(x));
2128 res = lx_interval(Inf(x));
2130 a = lx_interval(Sup(x));
2132 res = lx_interval(Inf(res),Sup(a));
2137 stagprec = stagsave;
2145real pot3_n[20] = {3.0, 9.0, 27.0, 81.0, 243.0, 729.0, 2187.0, 6561.0,
2146 19683.0, 59049.0, 177147.0, 531441.0, 1594323.0, 4782969.0,
2147 14348907.0, 43046721.0, 129140163.0, 387420489.0,
2148 1162261467.0, 3486784401.0 };
2152 lx_interval Sin_Rek(
const lx_interval &x,
int n)
2157 for (
int k=1; k<=n; k++)
2166 int Poly_N_Sin(
const lx_interval &x)
2170 lx_interval absx(
abs(x));
2173 real S(-53*stagprec*ln_N[0]),
2179 kr = k + expo(absx);
2185 D = D + c - ln_N[2*N] - ln_N[2*N+1];
2191 l_real floor(
const l_real &x)
2195 int p(StagPrec(y)),k;
2199 if (expo(y[1])>-1000000)
2203 while(expo(y[k])>=53 && k<=p)
2209 z += std::floor(_double(y[k]));
2215 lx_interval
sin(
const lx_interval &x)
noexcept
2219 int stagsave = stagprec,
2222 const real ln2 = 0.6931471806,
2224 ln3r = 0.9102392264,
2233 if (stagprec > stagmax)
2236 lx_interval res(0.0),T,Pi2;
2239 if (Sup(
abs(x))>MaxR)
2256 Pi2 = lx_interval(Inf(x));
2258 res = lx_interval(Inf(T),Sup(x));
2262 Pi2 = lx_interval(Sup(x));
2264 res = lx_interval(Inf(x),Sup(T));
2269 r = expo_RelDiam(li_part(x));
2286 r = expo( Sup(
abs(z)) );
2287 n = (int) _double((r*ln2 + 8*ln10)*ln3r);
2292 T = T / pot3_n[n-1];
2298 lx_interval *Koff =
new lx_interval[N+1];
2300 for (
int k=1; k<=N; k++)
2303 Koff[k] = -Koff[k-1]/(m*(m+1));
2306 res = Koff[N]; Pi2 =
sqr(T);
2307 for (
int k=N-1; k>=0; k--)
2308 res = res*Pi2 + Koff[k];
2311 for (
int k=1; k<=N+1; k++)
2314 Koff[0] = Koff[0]*m*(m+1);
2316 Pi2 = lx_interval( Sup(
abs(T)) );
2318 Pi2 =
power(Pi2,N+1)/Koff[0];
2321 res = res + lx_interval(-S,S);
2326 res = Sin_Rek(res,n);
2332 stagprec = stagsave;
2334 S = Sup(res); Si = Inf(res);
2335 if (S>1.0) { S = 1.0; bl =
true; }
2336 if (Si<-1.0) { Si = -1.0; bl =
true; }
2338 res = lx_interval(Si,S);
2344 lx_interval
sin_n(
const lx_interval &x,
const real& n)
noexcept
2347 int stagsave = stagprec,
2349 if (stagprec > stagmax)
2354 cxscthrow(REAL_NOT_ALLOWED(
"lx_interval sin_n(const lx_interval&, const real&)"));
2361 stagprec = stagsave;
2367 lx_interval
cos(
const lx_interval &x)
noexcept
2370 int stagsave = stagprec,
2372 if (stagprec > stagmax)
2378 if (li_part(x)==0) res = 1.0;
2387 stagprec = stagsave;
2390 S = Sup(res); Si = Inf(res);
2391 if (S>1.0) { S = 1.0; bl =
true; }
2392 if (Si<-1.0) { Si = -1.0; bl =
true; }
2394 res = lx_interval(Si,S);
2400 lx_interval
cos_n(
const lx_interval &x,
const real& n)
noexcept
2403 int stagsave = stagprec,
2405 if (stagprec > stagmax)
2410 cxscthrow(REAL_NOT_ALLOWED(
"lx_interval cos_n(const lx_interval&, const real&)"));
2416 stagprec = stagsave;
2422 lx_interval
tan(
const lx_interval& x)
noexcept
2426 if (li_part(x) == 0)
2433 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
"lx_interval tan(const lx_interval &x)"));
2440 lx_interval
cot(
const lx_interval & x)
noexcept
2447 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
"lx_interval cot(const lx_interval &x)"));
2458 lx_interval y(
abs(x));
2462 if (ext>-1000000 && ex>c)
2463 y = lx_interval(Inf(x),
upper_bnd(Sup(x)));
2468 y = (ex<-c)? 1.0 + lx_interval(lx_real(0),Sup(y)) :
sqrt(1+
sqr(y));
2473 int Poly_N_Atan(
const lx_interval &x)
2477 lx_interval absx(
abs(x));
2480 real S(-53*stagprec*ln_N[0]),
2485 D = ex + expo(absx);
2487 D = 2*D*ln_N[0] - ln_N[1];
2490 D = (2*N+2)*c - ln_N[2*N+1];
2496 lx_interval Atan_(
const lx_interval &x)
noexcept
2504 lx_interval res(0.0),T,T2;
2505 l_interval xl(li_part(x));
2513 if (
abs(Inf(res))>lx_real(2092,8.567562) )
2518 if (neg) res = -res;
2524 T2 = lx_interval(Inf(x));
2526 res = lx_interval(Inf(T),Sup(x));
2530 T2 = lx_interval(Sup(x));
2532 res = lx_interval(Inf(x),Sup(T));
2538 m = (int) _double( (ln_N[0]+c*ln_N[8])/ln_N[0] );
2541 m = (int) _double((c*ln_N[8] + ex*ln_N[0])/ln_N[0]);
2544 for (
int k=1; k<=m; k++)
2550 lx_interval *Koff =
new lx_interval[N+1];
2552 for (
int k=1; k<=N; k++)
2554 Koff[k] = lx_interval(0,l_interval(1))/ (2*k+1);
2555 if (k%2 != 0) Koff[k] = -Koff[k];
2560 for (
int k=N-1; k>=0; k--)
2561 res = res*T2 + Koff[k];
2563 T2 = lx_interval( Sup(
abs(T)) );
2565 T2 =
power(T2,N+1)/(2*N+3);
2569 res += lx_interval(-Xl,Xl);
2579 lx_interval
atan(
const lx_interval &x)
noexcept
2581 int stagsave = stagprec,
2584 if (stagprec > stagmax)
2590 r = expo_RelDiam(li_part(x));
2595 res = lx_interval(Inf(x));
2597 a = lx_interval(Sup(x));
2599 res = lx_interval(Inf(res),Sup(a));
2604 stagprec = stagsave;
2612 lx_interval Sqrt1mx2_(
const lx_interval &x)
noexcept
2620 l_interval li(li_part(x));
2629 res = lx_interval(-1023,l_interval(comp(0.5,1024)));
2633 res = lx_interval(-1023,li);
2637 res = (ex>=-exl)?
sqrt( (1-x)*(1+x) ) :
sqrt( 1-
sqr(x) );
2644 int stagsave = stagprec,
2647 if (stagprec > stagmax) stagprec = stagmax;
2648 if (stagprec==1) stagprec++;
2650 lx_interval res(
abs(x)),a;
2653 r = expo_RelDiam(li_part(res));
2658 a = lx_interval(Inf(res));
2661 res = lx_interval(Sup(res));
2662 res = Sqrt1mx2_(res);
2664 res = lx_interval(Inf(res),Sup(a));
2667 res = Sqrt1mx2_(res);
2669 stagprec = stagsave;
2681 int stagsave = stagprec,
2684 if (stagprec>stagmax) stagprec = stagmax;
2686 lx_interval u(
abs(x)),res;
2688 lx_real Infu(Inf(u));
2692 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
2693 "lx_interval sqrtx2m1(const lx_interval &x)"));
2697 res = u + lx_interval(lx_real(-1),lx_real(0));
2700 res =
sqrt( (u-1)*(u+1) );
2701 if (Inf(res)<=0 && Infu>1)
2703 u = lx_interval(Infu);
2707 res = lx_interval( Inf(u), Sup(res) );
2711 stagprec = stagsave;
2719 lx_interval Asin_(
const lx_interval& x)
noexcept
2723 lx_interval y,pihalbe,h;
2731 real supabsz = Sup(
abs(z)),
2738 if (infz == supz && supz == 0)
2741 if (infz == supz && supabsz == 1)
2767 lx_interval
asin(
const lx_interval &x)
noexcept
2769 int stagsave = stagprec,
2772 if (stagprec > stagmax)
2778 if (Inf(x)<-1 || Sup(x)>1)
2779 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
2780 (
"lx_interval asin(const lx_interval& x)"));
2782 r = expo_RelDiam(li_part(x));
2787 res = lx_interval(Inf(x));
2789 a = lx_interval(Sup(x));
2791 res = lx_interval(Inf(res),Sup(a));
2796 stagprec = stagsave;
2804 lx_interval Acos_(
const lx_interval& x)
noexcept
2809 lx_interval y,pihalbe,pi;
2817 real supabsz = Sup(
abs(z)),
2825 if (infz == supz && supz == 0)
2828 if (infz == supz && supabsz == 1)
2847 if (neg) y = pi - y;
2854 lx_interval
acos(
const lx_interval &x)
noexcept
2857 int stagsave = stagprec,
2860 if (stagprec > stagmax)
2866 if (Inf(x)<-1 || Sup(x)>1)
2867 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
2868 (
"lx_interval acos(const lx_interval& x)"));
2870 r = expo_RelDiam(li_part(x));
2875 res = lx_interval(Inf(x));
2877 a = lx_interval(Sup(x));
2879 res = lx_interval(Inf(a),Sup(res));
2884 stagprec = stagsave;
2893 lx_interval Acot_(
const lx_interval& x)
noexcept
2900 lx_interval y,pihalbe,pi;
2903 l_interval xl(li_part(x));
2911 y = pihalbe -
atan(x);
2921 y = pihalbe -
atan(y);
2923 if (neg) y = pi - y;
2929 lx_interval
acot(
const lx_interval &x)
noexcept
2932 int stagsave = stagprec,
2935 if (stagprec > stagmax)
2941 r = expo_RelDiam(li_part(x));
2946 res = lx_interval(Inf(x));
2948 a = lx_interval(Sup(x));
2950 res = lx_interval(Inf(a),Sup(res));
2955 stagprec = stagsave;
2963 lx_interval Sinh_(
const lx_interval &x)
noexcept
2968 lx_interval res(0.0),T;
2969 l_interval xl(li_part(x));
2978 res = -T*(1+1/(T+1));
2985 res = -T*(1+1/(T+1));
2998 res += l_interval(-0.5,0);
3006 if (neg) res = -res;
3012 lx_interval
sinh(
const lx_interval &x)
noexcept
3014 int stagsave = stagprec,
3017 if (stagprec > stagmax)
3023 r = expo_RelDiam(li_part(x));
3028 res = lx_interval(Inf(x));
3030 a = lx_interval(Sup(x));
3032 res = lx_interval(Inf(res),Sup(a));
3037 stagprec = stagsave;
3045 lx_interval Cosh_(
const lx_interval& x)
noexcept
3063 y += l_interval(0,0.5);
3071 if (Si<1.0) y = lx_interval(lx_real(1.0),Sup(y));
3076 lx_interval
cosh(
const lx_interval &x)
noexcept
3078 int stagsave = stagprec,
3081 if (stagprec > stagmax)
3084 lx_interval res,a,y(
abs(x));
3087 r = expo_RelDiam(li_part(y));
3092 res = lx_interval(Inf(y));
3094 a = lx_interval(Sup(y));
3096 res = lx_interval(Inf(res),Sup(a));
3101 stagprec = stagsave;
3109 lx_interval Tanh_(
const lx_interval& x)
noexcept
3117 l_interval xl(li_part(x));
3139 ex = expo(Iy); exl =
expo_gr(lr_part(Iy));
3155 lx_interval
tanh(
const lx_interval &x)
noexcept
3157 int stagsave = stagprec,
3160 if (stagprec > stagmax)
3166 r = expo_RelDiam(li_part(x));
3171 res = lx_interval(Inf(x));
3173 a = lx_interval(Sup(x));
3175 res = lx_interval(Inf(res),Sup(a));
3180 stagprec = stagsave;
3188 lx_interval Coth_(
const lx_interval& x)
noexcept
3197 l_interval xl(li_part(x));
3210 ex = expo(Iy); exl =
expo_gr(lr_part(Iy));
3225 lx_interval
coth(
const lx_interval &x)
noexcept
3228 int stagsave = stagprec,
3231 if (stagprec > stagmax)
3236 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3237 (
"lx_interval coth(const lx_interval& x)"));
3239 lx_interval res,a,y(x);
3241 bool neg(Sup(xl)<0);
3245 r = expo_RelDiam(xl);
3250 res = lx_interval(Inf(y));
3252 a = lx_interval(Sup(y));
3254 res = lx_interval(Inf(a),Sup(res));
3258 if (neg) res = -res;
3260 stagprec = stagsave;
3268 lx_interval Sqrtp1m1_(
const lx_interval& x)
noexcept
3273 lx_interval y(0),tmp;
3274 l_interval xl(li_part(x));
3289 y = (z<=interval(-c,c))? x/(
sqrt(tmp)+1) :
sqrt(tmp)-1;
3298 int stagsave = stagprec,
3302 if (stagprec>stagmax) stagprec = stagmax;
3307 r = expo_RelDiam(li_part(x));
3312 res = lx_interval(Inf(x));
3313 res = Sqrtp1m1_(res);
3314 a = lx_interval(Sup(x));
3316 res = lx_interval(Inf(res),Sup(a));
3321 stagprec = stagsave;
3330 lx_interval Asinh_(
const lx_interval &x)
noexcept
3336 l_interval xl(li_part(x));
3356 std::cout <<
"Hallo: (1-u)*(1+u)*res" << std::endl;
3359 S1 = Inf( (1-u)*(1+u)*res );
3360 res = lx_interval(S1,S2);
3365 if (neg) res = -res;
3371 lx_interval
asinh(
const lx_interval &x)
noexcept
3373 int stagsave = stagprec,
3375 if (stagprec>stagmax)
3381 r = expo_RelDiam(li_part(x));
3386 res = lx_interval(Inf(x));
3388 a = lx_interval(Sup(x));
3390 res = lx_interval(Inf(res),Sup(a));
3394 stagprec = stagsave;
3402 lx_interval
acosh(
const lx_interval &x)
noexcept
3405 int stagsave = stagprec,
3408 if (stagprec > stagmax)
3410 lx_interval res(0.0),x_1;
3415 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3416 (
"lx_interval acosh(const lx_interval& x)"));
3424 if (ex <= -exl-1600)
3428 res =
sqrt(res - 2);
3432 res = lx_interval(S1,S2);
3435 res = (ex<=-exl)?
lnp1( x_1 +
sqrt(x_1*(2+x_1)) ) :
3438 stagprec = stagsave;
3446 lx_interval Acoshp1_(
const lx_interval &x)
noexcept
3452 lx_interval res(0.0);
3457 l_interval xl(li_part(x));
3461 if (ex <= -exl-1600)
3469 res = lx_interval(S1,S2);
3483 lx_interval
acoshp1(
const lx_interval &x)
noexcept
3487 int stagsave = stagprec,
3489 if (stagprec>stagmax)
3493 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3494 (
"lx_interval acoshp1(const lx_interval& x)"));
3498 r = expo_RelDiam(lix);
3503 res = lx_interval(Inf(x));
3504 res = Acoshp1_(res);
3505 a = lx_interval(Sup(x));
3507 res = lx_interval(Inf(res),Sup(a));
3512 stagprec = stagsave;
3520 lx_interval Atanh_(
const lx_interval &x)
noexcept
3526 lx_interval res(0.0);
3528 l_interval xl(li_part(x));
3546 res =
ln( (1.0+x)/(1.0-x) );
3554 lx_interval
atanh(
const lx_interval &x)
noexcept
3556 int stagsave = stagprec,
3558 if (stagprec>stagmax)
3564 if (Inf(x)<=-1 || Sup(x)>=1)
3565 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3566 (
"lx_interval atanh(const lx_interval& x)"));
3568 r = expo_RelDiam(li_part(x));
3573 res = lx_interval(Inf(x));
3575 a = lx_interval(Sup(x));
3577 res = lx_interval(Inf(res),Sup(a));
3582 stagprec = stagsave;
3590 lx_interval Atanh1m_(
const lx_interval &x)
noexcept
3596 lx_interval res(0.0);
3603 lx_interval
atanh1m(
const lx_interval &x)
noexcept
3606 int stagsave = stagprec,
3608 if (stagprec > stagmax)
3611 if (Inf(x)<=0 || Sup(x)>=2)
3612 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3613 (
"lx_interval atanh1m(const lx_interval& x)"));
3618 r = expo_RelDiam(li_part(x));
3623 res = lx_interval(Inf(x));
3624 res = Atanh1m_(res);
3625 a = lx_interval(Sup(x));
3627 res = lx_interval(Inf(a),Sup(res));
3632 stagprec = stagsave;
3643 int stagsave = stagprec,
3645 if (stagprec > stagmax)
3651 stagprec = stagsave;
3659 lx_interval Acoth_(
const lx_interval& x)
noexcept
3667 res =
lnp1(2/(x-1));
3673 lx_interval
acoth(
const lx_interval &x)
noexcept
3676 int stagsave = stagprec,
3678 if (stagprec > stagmax) stagprec = stagmax;
3680 lx_interval res,a,u;
3686 if ( (Inf(x) <= res) || ((Sup(x)) <= res) || res <= x)
3687 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3688 (
"lx_interval acoth(const lx_interval& x)"));
3693 r = expo_RelDiam(xl);
3698 res = lx_interval(Inf(u));
3700 a = lx_interval(Sup(u));
3702 res = lx_interval(Inf(a),Sup(res));
3706 if (neg) res = -res;
3708 stagprec = stagsave;
3716 lx_interval Acothp1_(
const lx_interval& x)
noexcept
3730 lx_interval
acothp1(
const lx_interval &x)
noexcept
3733 int stagsave = stagprec,
3736 if (stagprec > stagmax)
3744 cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3745 (
"lx_interval acothp1(const lx_interval& x)"));
3747 r = expo_RelDiam(xl);
3752 res = lx_interval(Inf(x));
3753 res = Acothp1_(res);
3754 a = lx_interval(Sup(x));
3756 res = lx_interval(Inf(a),Sup(res));
3761 stagprec = stagsave;
3772 int stagsave = stagprec,
3774 if (stagprec > stagmax)
3780 stagprec = stagsave;
3788 lx_interval Sqrtx2y2_(
const lx_interval &x,
const lx_interval &y)
noexcept
3798 lx_interval res,ax,ay;
3810 exxl = exxl-exyl-1051;
3811 if (exy < exx + (exxl-1))
3817 if (exx<-9007199254735000.0)
3831 lx_interval
sqrtx2y2(
const lx_interval &x,
const lx_interval &y)
noexcept
3833 int stagsave = stagprec,
3836 if (stagprec>stagmax)
3841 lx_interval res,ax,ay,u,v;
3845 ax =
abs(x); ay =
abs(y);
3846 if ( Sup(ay) > Sup(ax) )
3848 res = ax; ax = ay; ay = res;
3868 exxl = exxl-exyl-1051;
3869 if (ry < rx + (exxl-1))
3874 if (rx < -9007199254735000.0)
3889 res = lx_interval(Inf(ay),Sup(res));
3893 rx = expo_RelDiam(li_part(ax));
3894 ry = expo_RelDiam(li_part(ay));
3895 if (rx > -107 || ry > -107)
3899 u = lx_interval(Inf(ax));
3900 v = lx_interval(Inf(ay));
3901 res = Sqrtx2y2_(u,v);
3902 u = lx_interval(Sup(ax));
3903 v = lx_interval(Sup(ay));
3905 res = lx_interval(Inf(res),Sup(u));
3908 res = Sqrtx2y2_(ax,ay);
3911 stagprec = stagsave;
3918 lx_interval Ln_sqrtx2y2_(
const lx_interval &x,
const lx_interval &y)
noexcept
3922 lx_interval res,ax,ay;
3925 ax =
abs(x); ay =
abs(y);
3926 Rx = Sup(ax); Ry = Sup(ay);
3930 res = ay; ay = ax; ax = res;
3946 res =
lnp1((ax-1)*(ax+1) + ay*ay);
3954 lx_interval
ln_sqrtx2y2(
const lx_interval &x,
const lx_interval &y)
noexcept
3956 int stagsave = stagprec,
3958 if (stagprec>stagmax) stagprec = stagmax;
3960 lx_interval res,ax,ay,u,v;
3963 ax =
abs(x); ay =
abs(y);
3964 if ( Sup(ay) > Sup(ax) )
3966 res = ax; ax = ay; ay = res;
3969 rx = expo_RelDiam(li_part(ax));
3970 ry = expo_RelDiam(li_part(ay));
3971 if (rx > -107 || ry > -107)
3975 u = lx_interval(Inf(ax));
3976 v = lx_interval(Inf(ay));
3977 res = Ln_sqrtx2y2_(u,v);
3979 u = lx_interval(Sup(ax));
3980 v = lx_interval(Sup(ay));
3981 u = Ln_sqrtx2y2_(u,v);
3983 res = lx_interval(Inf(res),Sup(u));
3986 res = Ln_sqrtx2y2_(ax,ay);
3988 stagprec = stagsave;
3996 lx_interval Sqrt_(
const lx_interval& x,
int n)
noexcept
4004 if (eq_zero(Inf(x)))
4009 res =
pow(lx_interval(Sx),1/lx_interval(n));
4010 res = lx_interval(lx_real(0),Sup(res));
4015 res =
pow(x,1/lx_interval(n));
4020 lx_interval
sqrt(
const lx_interval &x,
int n)
noexcept
4022 int stagsave = stagprec,
4025 if (stagprec>stagmax) stagprec = stagmax;
4032 r = expo_RelDiam(li_part(x));
4037 res = lx_interval(Inf(x));
4039 a = lx_interval(Sup(x));
4041 res = lx_interval(Inf(res),Sup(a));
4046 stagprec = stagsave;
4055 static real CXSC_Pi[40];
4056 static bool CXSC_Pi_initialized =
false;
4062 int stagsave = stagprec,
4064 if (!CXSC_Pi_initialized)
4067 std::cout << SaveOpt;
4069 str =
"+1921FB54442D18e7FC";
4071 str =
"+11A62633145C07e7C6";
4073 str =
"-1F1976B7ED8FBCe78E";
4075 str =
"+14CF98E804177De758";
4077 str =
"+131D89CD9128A5e722";
4079 str =
"+10F31C6809BBDFe6E8";
4081 str =
"+1519B3CD3A431Be6B1";
4083 str =
"+18158536F92F8Ae67A";
4085 str =
"+1BA7F09AB6B6A9e642";
4087 str =
"-1EDD0DBD2544CFe60A";
4089 str =
"+179FB1BD1310BAe5D3";
4091 str =
"+1A637ED6B0BFF6e59D";
4093 str =
"-1A485FCA40908Ee566";
4095 str =
"-1E501295D98169e52F";
4097 str =
"-1160DBEE83B4E0e4F9";
4099 str =
"-19B6D799AE131Ce4C1";
4101 str =
"+16CF70801F2E28e48B";
4103 str =
"+163BF0598DA483e455";
4105 str =
"+1871574E69A459e41F";
4107 str =
"-15C0B6CC281F27e3E3";
4109 str =
"+15D23DCA3AD962e3AD";
4111 str =
"-1CE8654EFBD56Ae376";
4113 str =
"-1184AB5BE23DA6e33F";
4115 str =
"+166D670C354E4Be309";
4117 str =
"-10D9FEC3A2E4FEe2D3";
4119 str =
"+1943042F86520Ce29C";
4121 str =
"-1B9D1C931C41C6e265";
4123 str =
"-188D3E7F179FC6e22D";
4125 str =
"-1361F1744FE176e1F7";
4127 str =
"+1F6B8ABBE0DE99e1C0";
4129 str =
"-169B10EA1A04B5e18A";
4131 str =
"-14FD1CF8CD56D0e154";
4133 str =
"-18AB54A8D7516Fe11E";
4135 str =
"+186263E8144056e0E7";
4137 str =
"-1AE34AEAAA77A5e0B0";
4139 str =
"+16998B8682283De07A";
4141 str =
"+19D42A90D5EF8Ee042";
4143 str =
"+174C9D9F70A08Be00C";
4145 str =
"+100000000000DBe000";
4147 str =
"+100000000000DCe000";
4150 CXSC_Pi_initialized =
true;
4151 std::cout << RestoreOpt;
4156 for (
int i=0; i<=stagmax; i++)
4157 y[i+1] = CXSC_Pi[i];
4159 stagprec = stagsave;
4162 return lx_interval(-1020,y);
4166 static real CXSC_Ln2[40];
4167 static bool CXSC_Ln2_initialized =
false;
4173 int stagsave = stagprec,
4175 if (!CXSC_Ln2_initialized)
4178 std::cout << SaveOpt;
4180 str =
"+162E42FEFA39EFe7FC";
4182 str =
"+1ABC9E3B39803Fe7C5";
4184 str =
"+17B57A079A1934e78E";
4186 str =
"-1ACE93A4EBE5D1e758";
4188 str =
"-123A2A82EA0C24e722";
4190 str =
"+1D881B7AEB2615e6EB";
4192 str =
"+19552FB4AFA1B1e6B5";
4194 str =
"+1DA5D5C6B82704e67C";
4196 str =
"+14427573B29117e645";
4198 str =
"-191F6B05A4D7A7e60F";
4200 str =
"-1DB5173AE53426e5D9";
4201 str >> CXSC_Ln2[10];
4202 str =
"+11317C387EB9EBe5A1";
4203 str >> CXSC_Ln2[11];
4204 str =
"-190F13B267F137e56B";
4205 str >> CXSC_Ln2[12];
4206 str =
"+16FA0EC7657F75e535";
4207 str >> CXSC_Ln2[13];
4208 str =
"-1234C5E1398A6Be4FF";
4209 str >> CXSC_Ln2[14];
4210 str =
"+1195EBBF4D7A70e4C8";
4211 str >> CXSC_Ln2[15];
4212 str =
"+18192432AFD0C4e492";
4213 str >> CXSC_Ln2[16];
4214 str =
"-1A1BE38BA4BA4De45C";
4215 str >> CXSC_Ln2[17];
4216 str =
"-1D7860151CFC06e422";
4217 str >> CXSC_Ln2[18];
4218 str =
"+19423F6B7F720Ce3EC";
4219 str >> CXSC_Ln2[19];
4220 str =
"+10D30F88FE551Ae3B5";
4221 str >> CXSC_Ln2[20];
4222 str =
"+1772B4EB6FE0F8e37E";
4223 str >> CXSC_Ln2[21];
4224 str =
"-17AA0B477087B0e347";
4225 str >> CXSC_Ln2[22];
4226 str =
"+1672C2E8C0EEBBe30C";
4227 str >> CXSC_Ln2[23];
4228 str =
"+1C4C872E4A1F3Ae2D6";
4229 str >> CXSC_Ln2[24];
4230 str =
"-1A970C65986667e2A0";
4231 str >> CXSC_Ln2[25];
4232 str =
"-18CD36365759DAe26A";
4233 str >> CXSC_Ln2[26];
4234 str =
"+1A1E0BD1D6095De231";
4235 str >> CXSC_Ln2[27];
4236 str =
"+12B34D999AB252e1FA";
4237 str >> CXSC_Ln2[28];
4238 str =
"-1912AC700EB43De1C4";
4239 str >> CXSC_Ln2[29];
4240 str =
"-1B8BEFC5924FF5e18E";
4241 str >> CXSC_Ln2[30];
4242 str =
"-180C2AE79DBFADe156";
4243 str >> CXSC_Ln2[31];
4244 str =
"-17D195E5A6D545e120";
4245 str >> CXSC_Ln2[32];
4246 str =
"-1743270F423129e0EA";
4247 str >> CXSC_Ln2[33];
4248 str =
"+189E6DB6303659e0B2";
4249 str >> CXSC_Ln2[34];
4250 str =
"-1F0E11945C9A4Ae07C";
4251 str >> CXSC_Ln2[35];
4252 str =
"+18DAFA85A8C283e046";
4253 str >> CXSC_Ln2[36];
4254 str =
"+13062D3458B6CFe00F";
4255 str >> CXSC_Ln2[37];
4256 str =
"-10000000000C9Be000";
4257 str >> CXSC_Ln2[38];
4258 str =
"-10000000000C9Ae000";
4259 str >> CXSC_Ln2[39];
4261 CXSC_Ln2_initialized =
true;
4262 std::cout << RestoreOpt;
4267 for (
int i=0; i<=stagmax; i++)
4268 y[i+1] = CXSC_Ln2[i];
4270 stagprec = stagsave;
4273 return lx_interval(-1022,y);
4276 static real CXSC_Ln10[40];
4277 static bool CXSC_Ln10_initialized =
false;
4283 int stagsave = stagprec,
4285 if (!CXSC_Ln10_initialized)
4288 std::cout << SaveOpt;
4290 str =
"+126BB1BBB55516e7FD";
4291 str >> CXSC_Ln10[0];
4292 str =
"-1F48AD494EA3E9e7C7";
4293 str >> CXSC_Ln10[1];
4294 str =
"-19EBAE3AE0260Ce791";
4295 str >> CXSC_Ln10[2];
4296 str =
"-12D10378BE1CF1e75B";
4297 str >> CXSC_Ln10[3];
4298 str =
"+10403E05AE52C6e725";
4299 str >> CXSC_Ln10[4];
4300 str =
"-1FA509CAFDF466e6ED";
4301 str >> CXSC_Ln10[5];
4302 str =
"-1C79A1FE9D0795e6B7";
4303 str >> CXSC_Ln10[6];
4304 str =
"+1058C448308218e681";
4305 str >> CXSC_Ln10[7];
4306 str =
"-1D250470877BFDe64A";
4307 str >> CXSC_Ln10[8];
4308 str =
"-1AE92987D3075De612";
4309 str >> CXSC_Ln10[9];
4310 str =
"-1D5CDBB8626956e5DC";
4311 str >> CXSC_Ln10[10];
4312 str =
"-13C4F27CE0410Ae5A6";
4313 str >> CXSC_Ln10[11];
4314 str =
"+1B3AC12ACF1BE9e570";
4315 str >> CXSC_Ln10[12];
4316 str =
"+1161BB49D219C8e53A";
4317 str >> CXSC_Ln10[13];
4318 str =
"-110D6613293728e504";
4319 str >> CXSC_Ln10[14];
4320 str =
"+142163A4CDA351e4CC";
4321 str >> CXSC_Ln10[15];
4322 str =
"+1E2713D6C22C16e494";
4323 str >> CXSC_Ln10[16];
4324 str =
"-15090EF85CB0ADe45B";
4325 str >> CXSC_Ln10[17];
4326 str =
"-1C5B3E859F876Ee424";
4327 str >> CXSC_Ln10[18];
4328 str =
"-1C0D54B14459D9e3EC";
4329 str >> CXSC_Ln10[19];
4330 str =
"+1AB685CD44E2C3e3B5";
4331 str >> CXSC_Ln10[20];
4332 str =
"+1A47ECB26978C6e37E";
4333 str >> CXSC_Ln10[21];
4334 str =
"-15812716B8AD41e347";
4335 str >> CXSC_Ln10[22];
4336 str =
"-16047E37E81868e311";
4337 str >> CXSC_Ln10[23];
4338 str =
"+1E14126A45765De2DA";
4339 str >> CXSC_Ln10[24];
4340 str =
"-10ECBE631205C0e2A3";
4341 str >> CXSC_Ln10[25];
4342 str =
"-15A485363BE7D4e26C";
4343 str >> CXSC_Ln10[26];
4344 str =
"-1DEDE455922FF8e234";
4345 str >> CXSC_Ln10[27];
4346 str =
"-1C202C3AE8B719e1FE";
4347 str >> CXSC_Ln10[28];
4348 str =
"-148E3DB9B96D03e1C7";
4349 str >> CXSC_Ln10[29];
4350 str =
"+1E3795D1008FE3e191";
4351 str >> CXSC_Ln10[30];
4352 str =
"-13C992BD5AD855e158";
4353 str >> CXSC_Ln10[31];
4354 str =
"-152096175A0882e122";
4355 str >> CXSC_Ln10[32];
4356 str =
"+1BB0274A1CB072e0EB";
4357 str >> CXSC_Ln10[33];
4358 str =
"-1D6A3FC0087494e0B4";
4359 str >> CXSC_Ln10[34];
4360 str =
"+1AD6BFBFFD821Ce07E";
4361 str >> CXSC_Ln10[35];
4362 str =
"-17D6CD3EE64A79e048";
4363 str >> CXSC_Ln10[36];
4364 str =
"-166DC44198DC68e010";
4365 str >> CXSC_Ln10[37];
4366 str =
"-100000000012D2e000";
4367 str >> CXSC_Ln10[38];
4368 str =
"-100000000012D1e000";
4369 str >> CXSC_Ln10[39];
4371 CXSC_Ln10_initialized =
true;
4372 std::cout << RestoreOpt;
4377 for (
int i=0; i<=stagmax; i++)
4378 y[i+1] = CXSC_Ln10[i];
4380 stagprec = stagsave;
4383 return lx_interval(-1021,y);
4386 static real CXSC_Pir[40];
4387 static bool CXSC_Pir_initialized =
false;
4393 int stagsave = stagprec,
4395 if (!CXSC_Pir_initialized)
4398 std::cout << SaveOpt;
4400 str =
"+145F306DC9C883e7FC";
4402 str =
"-16B01EC5417056e7C6";
4404 str =
"-16447E493AD4CEe790";
4406 str =
"+1E21C820FF28B2e75A";
4408 str =
"-1508510EA79237e723";
4410 str =
"+1B8E909374B802e6EB";
4412 str =
"-1B6D115F62E6DEe6B5";
4414 str =
"-180F10A71A76B3e67E";
4416 str =
"+1CFBA208D7D4BBe647";
4418 str =
"-12EDEC598E3F65e60F";
4420 str =
"-1741037D8CDC54e5D8";
4421 str >> CXSC_Pir[10];
4422 str =
"+1CC1A99CFA4E42e5A2";
4423 str >> CXSC_Pir[11];
4424 str =
"+17E2EF7E4A0EC8e56B";
4425 str >> CXSC_Pir[12];
4426 str =
"-1DA00087E99FC0e52F";
4427 str >> CXSC_Pir[13];
4428 str =
"-10D0EE74A5F593e4F9";
4429 str >> CXSC_Pir[14];
4430 str =
"+1F6D367ECF27CBe4C1";
4431 str >> CXSC_Pir[15];
4432 str =
"+136E9E8C7ECD3De488";
4433 str >> CXSC_Pir[16];
4434 str =
"-100AE9456C229Ce452";
4435 str >> CXSC_Pir[17];
4436 str =
"-141A0E84C2F8C6e419";
4437 str >> CXSC_Pir[18];
4438 str =
"-10EB5ADA2B2809e3E0";
4439 str >> CXSC_Pir[19];
4440 str =
"-10277039517BD5e3AA";
4441 str >> CXSC_Pir[20];
4442 str =
"+198237E3DB5D60e36E";
4443 str >> CXSC_Pir[21];
4444 str =
"-1E6087BECA1794e338";
4445 str >> CXSC_Pir[22];
4446 str =
"+1DA9E391615EE6e301";
4447 str >> CXSC_Pir[23];
4448 str =
"+1B086599855F15e2C9";
4449 str >> CXSC_Pir[24];
4450 str =
"-17E5EFDC8009E0e293";
4451 str >> CXSC_Pir[25];
4452 str =
"+135CC9CC418185e25B";
4453 str >> CXSC_Pir[26];
4454 str =
"+156CA73A8C960Ee225";
4455 str >> CXSC_Pir[27];
4456 str =
"+13DE04635A3E21e1EE";
4457 str >> CXSC_Pir[28];
4458 str =
"-18F260C88C5FDBe1B7";
4459 str >> CXSC_Pir[29];
4460 str =
"-157CA63B89746Ae181";
4461 str >> CXSC_Pir[30];
4462 str =
"+1CA6DDAF44D157e149";
4463 str >> CXSC_Pir[31];
4464 str =
"+19053EA5FF0705e111";
4465 str >> CXSC_Pir[32];
4466 str =
"+1FBF19F419616Fe0DA";
4467 str >> CXSC_Pir[33];
4468 str =
"+13E60C9F6EF0CFe0A3";
4469 str >> CXSC_Pir[34];
4470 str =
"+126EF6B1E5EF8Ae06D";
4471 str >> CXSC_Pir[35];
4472 str =
"-18BC1946A1B01Ce034";
4473 str >> CXSC_Pir[36];
4474 str =
"-12780EDE6F8384e000";
4475 str >> CXSC_Pir[37];
4476 str =
"+10000000000000e000";
4477 str >> CXSC_Pir[38];
4478 str =
"+10000000000001e000";
4479 str >> CXSC_Pir[39];
4481 CXSC_Pir_initialized =
true;
4482 std::cout << RestoreOpt;
4487 for (
int i=0; i<=stagmax; i++)
4488 y[i+1] = CXSC_Pir[i];
4490 stagprec = stagsave;
4493 return lx_interval(-1023,y);
4496 static real CXSC_SqrtPi[40];
4497 static bool CXSC_SqrtPi_initialized =
false;
4503 int stagsave = stagprec,
4505 if (!CXSC_SqrtPi_initialized)
4508 std::cout << SaveOpt;
4510 str =
"+1C5BF891B4EF6Be7FC";
4511 str >> CXSC_SqrtPi[0];
4512 str =
"-1618F13EB7CA89e7C6";
4513 str >> CXSC_SqrtPi[1];
4514 str =
"-1B1F0071B7AAE4e78E";
4515 str >> CXSC_SqrtPi[2];
4516 str =
"-1389B5A46BDFE8e757";
4517 str >> CXSC_SqrtPi[3];
4518 str =
"-160AF5C5C89448e721";
4519 str >> CXSC_SqrtPi[4];
4520 str =
"-14835F07122994e6E5";
4521 str >> CXSC_SqrtPi[5];
4522 str =
"+1CEC283C18EE8Fe6AF";
4523 str >> CXSC_SqrtPi[6];
4524 str =
"-13ADEBB9223CA8e678";
4525 str >> CXSC_SqrtPi[7];
4526 str =
"+1454912430D291e642";
4527 str >> CXSC_SqrtPi[8];
4528 str =
"-1E8B2345020EF6e60C";
4529 str >> CXSC_SqrtPi[9];
4530 str =
"-17262982556291e5D5";
4531 str >> CXSC_SqrtPi[10];
4532 str =
"+1196FA9B140CABe59E";
4533 str >> CXSC_SqrtPi[11];
4534 str =
"-175EEE59D91D39e568";
4535 str >> CXSC_SqrtPi[12];
4536 str =
"+1789268B7D9D48e52D";
4537 str >> CXSC_SqrtPi[13];
4538 str =
"+17162E2F06B89Ce4F7";
4539 str >> CXSC_SqrtPi[14];
4540 str =
"+1EC9C08F40A3DBe4C0";
4541 str >> CXSC_SqrtPi[15];
4542 str =
"+1B6048DD0729E2e48A";
4543 str >> CXSC_SqrtPi[16];
4544 str =
"+1471CF4C33FF6Be453";
4545 str >> CXSC_SqrtPi[17];
4546 str =
"+1D75FBD8B36F94e41D";
4547 str >> CXSC_SqrtPi[18];
4548 str =
"+16BA59D137CC6Ee3E7";
4549 str >> CXSC_SqrtPi[19];
4550 str =
"-1FDFA25FB4BFD8e3B1";
4551 str >> CXSC_SqrtPi[20];
4552 str =
"-1699363F68227Be379";
4553 str >> CXSC_SqrtPi[21];
4554 str =
"-1BDD2FD4684487e342";
4555 str >> CXSC_SqrtPi[22];
4556 str =
"+1122B2D8015ED6e30B";
4557 str >> CXSC_SqrtPi[23];
4558 str =
"-17EB1A81424DE5e2D2";
4559 str >> CXSC_SqrtPi[24];
4560 str =
"+1C08B42B2EB0E0e29C";
4561 str >> CXSC_SqrtPi[25];
4562 str =
"-1316DE24F93E9Fe266";
4563 str >> CXSC_SqrtPi[26];
4564 str =
"+129354F2D42931e230";
4565 str >> CXSC_SqrtPi[27];
4566 str =
"-1CB7B480D41490e1FA";
4567 str >> CXSC_SqrtPi[28];
4568 str =
"+1608DE7786C4ABe1C3";
4569 str >> CXSC_SqrtPi[29];
4570 str =
"-117732A85F48BCe18D";
4571 str >> CXSC_SqrtPi[30];
4572 str =
"-18BFB034DC2D75e156";
4573 str >> CXSC_SqrtPi[31];
4574 str =
"+155DAB8C4A398Ee120";
4575 str >> CXSC_SqrtPi[32];
4576 str =
"+161C9A5BA77FF3e0E8";
4577 str >> CXSC_SqrtPi[33];
4578 str =
"-1ECF0081DB503Ce0B2";
4579 str >> CXSC_SqrtPi[34];
4580 str =
"-192FF4749E0FD8e07B";
4581 str >> CXSC_SqrtPi[35];
4582 str =
"-1B84C9BCD51654e044";
4583 str >> CXSC_SqrtPi[36];
4584 str =
"-11CF482677D72Fe00A";
4585 str >> CXSC_SqrtPi[37];
4586 str =
"-10000000000025e000";
4587 str >> CXSC_SqrtPi[38];
4588 str =
"-10000000000024e000";
4589 str >> CXSC_SqrtPi[39];
4591 CXSC_SqrtPi_initialized =
true;
4592 std::cout << RestoreOpt;
4597 for (
int i=0; i<=stagmax; i++)
4598 y[i+1] = CXSC_SqrtPi[i];
4600 stagprec = stagsave;
4603 return lx_interval(-1021,y);
4606 static real CXSC_Sqrt2Pi[40];
4607 static bool CXSC_Sqrt2Pi_initialized =
false;
4613 int stagsave = stagprec,
4615 if (!CXSC_Sqrt2Pi_initialized)
4618 std::cout << SaveOpt;
4620 str =
"+140D931FF62706e7FD";
4621 str >> CXSC_Sqrt2Pi[0];
4622 str =
"-1A6A0D6F814637e7C7";
4623 str >> CXSC_Sqrt2Pi[1];
4624 str =
"-1311D073060ACEe791";
4625 str >> CXSC_Sqrt2Pi[2];
4626 str =
"+16000B50DC2F41e758";
4627 str >> CXSC_Sqrt2Pi[3];
4628 str =
"+16EF75CA45A834e721";
4629 str >> CXSC_Sqrt2Pi[4];
4630 str =
"+19BDB2B4C39342e6E9";
4631 str >> CXSC_Sqrt2Pi[5];
4632 str =
"+1F5582E2063EE6e6B2";
4633 str >> CXSC_Sqrt2Pi[6];
4634 str =
"+183F879BEA150Ce679";
4635 str >> CXSC_Sqrt2Pi[7];
4636 str =
"-1F1EA3CA289B00e641";
4637 str >> CXSC_Sqrt2Pi[8];
4638 str =
"-1699CDA77736F9e60A";
4639 str >> CXSC_Sqrt2Pi[9];
4640 str =
"-11A379D298B55Ee5D1";
4641 str >> CXSC_Sqrt2Pi[10];
4642 str =
"-1A6DDB0152BA94e59B";
4643 str >> CXSC_Sqrt2Pi[11];
4644 str =
"-1957E2E58A02FEe564";
4645 str >> CXSC_Sqrt2Pi[12];
4646 str =
"-1D6160F18E604De52E";
4647 str >> CXSC_Sqrt2Pi[13];
4648 str =
"+1311860CDF7215e4F5";
4649 str >> CXSC_Sqrt2Pi[14];
4650 str =
"+12271F44C50274e4BE";
4651 str >> CXSC_Sqrt2Pi[15];
4652 str =
"-100BF5C5497A21e487";
4653 str >> CXSC_Sqrt2Pi[16];
4654 str =
"+1E94B6E6AD51E2e44F";
4655 str >> CXSC_Sqrt2Pi[17];
4656 str =
"-1C910B5F3D27CEe416";
4657 str >> CXSC_Sqrt2Pi[18];
4658 str =
"+1F266C0EA9E7FBe3E0";
4659 str >> CXSC_Sqrt2Pi[19];
4660 str =
"+1D84A8782A175De3AA";
4661 str >> CXSC_Sqrt2Pi[20];
4662 str =
"-1C75F70BEA4BE2e36F";
4663 str >> CXSC_Sqrt2Pi[21];
4664 str =
"+1ABE52E82F3797e338";
4665 str >> CXSC_Sqrt2Pi[22];
4666 str =
"-10A542CE87822Be302";
4667 str >> CXSC_Sqrt2Pi[23];
4668 str =
"+1457EC878576D9e2CC";
4669 str >> CXSC_Sqrt2Pi[24];
4670 str =
"-1E99158B23E861e296";
4671 str >> CXSC_Sqrt2Pi[25];
4672 str =
"-178F7C0F0F2130e25F";
4673 str >> CXSC_Sqrt2Pi[26];
4674 str =
"-12619EF8E11367e223";
4675 str >> CXSC_Sqrt2Pi[27];
4676 str =
"-1F5C2604AB7BA5e1EC";
4677 str >> CXSC_Sqrt2Pi[28];
4678 str =
"+13ED3039D91C88e1B2";
4679 str >> CXSC_Sqrt2Pi[29];
4680 str =
"-19055B38C434DDe17A";
4681 str >> CXSC_Sqrt2Pi[30];
4682 str =
"+1A7547A2C9CA85e144";
4683 str >> CXSC_Sqrt2Pi[31];
4684 str =
"-1543DE12F9EBD5e10E";
4685 str >> CXSC_Sqrt2Pi[32];
4686 str =
"+180AD772E1F1A0e0D8";
4687 str >> CXSC_Sqrt2Pi[33];
4688 str =
"+1FEF40C66F715Ee0A2";
4689 str >> CXSC_Sqrt2Pi[34];
4690 str =
"+14C244F317CD0De069";
4691 str >> CXSC_Sqrt2Pi[35];
4692 str =
"-1A29C32DBBFCAFe030";
4693 str >> CXSC_Sqrt2Pi[36];
4694 str =
"-1038D4217EB5FCe000";
4695 str >> CXSC_Sqrt2Pi[37];
4696 str =
"-10000000000001e000";
4697 str >> CXSC_Sqrt2Pi[38];
4698 str =
"-10000000000000e000";
4699 str >> CXSC_Sqrt2Pi[39];
4702 CXSC_Sqrt2Pi_initialized =
true;
4703 std::cout << RestoreOpt;
4708 for (
int i=0; i<=stagmax; i++)
4709 y[i+1] = CXSC_Sqrt2Pi[i];
4711 stagprec = stagsave;
4714 return lx_interval(-1021,y);
4717 static real CXSC_Sqrt2[40];
4718 static bool CXSC_Sqrt2_initialized =
false;
4724 int stagsave = stagprec,
4726 if (!CXSC_Sqrt2_initialized)
4729 std::cout << SaveOpt;
4731 str =
"+16A09E667F3BCDe7FC";
4732 str >> CXSC_Sqrt2[0];
4733 str =
"-1BDD3413B26456e7C6";
4734 str >> CXSC_Sqrt2[1];
4735 str =
"+157D3E3ADEC175e790";
4736 str >> CXSC_Sqrt2[2];
4737 str =
"+12775099DA2F59e758";
4738 str >> CXSC_Sqrt2[3];
4739 str =
"+160CCE64552BF2e71F";
4740 str >> CXSC_Sqrt2[4];
4741 str =
"+1821D5C5161D46e6E6";
4742 str >> CXSC_Sqrt2[5];
4743 str =
"-1C032046F8498Ee6B0";
4744 str >> CXSC_Sqrt2[6];
4745 str =
"+1EE950BC8738F7e678";
4746 str >> CXSC_Sqrt2[7];
4747 str =
"-1AC3FDBC64E103e642";
4748 str >> CXSC_Sqrt2[8];
4749 str =
"+13B469101743A1e60A";
4750 str >> CXSC_Sqrt2[9];
4751 str =
"+15E3E9CA60B38Ce5D4";
4752 str >> CXSC_Sqrt2[10];
4753 str =
"+11BC337BCAB1BDe599";
4754 str >> CXSC_Sqrt2[11];
4755 str =
"-1BBA5DEE9D6E7De563";
4756 str >> CXSC_Sqrt2[12];
4757 str =
"-1438DD083B1CC4e52D";
4758 str >> CXSC_Sqrt2[13];
4759 str =
"+1B56A28E2EDFA7e4F7";
4760 str >> CXSC_Sqrt2[14];
4761 str =
"+1CCB2A634331F4e4C1";
4762 str >> CXSC_Sqrt2[15];
4763 str =
"-1BD9056876F83Ee48A";
4764 str >> CXSC_Sqrt2[16];
4765 str =
"-1234FA22AB6BEFe454";
4766 str >> CXSC_Sqrt2[17];
4767 str =
"+19040CA4A81395e41D";
4768 str >> CXSC_Sqrt2[18];
4769 str =
"-15249C0BC4082De3E7";
4770 str >> CXSC_Sqrt2[19];
4771 str =
"+13A02CEBC93E0Ce3B1";
4772 str >> CXSC_Sqrt2[20];
4773 str =
"+109936AF354A2Ee37B";
4774 str >> CXSC_Sqrt2[21];
4775 str =
"-1AE4730CBE4908e345";
4776 str >> CXSC_Sqrt2[22];
4777 str =
"+11B6380826E010e30E";
4778 str >> CXSC_Sqrt2[23];
4779 str =
"-1CDCAD0CCD5A16e2D5";
4780 str >> CXSC_Sqrt2[24];
4781 str =
"-1084BC28012BC8e29C";
4782 str >> CXSC_Sqrt2[25];
4783 str =
"-1C035DDECF8216e265";
4784 str >> CXSC_Sqrt2[26];
4785 str =
"+18907DEAA070B0e22B";
4786 str >> CXSC_Sqrt2[27];
4787 str =
"+1FCBDDEA2F7DC3e1F5";
4788 str >> CXSC_Sqrt2[28];
4789 str =
"+18C41C51757FB0e1BE";
4790 str >> CXSC_Sqrt2[29];
4791 str =
"-189A5B616B1381e188";
4792 str >> CXSC_Sqrt2[30];
4793 str =
"+165C417EFF0B88e152";
4794 str >> CXSC_Sqrt2[31];
4795 str =
"-1627043F832999e11A";
4796 str >> CXSC_Sqrt2[32];
4797 str =
"+105E5FCA017092e0E3";
4798 str >> CXSC_Sqrt2[33];
4799 str =
"-187A16D6A8FDCAe0AD";
4800 str >> CXSC_Sqrt2[34];
4801 str =
"-1838421AE0AE62e072";
4802 str >> CXSC_Sqrt2[35];
4803 str =
"-165073EB433984e03C";
4804 str >> CXSC_Sqrt2[36];
4805 str =
"+1F0A42F9DA4A6Ce006";
4806 str >> CXSC_Sqrt2[37];
4807 str =
"+10000000000002e000";
4808 str >> CXSC_Sqrt2[38];
4809 str =
"+10000000000003e000";
4810 str >> CXSC_Sqrt2[39];
4812 CXSC_Sqrt2_initialized =
true;
4813 std::cout << RestoreOpt;
4818 for (
int i=0; i<=stagmax; i++)
4819 y[i+1] = CXSC_Sqrt2[i];
4821 stagprec = stagsave;
4824 return lx_interval(-1021,y);
4827 static real CXSC_Sqrt3[40];
4828 static bool CXSC_Sqrt3_initialized =
false;
4834 int stagsave = stagprec,
4836 if (!CXSC_Sqrt3_initialized)
4839 std::cout << SaveOpt;
4841 str =
"+1BB67AE8584CAAe7FC";
4842 str >> CXSC_Sqrt3[0];
4843 str =
"+1CEC95D0B5C1E3e7C6";
4844 str >> CXSC_Sqrt3[1];
4845 str =
"-1F11DB689F2CCFe78E";
4846 str >> CXSC_Sqrt3[2];
4847 str =
"+13DA4798C720A6e758";
4848 str >> CXSC_Sqrt3[3];
4849 str =
"+121B9169B89243e722";
4850 str >> CXSC_Sqrt3[4];
4851 str =
"-1813508751212Be6E9";
4852 str >> CXSC_Sqrt3[5];
4853 str =
"-1B3D547B775C1Ee6B2";
4854 str >> CXSC_Sqrt3[6];
4855 str =
"-19D986D92E2F0Ae679";
4856 str >> CXSC_Sqrt3[7];
4857 str =
"+1A34334CE806B6e642";
4858 str >> CXSC_Sqrt3[8];
4859 str =
"+1A383B9E122E61e60C";
4860 str >> CXSC_Sqrt3[9];
4861 str =
"+1C61D736F2F6F2e5D5";
4862 str >> CXSC_Sqrt3[10];
4863 str =
"-10AF49233F9250e59E";
4864 str >> CXSC_Sqrt3[11];
4865 str =
"-1558A109EC0523e567";
4866 str >> CXSC_Sqrt3[12];
4867 str =
"+1F799D4D4FF2BCe531";
4868 str >> CXSC_Sqrt3[13];
4869 str =
"-1AD7B219E34EDBe4FB";
4870 str >> CXSC_Sqrt3[14];
4871 str =
"+15AB940B6677E3e4C5";
4872 str >> CXSC_Sqrt3[15];
4873 str =
"-1D9B2A8203B8F0e48E";
4874 str >> CXSC_Sqrt3[16];
4875 str =
"-1DB0C8975A3834e458";
4876 str >> CXSC_Sqrt3[17];
4877 str =
"-1BCAAB3F6BE884e422";
4878 str >> CXSC_Sqrt3[18];
4879 str =
"+14C70ADB1EC1BBe3E8";
4880 str >> CXSC_Sqrt3[19];
4881 str =
"-14E1EF77987E55e3AF";
4882 str >> CXSC_Sqrt3[20];
4883 str =
"-19695FC6269D28e378";
4884 str >> CXSC_Sqrt3[21];
4885 str =
"+10D0652AAC5936e342";
4886 str >> CXSC_Sqrt3[22];
4887 str =
"-1BD0891D370824e30C";
4888 str >> CXSC_Sqrt3[23];
4889 str =
"-129B4C6252D061e2D4";
4890 str >> CXSC_Sqrt3[24];
4891 str =
"+1DC9B1A4C31275e29E";
4892 str >> CXSC_Sqrt3[25];
4893 str =
"+11FF9B8422294Ee267";
4894 str >> CXSC_Sqrt3[26];
4895 str =
"-1E4A6AA47F3A85e231";
4896 str >> CXSC_Sqrt3[27];
4897 str =
"+17043E01AA3F3De1FA";
4898 str >> CXSC_Sqrt3[28];
4899 str =
"+188EF377D2D5B6e1C0";
4900 str >> CXSC_Sqrt3[29];
4901 str =
"-1735E8C815F031e185";
4902 str >> CXSC_Sqrt3[30];
4903 str =
"-1B89330FD8417Ce14F";
4904 str >> CXSC_Sqrt3[31];
4905 str =
"+16D1A627670F5Ce117";
4906 str >> CXSC_Sqrt3[32];
4907 str =
"+1AF43BBA8154D3e0DB";
4908 str >> CXSC_Sqrt3[33];
4909 str =
"+1DA9A969A91295e0A5";
4910 str >> CXSC_Sqrt3[34];
4911 str =
"-1636594394C675e06E";
4912 str >> CXSC_Sqrt3[35];
4913 str =
"+1064B9DA1A3185e037";
4914 str >> CXSC_Sqrt3[36];
4915 str =
"-1CE514CF1825CCe001";
4916 str >> CXSC_Sqrt3[37];
4917 str =
"+10000000000000e000";
4918 str >> CXSC_Sqrt3[38];
4919 str =
"+10000000000001e000";
4920 str >> CXSC_Sqrt3[39];
4922 CXSC_Sqrt3_initialized =
true;
4923 std::cout << RestoreOpt;
4928 for (
int i=0; i<=stagmax; i++)
4929 y[i+1] = CXSC_Sqrt3[i];
4931 stagprec = stagsave;
4934 return lx_interval(-1021,y);
4937 static real CXSC_Ln2r[40];
4938 static bool CXSC_Ln2r_initialized =
false;
4944 int stagsave = stagprec,
4946 if (!CXSC_Ln2r_initialized)
4949 std::cout << SaveOpt;
4951 str =
"+171547652B82FEe7FC";
4952 str >> CXSC_Ln2r[0];
4953 str =
"+1777D0FFDA0D24e7C4";
4954 str >> CXSC_Ln2r[1];
4955 str =
"-160BB8A5442AB9e78E";
4956 str >> CXSC_Ln2r[2];
4957 str =
"-14B52D3BA6D74De756";
4958 str >> CXSC_Ln2r[3];
4959 str =
"+19A342648FBC39e720";
4960 str >> CXSC_Ln2r[4];
4961 str =
"-1E0455744994EEe6EA";
4962 str >> CXSC_Ln2r[5];
4963 str =
"+1B25EEB82D7C16e6B4";
4964 str >> CXSC_Ln2r[6];
4965 str =
"+1F5485CF306255e67E";
4966 str >> CXSC_Ln2r[7];
4967 str =
"-1EC07680A1F958e648";
4968 str >> CXSC_Ln2r[8];
4969 str =
"-106326680EB5B6e612";
4970 str >> CXSC_Ln2r[9];
4971 str =
"-1B3D04C549BC98e5DC";
4972 str >> CXSC_Ln2r[10];
4973 str =
"+1EABCEAD10305Be5A6";
4974 str >> CXSC_Ln2r[11];
4975 str =
"-14440C57D7AB97e56D";
4976 str >> CXSC_Ln2r[12];
4977 str =
"-17185D42A4E6D6e536";
4978 str >> CXSC_Ln2r[13];
4979 str =
"-1F332B5BE48526e4FE";
4980 str >> CXSC_Ln2r[14];
4981 str =
"+12CE4F199E108De4C8";
4982 str >> CXSC_Ln2r[15];
4983 str =
"-18DAFCC6077F2Ae48F";
4984 str >> CXSC_Ln2r[16];
4985 str =
"+19ABB71EC25E12e458";
4986 str >> CXSC_Ln2r[17];
4987 str =
"-11473D7A3366BDe41F";
4988 str >> CXSC_Ln2r[18];
4989 str =
"-125DF4E28B5ED4e3E8";
4990 str >> CXSC_Ln2r[19];
4991 str =
"+1C64262D010330e3B2";
4992 str >> CXSC_Ln2r[20];
4993 str =
"-17DCAE42742BDEe37C";
4994 str >> CXSC_Ln2r[21];
4995 str =
"+109C8C7E7B896Fe346";
4996 str >> CXSC_Ln2r[22];
4997 str =
"+10C470FE2464B9e310";
4998 str >> CXSC_Ln2r[23];
4999 str =
"-1B5F6CFB7C34BEe2DA";
5000 str >> CXSC_Ln2r[24];
5001 str =
"-125E5DBA4A1165e2A1";
5002 str >> CXSC_Ln2r[25];
5003 str =
"-1FA683975309E6e26A";
5004 str >> CXSC_Ln2r[26];
5005 str =
"-140C23C4E5CC64e233";
5006 str >> CXSC_Ln2r[27];
5007 str =
"+117670EC70E797e1FD";
5008 str >> CXSC_Ln2r[28];
5009 str =
"+1B2A04B8E7416Ce1C7";
5010 str >> CXSC_Ln2r[29];
5011 str =
"+11D96159397087e18F";
5012 str >> CXSC_Ln2r[30];
5013 str =
"+10E29D810B4C60e159";
5014 str >> CXSC_Ln2r[31];
5015 str =
"+1D7442ECEFEFA1e123";
5016 str >> CXSC_Ln2r[32];
5017 str =
"+1CE25B70026529e0ED";
5018 str >> CXSC_Ln2r[33];
5019 str =
"-12CA24549E0811e0B7";
5020 str >> CXSC_Ln2r[34];
5021 str =
"+1220755E0827AEe080";
5022 str >> CXSC_Ln2r[35];
5023 str =
"+1086BCE30D4370e04A";
5024 str >> CXSC_Ln2r[36];
5025 str =
"-16FF855E4293BCe011";
5026 str >> CXSC_Ln2r[37];
5027 str =
"+10000000002A50e000";
5028 str >> CXSC_Ln2r[38];
5029 str =
"+10000000002A51e000";
5030 str >> CXSC_Ln2r[39];
5032 CXSC_Ln2r_initialized =
true;
5033 std::cout << RestoreOpt;
5038 for (
int i=0; i<=stagmax; i++)
5039 y[i+1] = CXSC_Ln2r[i];
5041 stagprec = stagsave;
5044 return lx_interval(-1021,y);
5047 static real CXSC_Pid3[40];
5048 static bool CXSC_Pid3_initialized =
false;
5054 int stagsave = stagprec,
5056 if (!CXSC_Pid3_initialized)
5059 std::cout << SaveOpt;
5061 str =
"+10C152382D7366e7FD";
5062 str >> CXSC_Pid3[0];
5063 str =
"-1EE6913347C2A6e7C7";
5064 str >> CXSC_Pid3[1];
5065 str =
"-14BBA47A9E5FD2e78F";
5066 str >> CXSC_Pid3[2];
5067 str =
"-1CCAEF65529B02e759";
5068 str >> CXSC_Pid3[3];
5069 str =
"+197CB7BCC18B87e722";
5070 str >> CXSC_Pid3[4];
5071 str =
"-13EBBDA1FF3058e6EC";
5072 str >> CXSC_Pid3[5];
5073 str =
"-11D10CB320F4D1e6B4";
5074 str >> CXSC_Pid3[6];
5075 str =
"+1958EB892987ECe67D";
5076 str >> CXSC_Pid3[7];
5077 str =
"+167C54B11CF247e647";
5078 str >> CXSC_Pid3[8];
5079 str =
"+12C2E985923A44e60E";
5080 str >> CXSC_Pid3[9];
5081 str =
"+1945484A2DD81Fe5D6";
5082 str >> CXSC_Pid3[10];
5083 str =
"+1197A9E475D54Fe59E";
5084 str >> CXSC_Pid3[11];
5085 str =
"-1E181FEE158585e568";
5086 str >> CXSC_Pid3[12];
5087 str =
"+1047FCE7066A6Ee532";
5088 str >> CXSC_Pid3[13];
5089 str =
"+1D1A8602EA0C85e4FC";
5090 str >> CXSC_Pid3[14];
5091 str =
"+14430C5998BF34e4C6";
5092 str >> CXSC_Pid3[15];
5093 str =
"+173BF40AAD43D9e48F";
5094 str >> CXSC_Pid3[16];
5095 str =
"-137B014DDEDCF5e459";
5096 str >> CXSC_Pid3[17];
5097 str =
"-1A5F1B210EE7C5e420";
5098 str >> CXSC_Pid3[18];
5099 str =
"+151B536DDF9502e3EA";
5100 str >> CXSC_Pid3[19];
5101 str =
"+10E4DB4F709CEEe3B4";
5102 str >> CXSC_Pid3[20];
5103 str =
"+16841F78EC058Ee37E";
5104 str >> CXSC_Pid3[21];
5105 str =
"+1D269E370AFA06e346";
5106 str >> CXSC_Pid3[22];
5107 str =
"+119123BD75E37Be310";
5108 str >> CXSC_Pid3[23];
5109 str =
"+1C7DBAADF64D9De2DA";
5110 str >> CXSC_Pid3[24];
5111 str =
"+16CC595AEA086De2A4";
5112 str >> CXSC_Pid3[25];
5113 str =
"+1942EC979DED29e26E";
5114 str >> CXSC_Pid3[26];
5115 str =
"+1EFBE875957C10e238";
5116 str >> CXSC_Pid3[27];
5117 str =
"+133B7D68BA4029e1FF";
5118 str >> CXSC_Pid3[28];
5119 str =
"-11EB0DA382BF6Ce1C9";
5120 str >> CXSC_Pid3[29];
5121 str =
"+1970EDF4B943FDe193";
5122 str >> CXSC_Pid3[30];
5123 str =
"-11C6A6D14BBC74e15C";
5124 str >> CXSC_Pid3[31];
5125 str =
"+1FBE371E3DC1D2e125";
5126 str >> CXSC_Pid3[32];
5127 str =
"-1F34D225753A55e0EF";
5128 str >> CXSC_Pid3[33];
5129 str =
"+1D0DA1E2E38EC1e0B7";
5130 str >> CXSC_Pid3[34];
5131 str =
"-18C889B4CA7CA6e07E";
5132 str >> CXSC_Pid3[35];
5133 str =
"+1B346B8DAF1FA8e048";
5134 str >> CXSC_Pid3[36];
5135 str =
"+1326EDF35258AEe012";
5136 str >> CXSC_Pid3[37];
5137 str =
"-1000000000DEDBe000";
5138 str >> CXSC_Pid3[38];
5139 str =
"-1000000000DEDAe000";
5140 str >> CXSC_Pid3[39];
5142 CXSC_Pid3_initialized =
true;
5143 std::cout << RestoreOpt;
5148 for (
int i=0; i<=stagmax; i++)
5149 y[i+1] = CXSC_Pid3[i];
5151 stagprec = stagsave;
5154 return lx_interval(-1022,y);
5157 static real CXSC_SqrtPir[40];
5158 static bool CXSC_SqrtPir_initialized =
false;
5164 int stagsave = stagprec,
5166 if (!CXSC_SqrtPir_initialized)
5169 std::cout << SaveOpt;
5171 str =
"+120DD750429B6De7FD";
5172 str >> CXSC_SqrtPir[0];
5173 str =
"+11AE3A914FED80e7C5";
5174 str >> CXSC_SqrtPir[1];
5175 str =
"-13CBBEBF65F145e78E";
5176 str >> CXSC_SqrtPir[2];
5177 str =
"-1E0C574632F53Ee757";
5178 str >> CXSC_SqrtPir[3];
5179 str =
"-1E6633BE9E7F15e721";
5180 str >> CXSC_SqrtPir[4];
5181 str =
"+1CF859270F1141e6EA";
5182 str >> CXSC_SqrtPir[5];
5183 str =
"-1FE4FB499C328Ae6B3";
5184 str >> CXSC_SqrtPir[6];
5185 str =
"-10B82C446DC78De67C";
5186 str >> CXSC_SqrtPir[7];
5187 str =
"-1878B089078800e646";
5188 str >> CXSC_SqrtPir[8];
5189 str =
"-13DAEADA9E233Ee60E";
5190 str >> CXSC_SqrtPir[9];
5191 str =
"+1137197A708BD2e5D8";
5192 str >> CXSC_SqrtPir[10];
5193 str =
"-109009506D5BA2e59D";
5194 str >> CXSC_SqrtPir[11];
5195 str =
"+17C9F0B5951E94e567";
5196 str >> CXSC_SqrtPir[12];
5197 str =
"-1735F4949633A4e530";
5198 str >> CXSC_SqrtPir[13];
5199 str =
"-146014DBC90D0Ee4FA";
5200 str >> CXSC_SqrtPir[14];
5201 str =
"+1CAB0B222EEEA0e4C4";
5202 str >> CXSC_SqrtPir[15];
5203 str =
"+1B1C750754B40Ae48E";
5204 str >> CXSC_SqrtPir[16];
5205 str =
"-16B2CD2E72C16Ee456";
5206 str >> CXSC_SqrtPir[17];
5207 str =
"-148C024FF194B2e420";
5208 str >> CXSC_SqrtPir[18];
5209 str =
"+1CF866DD09628De3EA";
5210 str >> CXSC_SqrtPir[19];
5211 str =
"-16CBF3DC0C536Ee3B3";
5212 str >> CXSC_SqrtPir[20];
5213 str =
"+1EEDA3436CC85Fe37C";
5214 str >> CXSC_SqrtPir[21];
5215 str =
"+16928D2C52986Ae346";
5216 str >> CXSC_SqrtPir[22];
5217 str =
"+1EF82FD6BDE19De30E";
5218 str >> CXSC_SqrtPir[23];
5219 str =
"+1218F360779AEEe2D8";
5220 str >> CXSC_SqrtPir[24];
5221 str =
"+14F13DB14D3AC2e2A2";
5222 str >> CXSC_SqrtPir[25];
5223 str =
"+1461BD3C8DC495e26C";
5224 str >> CXSC_SqrtPir[26];
5225 str =
"-1CAE7855A13FF8e234";
5226 str >> CXSC_SqrtPir[27];
5227 str =
"-18CEA8571A02F7e1FE";
5228 str >> CXSC_SqrtPir[28];
5229 str =
"-1AC80A19057BBDe1C8";
5230 str >> CXSC_SqrtPir[29];
5231 str =
"+1A1910D82DC198e191";
5232 str >> CXSC_SqrtPir[30];
5233 str =
"+16B8F9198BC17Fe15B";
5234 str >> CXSC_SqrtPir[31];
5235 str =
"+1D7B579C6CAF5De123";
5236 str >> CXSC_SqrtPir[32];
5237 str =
"+1E97B95E80FE25e0ED";
5238 str >> CXSC_SqrtPir[33];
5239 str =
"-188EF7630D4F86e0AF";
5240 str >> CXSC_SqrtPir[34];
5241 str =
"+1988FBA498490Ae076";
5242 str >> CXSC_SqrtPir[35];
5243 str =
"+178235EAEC9403e03F";
5244 str >> CXSC_SqrtPir[36];
5245 str =
"+1067F03DFDFF93e005";
5246 str >> CXSC_SqrtPir[37];
5247 str =
"+10000000000006e000";
5248 str >> CXSC_SqrtPir[38];
5249 str =
"+10000000000007e000";
5250 str >> CXSC_SqrtPir[39];
5252 CXSC_SqrtPir_initialized =
true;
5253 std::cout << RestoreOpt;
5258 for (
int i=0; i<=stagmax; i++)
5259 y[i+1] = CXSC_SqrtPir[i];
5261 stagprec = stagsave;
5264 return lx_interval(-1023,y);
5267 static real CXSC_Sqrt2Pir[40];
5268 static bool CXSC_Sqrt2Pir_initialized =
false;
5274 int stagsave = stagprec,
5276 if (!CXSC_Sqrt2Pir_initialized)
5279 std::cout << SaveOpt;
5281 str =
"+19884533D43651e7FC";
5282 str >> CXSC_Sqrt2Pir[0];
5283 str =
"-1CBC0D30EBFD15e7C6";
5284 str >> CXSC_Sqrt2Pir[1];
5285 str =
"-1C7402C7D60CFBe78E";
5286 str >> CXSC_Sqrt2Pir[2];
5287 str =
"+12706D8C0471B5e756";
5288 str >> CXSC_Sqrt2Pir[3];
5289 str =
"-1FF6718B45881De720";
5290 str >> CXSC_Sqrt2Pir[4];
5291 str =
"-13AABB82C248DCe6EA";
5292 str >> CXSC_Sqrt2Pir[5];
5293 str =
"-1458A899162EE4e6B1";
5294 str >> CXSC_Sqrt2Pir[6];
5295 str =
"-14EBD8868F41EBe67A";
5296 str >> CXSC_Sqrt2Pir[7];
5297 str =
"+13278E993445F1e642";
5298 str >> CXSC_Sqrt2Pir[8];
5299 str =
"-1CC019F5F4780Ae60C";
5300 str >> CXSC_Sqrt2Pir[9];
5301 str =
"+147CE4B4ECDBD7e5D6";
5302 str >> CXSC_Sqrt2Pir[10];
5303 str =
"-19A3DCC6A3534Be59E";
5304 str >> CXSC_Sqrt2Pir[11];
5305 str =
"+11379A7BA8CB0Ae568";
5306 str >> CXSC_Sqrt2Pir[12];
5307 str =
"-12D909C875312Ee531";
5308 str >> CXSC_Sqrt2Pir[13];
5309 str =
"+1C1CEC4882C77Be4FA";
5310 str >> CXSC_Sqrt2Pir[14];
5311 str =
"-14C4078263DF36e4C4";
5312 str >> CXSC_Sqrt2Pir[15];
5313 str =
"+1AB3FC8D2AB243e48E";
5314 str >> CXSC_Sqrt2Pir[16];
5315 str =
"+17B9172454310Ae458";
5316 str >> CXSC_Sqrt2Pir[17];
5317 str =
"-1444B6B781B7F2e422";
5318 str >> CXSC_Sqrt2Pir[18];
5319 str =
"-1DB5C6773B74B7e3EC";
5320 str >> CXSC_Sqrt2Pir[19];
5321 str =
"-12D4CD4FAB8CF9e3B5";
5322 str >> CXSC_Sqrt2Pir[20];
5323 str =
"-12C319ACF346DCe37D";
5324 str >> CXSC_Sqrt2Pir[21];
5325 str =
"+193ED298857CB8e346";
5326 str >> CXSC_Sqrt2Pir[22];
5327 str =
"+1AB87659565E92e30E";
5328 str >> CXSC_Sqrt2Pir[23];
5329 str =
"-1AEB785019F78Ee2D6";
5330 str >> CXSC_Sqrt2Pir[24];
5331 str =
"-17DAF38DE68CA0e29F";
5332 str >> CXSC_Sqrt2Pir[25];
5333 str =
"-14D672D025580Ce265";
5334 str >> CXSC_Sqrt2Pir[26];
5335 str =
"-17AA87F2ABB794e22F";
5336 str >> CXSC_Sqrt2Pir[27];
5337 str =
"+16E85953CBD917e1F9";
5338 str >> CXSC_Sqrt2Pir[28];
5339 str =
"-10AB555C9A9735e1C3";
5340 str >> CXSC_Sqrt2Pir[29];
5341 str =
"+1020FEB8ED1EA2e18A";
5342 str >> CXSC_Sqrt2Pir[30];
5343 str =
"+18282C79079F71e152";
5344 str >> CXSC_Sqrt2Pir[31];
5345 str =
"+13D282FF699FC4e11C";
5346 str >> CXSC_Sqrt2Pir[32];
5347 str =
"-1A547E139AE10Ce0E6";
5348 str >> CXSC_Sqrt2Pir[33];
5349 str =
"+167FCF0E311B0De0AE";
5350 str >> CXSC_Sqrt2Pir[34];
5351 str =
"+1AC5D5E32ED719e078";
5352 str >> CXSC_Sqrt2Pir[35];
5353 str =
"+1B311EB9071956e042";
5354 str >> CXSC_Sqrt2Pir[36];
5355 str =
"+1D237BE89A6494e00C";
5356 str >> CXSC_Sqrt2Pir[37];
5357 str =
"+10000000000075e000";
5358 str >> CXSC_Sqrt2Pir[38];
5359 str =
"+10000000000076e000";
5360 str >> CXSC_Sqrt2Pir[39];
5362 CXSC_Sqrt2Pir_initialized =
true;
5363 std::cout << RestoreOpt;
5368 for (
int i=0; i<=stagmax; i++)
5369 y[i+1] = CXSC_Sqrt2Pir[i];
5371 stagprec = stagsave;
5374 return lx_interval(-1023,y);
5377 static real CXSC_LnPi[40];
5378 static bool CXSC_LnPi_initialized =
false;
5384 int stagsave = stagprec,
5386 if (!CXSC_LnPi_initialized)
5389 std::cout << SaveOpt;
5391 str =
"+1250D048E7A1BDe7FD";
5392 str >> CXSC_LnPi[0];
5393 str =
"+17ABF2AD8D5088e7C4";
5394 str >> CXSC_LnPi[1];
5395 str =
"-16CCF43244818Ae78C";
5396 str >> CXSC_LnPi[2];
5397 str =
"+1F9303719C0176e756";
5398 str >> CXSC_LnPi[3];
5399 str =
"+15DF52611CB54Ee720";
5400 str >> CXSC_LnPi[4];
5401 str =
"-1D9056E74F8C97e6EA";
5402 str >> CXSC_LnPi[5];
5403 str =
"+100B095B6C2E1Ae6B3";
5404 str >> CXSC_LnPi[6];
5405 str =
"-18C7557878A9E7e67D";
5406 str >> CXSC_LnPi[7];
5407 str =
"+1B9BBBB4F4CEE7e646";
5408 str >> CXSC_LnPi[8];
5409 str =
"+1B477FCC702F86e610";
5410 str >> CXSC_LnPi[9];
5411 str =
"+141F1344A31799e5DA";
5412 str >> CXSC_LnPi[10];
5413 str =
"+1B6740BE95CD58e5A4";
5414 str >> CXSC_LnPi[11];
5415 str =
"-1F2C63904D27DBe56C";
5416 str >> CXSC_LnPi[12];
5417 str =
"+1426F00B933976e534";
5418 str >> CXSC_LnPi[13];
5419 str =
"+125703BE5FAA20e4FE";
5420 str >> CXSC_LnPi[14];
5421 str =
"-1DADAE5397F95Be4C7";
5422 str >> CXSC_LnPi[15];
5423 str =
"+17C9D110381543e48F";
5424 str >> CXSC_LnPi[16];
5425 str =
"-1259230E627FCAe459";
5426 str >> CXSC_LnPi[17];
5427 str =
"+191CEAB6B13A33e422";
5428 str >> CXSC_LnPi[18];
5429 str =
"+109D49A13CB595e3EB";
5430 str >> CXSC_LnPi[19];
5431 str =
"-12C574CDCD41C2e3B4";
5432 str >> CXSC_LnPi[20];
5433 str =
"+1D4141476C3E9De37E";
5434 str >> CXSC_LnPi[21];
5435 str =
"+1D26D892B64467e344";
5436 str >> CXSC_LnPi[22];
5437 str =
"-16BAF3B607E1ADe30B";
5438 str >> CXSC_LnPi[23];
5439 str =
"+165A768D8BC5ADe2D5";
5440 str >> CXSC_LnPi[24];
5441 str =
"+12185364B32BD1e29D";
5442 str >> CXSC_LnPi[25];
5443 str =
"-114D72550F0B90e266";
5444 str >> CXSC_LnPi[26];
5445 str =
"+1E586BAEEB8BF4e230";
5446 str >> CXSC_LnPi[27];
5447 str =
"-1F4B9322D4506Fe1F8";
5448 str >> CXSC_LnPi[28];
5449 str =
"+16D32BAA9A4FCCe1C2";
5450 str >> CXSC_LnPi[29];
5451 str =
"+1A12D8CF8CC6DAe18B";
5452 str >> CXSC_LnPi[30];
5453 str =
"-1215CF3BD682CAe155";
5454 str >> CXSC_LnPi[31];
5455 str =
"-184CA7D8873E45e11D";
5456 str >> CXSC_LnPi[32];
5457 str =
"-1F02ECC3E58C6Ee0E7";
5458 str >> CXSC_LnPi[33];
5459 str =
"-11F6EC8ED0D92Be0B1";
5460 str >> CXSC_LnPi[34];
5461 str =
"-199F29ACE1FC18e077";
5462 str >> CXSC_LnPi[35];
5463 str =
"+119F3673AA919Ae041";
5464 str >> CXSC_LnPi[36];
5465 str =
"-1A8359A2831626e00A";
5466 str >> CXSC_LnPi[37];
5467 str =
"-10000000000072e000";
5468 str >> CXSC_LnPi[38];
5469 str =
"-10000000000071e000";
5470 str >> CXSC_LnPi[39];
5472 CXSC_LnPi_initialized =
true;
5473 std::cout << RestoreOpt;
5478 for (
int i=0; i<=stagmax; i++)
5479 y[i+1] = CXSC_LnPi[i];
5481 stagprec = stagsave;
5484 return lx_interval(-1022,y);
5487 static real CXSC_Ln2Pi[40];
5488 static bool CXSC_Ln2Pi_initialized =
false;
5494 int stagsave = stagprec,
5496 if (!CXSC_Ln2Pi_initialized)
5499 std::cout << SaveOpt;
5501 str =
"+1D67F1C864BEB5e7FC";
5502 str >> CXSC_Ln2Pi[0];
5503 str =
"-165B5A1B7FF5DFe7C6";
5504 str >> CXSC_Ln2Pi[1];
5505 str =
"-1B7F70C13DC1CCe78F";
5506 str >> CXSC_Ln2Pi[2];
5507 str =
"+13458B4DDEC6A3e759";
5508 str >> CXSC_Ln2Pi[3];
5509 str =
"+133DAA155D2130e721";
5510 str >> CXSC_Ln2Pi[4];
5511 str =
"-18A007FC5E501Be6EB";
5512 str >> CXSC_Ln2Pi[5];
5513 str =
"-15406FA3AA9644e6B1";
5514 str >> CXSC_Ln2Pi[6];
5515 str =
"-13E8D52A392CC9e67B";
5516 str >> CXSC_Ln2Pi[7];
5517 str =
"-1A43099131E88De645";
5518 str >> CXSC_Ln2Pi[8];
5519 str =
"-114835B6623C4De60F";
5520 str >> CXSC_Ln2Pi[9];
5521 str =
"-1ABB7858CF827Ae5D9";
5522 str >> CXSC_Ln2Pi[10];
5523 str =
"+1D8D7045A5A495e5A3";
5524 str >> CXSC_Ln2Pi[11];
5525 str =
"+1A26094B3F6FC5e56C";
5526 str >> CXSC_Ln2Pi[12];
5527 str =
"-1EF27932D0E3D0e534";
5528 str >> CXSC_Ln2Pi[13];
5529 str =
"-12128804136AB6e4FD";
5530 str >> CXSC_Ln2Pi[14];
5531 str =
"+15F8A4AC0BEE17e4C4";
5532 str >> CXSC_Ln2Pi[15];
5533 str =
"+1892F2A5B69B5Fe48E";
5534 str >> CXSC_Ln2Pi[16];
5535 str =
"+1CC7C09477ADCEe458";
5536 str >> CXSC_Ln2Pi[17];
5537 str =
"-116DD579AF074Ae41F";
5538 str >> CXSC_Ln2Pi[18];
5539 str =
"+190E43C1DCCD69e3E7";
5540 str >> CXSC_Ln2Pi[19];
5541 str =
"-11F55BBD0978D3e3AF";
5542 str >> CXSC_Ln2Pi[20];
5543 str =
"+167EC65B83F29Be378";
5544 str >> CXSC_Ln2Pi[21];
5545 str =
"-14C0D466FC8C7Ae33C";
5546 str >> CXSC_Ln2Pi[22];
5547 str =
"-1D56DE4860435Ce306";
5548 str >> CXSC_Ln2Pi[23];
5549 str =
"-10C7B15DFFBDFCe2D0";
5550 str >> CXSC_Ln2Pi[24];
5551 str =
"-15007E40803B52e299";
5552 str >> CXSC_Ln2Pi[25];
5553 str =
"+1DF2A457B56D15e261";
5554 str >> CXSC_Ln2Pi[26];
5555 str =
"-16B7CAD686151De22B";
5556 str >> CXSC_Ln2Pi[27];
5557 str =
"-11F972F1A61CA1e1F5";
5558 str >> CXSC_Ln2Pi[28];
5559 str =
"+1443CF52FBF6B4e1BE";
5560 str >> CXSC_Ln2Pi[29];
5561 str =
"-12652AE82DC678e187";
5562 str >> CXSC_Ln2Pi[30];
5563 str =
"-11712858901127e151";
5564 str >> CXSC_Ln2Pi[31];
5565 str =
"+124D51F4842F1Fe11B";
5566 str >> CXSC_Ln2Pi[32];
5567 str =
"+1B8F6B0823A92Ae0E4";
5568 str >> CXSC_Ln2Pi[33];
5569 str =
"-1742244E0D8F40e0AB";
5570 str >> CXSC_Ln2Pi[34];
5571 str =
"+127A8F1E2AEAD3e074";
5572 str >> CXSC_Ln2Pi[35];
5573 str =
"-180BC6B9E8F00Ce03D";
5574 str >> CXSC_Ln2Pi[36];
5575 str =
"+190933A24F0ECEe007";
5576 str >> CXSC_Ln2Pi[37];
5577 str =
"-10000000000007e000";
5578 str >> CXSC_Ln2Pi[38];
5579 str =
"-10000000000006e000";
5580 str >> CXSC_Ln2Pi[39];
5582 CXSC_Ln2Pi_initialized =
true;
5583 std::cout << RestoreOpt;
5588 for (
int i=0; i<=stagmax; i++)
5589 y[i+1] = CXSC_Ln2Pi[i];
5591 stagprec = stagsave;
5594 return lx_interval(-1021,y);
5597 static real CXSC_E[40];
5598 static bool CXSC_E_initialized =
false;
5604 int stagsave = stagprec,
5606 if (!CXSC_E_initialized)
5609 std::cout << SaveOpt;
5611 str =
"+15BF0A8B145769e7FD";
5613 str =
"+14D57EE2B1013Ae7C7";
5615 str =
"-1618713A31D3E2e78F";
5617 str =
"+1C5A6D2B53C26De759";
5619 str =
"-1F75CDE60219B6e723";
5621 str =
"-188C76D93041A1e6EC";
5623 str =
"+12FE363630C75Ee6B6";
5625 str =
"-1C25F937F544EEe680";
5627 str =
"-1E852C20E12A2Ae64A";
5629 str =
"-14D4F6DE605705e60F";
5631 str =
"-1F3225EF539355e5D5";
5633 str =
"-16109728625547e59F";
5635 str =
"-194301506D94CFe569";
5637 str =
"-1879C78F8CBA44e533";
5639 str =
"-1D5976250C1018e4FA";
5641 str =
"+1C877C56284DABe4C4";
5643 str =
"+1E73530ACCA4F5e48E";
5645 str =
"-1F161A150FD53Ae458";
5647 str =
"+159927DB0E8845e41F";
5649 str =
"+12976591C7F773e3E9";
5651 str =
"-1525489F280B98e3B2";
5653 str =
"+1D4F42A3DE394Ee37A";
5655 str =
"-16A3522431391Be341";
5657 str =
"+1D8C8583D3E477e30B";
5659 str =
"+14DAE13C05F9C4e2D1";
5661 str =
"-19040E899FE5FEe29B";
5663 str =
"+19A50685EC322Ee265";
5665 str =
"+17F4E74C2C1FFCe22F";
5667 str =
"+1C9E2465DDE503e1F9";
5669 str =
"+1E1FF1D8DA637De1BF";
5671 str =
"+1AE6776BF9785Ee189";
5673 str =
"-1EEFFD1D38873Ee153";
5675 str =
"-105D2F89A72197e11D";
5677 str =
"+11360D977FD443e0E7";
5679 str =
"+168470C23F9FBAe0B1";
5681 str =
"-10E552624D737Ee07B";
5683 str =
"-148879616420CCe045";
5685 str =
"-1FEE3CF25C81B1e00F";
5687 str =
"-10000000001233e000";
5689 str =
"-10000000001232e000";
5692 CXSC_E_initialized =
true;
5693 std::cout << RestoreOpt;
5698 for (
int i=0; i<=stagmax; i++)
5701 stagprec = stagsave;
5704 return lx_interval(-1021,y);
5707 static real CXSC_EpPi[40];
5708 static bool CXSC_EpPi_initialized =
false;
5714 int stagsave = stagprec,
5716 if (!CXSC_EpPi_initialized)
5719 std::cout << SaveOpt;
5721 str =
"+1724046EB0933Ae7FD";
5722 str >> CXSC_EpPi[0];
5723 str =
"-184C962DD81952e7C7";
5724 str >> CXSC_EpPi[1];
5725 str =
"-12D659C0BCD22Ee790";
5726 str >> CXSC_EpPi[2];
5727 str =
"+117496B8A92F91e75A";
5728 str >> CXSC_EpPi[3];
5729 str =
"+16A8C4203E5FCDe724";
5730 str >> CXSC_EpPi[4];
5731 str =
"-166B11F99A663Be6EE";
5732 str >> CXSC_EpPi[5];
5733 str =
"-118EC2076DABB1e6B8";
5734 str >> CXSC_EpPi[6];
5735 str =
"+19776E5BEB18A5e682";
5736 str >> CXSC_EpPi[7];
5737 str =
"+1AD4091E84B051e64C";
5738 str >> CXSC_EpPi[8];
5739 str =
"+1E89AA12909B40e616";
5740 str >> CXSC_EpPi[9];
5741 str =
"+1ACE3C0DDBB994e5DD";
5742 str >> CXSC_EpPi[10];
5743 str =
"+141EC9379CBBFEe5A6";
5744 str >> CXSC_EpPi[11];
5745 str =
"+1FC4E78D00A016e56D";
5746 str >> CXSC_EpPi[12];
5747 str =
"+1608BE35B9A409e537";
5748 str >> CXSC_EpPi[13];
5749 str =
"-1A0D8AA90EB6B9e4FD";
5750 str >> CXSC_EpPi[14];
5751 str =
"+106FE8AFD21ACFe4C7";
5752 str >> CXSC_EpPi[15];
5753 str =
"+1C072FEA1BFCAFe48F";
5754 str >> CXSC_EpPi[16];
5755 str =
"+1915B9F352EC68e455";
5756 str >> CXSC_EpPi[17];
5757 str =
"-13FA07C37897E9e41E";
5758 str >> CXSC_EpPi[18];
5759 str =
"-1EC01C89B8DDFFe3E8";
5760 str >> CXSC_EpPi[19];
5761 str =
"+1EDC3A402336AFe3B0";
5762 str >> CXSC_EpPi[20];
5763 str =
"-12677080620EA5e378";
5764 str >> CXSC_EpPi[21];
5765 str =
"-1C63FD21D891DEe340";
5766 str >> CXSC_EpPi[22];
5767 str =
"-1FB6165FFF8730e309";
5768 str >> CXSC_EpPi[23];
5769 str =
"-177AB93E2523EFe2D3";
5770 str >> CXSC_EpPi[24];
5771 str =
"+16D78E0B522E2Ce29C";
5772 str >> CXSC_EpPi[25];
5773 str =
"-17473D7DD61EBEe266";
5774 str >> CXSC_EpPi[26];
5775 str =
"-1F082665C53E27e22A";
5776 str >> CXSC_EpPi[27];
5777 str =
"-17CDF823ACB5D6e1F3";
5778 str >> CXSC_EpPi[28];
5779 str =
"-1D95D856C4BF74e1BC";
5780 str >> CXSC_EpPi[29];
5781 str =
"-1327665D26E23Ae186";
5782 str >> CXSC_EpPi[30];
5783 str =
"-1EC5804BDCCA81e150";
5784 str >> CXSC_EpPi[31];
5785 str =
"-1C73760E976CC3e117";
5786 str >> CXSC_EpPi[32];
5787 str =
"-10B1DCE92BE86Ce0E0";
5788 str >> CXSC_EpPi[33];
5789 str =
"-17372866D0A1CCe0AA";
5790 str >> CXSC_EpPi[34];
5791 str =
"-15510B0AF58D1Ee074";
5792 str >> CXSC_EpPi[35];
5793 str =
"+1B9820D80B02D9e03C";
5794 str >> CXSC_EpPi[36];
5795 str =
"-17765315D853BAe002";
5796 str >> CXSC_EpPi[37];
5797 str =
"-10000000000001e000";
5798 str >> CXSC_EpPi[38];
5799 str =
"-10000000000000e000";
5800 str >> CXSC_EpPi[39];
5802 CXSC_EpPi_initialized =
true;
5803 std::cout << RestoreOpt;
5808 for (
int i=0; i<=stagmax; i++)
5809 y[i+1] = CXSC_EpPi[i];
5811 stagprec = stagsave;
5814 return lx_interval(-1018,y);
5817 static real CXSC_EulerGamma[40];
5818 static bool CXSC_EulerGamma_initialized =
false;
5824 int stagsave = stagprec,
5826 if (!CXSC_EulerGamma_initialized)
5829 std::cout << SaveOpt;
5831 str =
"+12788CFC6FB619e7FD";
5832 str >> CXSC_EulerGamma[0];
5833 str =
"-16CB90701FBFABe7C4";
5834 str >> CXSC_EulerGamma[1];
5835 str =
"-134A95E3133C51e78E";
5836 str >> CXSC_EulerGamma[2];
5837 str =
"+19730064300F7De758";
5838 str >> CXSC_EulerGamma[3];
5839 str =
"-171ECA0084E369e721";
5840 str >> CXSC_EulerGamma[4];
5841 str =
"-1302FE2B078898e6EB";
5842 str >> CXSC_EulerGamma[5];
5843 str =
"+192732D88415F4e6B4";
5844 str >> CXSC_EulerGamma[6];
5845 str =
"+11056AE9132136e67E";
5846 str >> CXSC_EulerGamma[7];
5847 str =
"-17DC6F12E630A3e648";
5848 str >> CXSC_EulerGamma[8];
5849 str =
"+175FD4B1BD70F2e611";
5850 str >> CXSC_EulerGamma[9];
5851 str =
"-19BC9466120C20e5DB";
5852 str >> CXSC_EulerGamma[10];
5853 str =
"-18FD5699260EADe5A5";
5854 str >> CXSC_EulerGamma[11];
5855 str =
"-12EA987665551Fe56E";
5856 str >> CXSC_EulerGamma[12];
5857 str =
"-1FB159BA4A423De537";
5858 str >> CXSC_EulerGamma[13];
5859 str =
"+1FA543D43BCC60e501";
5860 str >> CXSC_EulerGamma[14];
5861 str =
"-1E6F04E0F639F6e4C8";
5862 str >> CXSC_EulerGamma[15];
5863 str =
"-1A23768654F43De490";
5864 str >> CXSC_EulerGamma[16];
5865 str =
"-14F1C5CB4F55EBe457";
5866 str >> CXSC_EulerGamma[17];
5867 str =
"+1E71DF52EDAA7Fe41F";
5868 str >> CXSC_EulerGamma[18];
5869 str =
"+1C398F9B427E3Fe3E8";
5870 str >> CXSC_EulerGamma[19];
5871 str =
"+1432C7402B3D24e3AF";
5872 str >> CXSC_EulerGamma[20];
5873 str =
"-1810CF88C5F0D1e377";
5874 str >> CXSC_EulerGamma[21];
5875 str =
"-1E9610AE5B38C5e340";
5876 str >> CXSC_EulerGamma[22];
5877 str =
"+18220365594965e30A";
5878 str >> CXSC_EulerGamma[23];
5879 str =
"-11F19DA40D550De2D4";
5880 str >> CXSC_EulerGamma[24];
5881 str =
"+1936632B38107Ee29D";
5882 str >> CXSC_EulerGamma[25];
5883 str =
"+11569F72C8E198e267";
5884 str >> CXSC_EulerGamma[26];
5885 str =
"-1534E2EDC357EAe230";
5886 str >> CXSC_EulerGamma[27];
5887 str =
"-126925B08D68FFe1F7";
5888 str >> CXSC_EulerGamma[28];
5889 str =
"-1F62F86B1E6840e1C0";
5890 str >> CXSC_EulerGamma[29];
5891 str =
"+133239C12DF171e188";
5892 str >> CXSC_EulerGamma[30];
5893 str =
"+17E60989B189E2e14D";
5894 str >> CXSC_EulerGamma[31];
5895 str =
"+1F6FB023E2AA98e117";
5896 str >> CXSC_EulerGamma[32];
5897 str =
"+16911C6C6708F0e0DF";
5898 str >> CXSC_EulerGamma[33];
5899 str =
"-1B7B61C9327A74e0A9";
5900 str >> CXSC_EulerGamma[34];
5901 str =
"-16E397C5D924C3e073";
5902 str >> CXSC_EulerGamma[35];
5903 str =
"-1435DBEDE3F382e03C";
5904 str >> CXSC_EulerGamma[36];
5905 str =
"+1C0AEA1C4BB6FFe006";
5906 str >> CXSC_EulerGamma[37];
5907 str =
"-1000000000000Ee000";
5908 str >> CXSC_EulerGamma[38];
5909 str =
"-1000000000000De000";
5910 str >> CXSC_EulerGamma[39];
5912 CXSC_EulerGamma_initialized =
true;
5913 std::cout << RestoreOpt;
5918 for (
int i=0; i<=stagmax; i++)
5919 y[i+1] = CXSC_EulerGamma[i];
5921 stagprec = stagsave;
5924 return lx_interval(-1023,y);
5927 static real CXSC_Catalan[40];
5928 static bool CXSC_Catalan_initialized =
false;
5934 int stagsave = stagprec,
5936 if (!CXSC_Catalan_initialized)
5939 std::cout << SaveOpt;
5941 str =
"+1D4F9713E8135De7FC";
5942 str >> CXSC_Catalan[0];
5943 str =
"+11485608B8DF4De7C3";
5944 str >> CXSC_Catalan[1];
5945 str =
"-12F39C13BC1EC8e78D";
5946 str >> CXSC_Catalan[2];
5947 str =
"+1C2FF8094A263Ee755";
5948 str >> CXSC_Catalan[3];
5949 str =
"+168F335DBE5370e71F";
5950 str >> CXSC_Catalan[4];
5951 str =
"+16291BBB16163Ee6E7";
5952 str >> CXSC_Catalan[5];
5953 str =
"+124D663F739C43e6B1";
5954 str >> CXSC_Catalan[6];
5955 str =
"-136A0725ED0E94e679";
5956 str >> CXSC_Catalan[7];
5957 str =
"-1D3A26F9C06FCEe63E";
5958 str >> CXSC_Catalan[8];
5959 str =
"-164E42486BFCD2e607";
5960 str >> CXSC_Catalan[9];
5961 str =
"+14F358CFDEC843e5D1";
5962 str >> CXSC_Catalan[10];
5963 str =
"-11EB82210976ABe59B";
5964 str >> CXSC_Catalan[11];
5965 str =
"-17D31F6DF5E801e565";
5966 str >> CXSC_Catalan[12];
5967 str =
"+13FD19CE3E396Ae52F";
5968 str >> CXSC_Catalan[13];
5969 str =
"-1C8CBB3852FF3Fe4F6";
5970 str >> CXSC_Catalan[14];
5971 str =
"+1A86EB34EAD01Ae4C0";
5972 str >> CXSC_Catalan[15];
5973 str =
"+1C68C37800513Be485";
5974 str >> CXSC_Catalan[16];
5975 str =
"+1D46EBB334D7C9e44E";
5976 str >> CXSC_Catalan[17];
5977 str =
"-1944C5E2711625e417";
5978 str >> CXSC_Catalan[18];
5979 str =
"-17885C649BB92Fe3E1";
5980 str >> CXSC_Catalan[19];
5981 str =
"+1A2A0CEE24DD91e3A9";
5982 str >> CXSC_Catalan[20];
5983 str =
"+159AEC52EB2869e372";
5984 str >> CXSC_Catalan[21];
5985 str =
"-1D26976389F1E1e339";
5986 str >> CXSC_Catalan[22];
5987 str =
"+1E9AF9FF2E2FB1e302";
5988 str >> CXSC_Catalan[23];
5989 str =
"+1E8B66677323FEe2CC";
5990 str >> CXSC_Catalan[24];
5991 str =
"+164BBD8A306F6Ae296";
5992 str >> CXSC_Catalan[25];
5993 str =
"-1EE36A15C4872Be25F";
5994 str >> CXSC_Catalan[26];
5995 str =
"+1C3A35B39DC2FFe228";
5996 str >> CXSC_Catalan[27];
5997 str =
"-1CCAF1572CDFC2e1F1";
5998 str >> CXSC_Catalan[28];
5999 str =
"+15FB135902BFEEe1BA";
6000 str >> CXSC_Catalan[29];
6001 str =
"+19FDE4873721BAe183";
6002 str >> CXSC_Catalan[30];
6003 str =
"-17ABB7B5115456e14D";
6004 str >> CXSC_Catalan[31];
6005 str =
"+1458F7F79FA825e117";
6006 str >> CXSC_Catalan[32];
6007 str =
"-1416ED1E24CEFDe0E1";
6008 str >> CXSC_Catalan[33];
6009 str =
"+15A6293C127A02e0A9";
6010 str >> CXSC_Catalan[34];
6011 str =
"-1F1AABC6E5593Ce073";
6012 str >> CXSC_Catalan[35];
6013 str =
"+1A7A8FB50B3479e03D";
6014 str >> CXSC_Catalan[36];
6015 str =
"+1B853813268EF2e005";
6016 str >> CXSC_Catalan[37];
6017 str =
"+10000000000003e000";
6018 str >> CXSC_Catalan[38];
6019 str =
"+10000000000004e000";
6020 str >> CXSC_Catalan[39];
6022 CXSC_Catalan_initialized =
true;
6023 std::cout << RestoreOpt;
6028 for (
int i=0; i<=stagmax; i++)
6029 y[i+1] = CXSC_Catalan[i];
6031 stagprec = stagsave;
6034 return lx_interval(-1022,y);
6037 static real CXSC_sqrt5[40];
6038 static bool CXSC_sqrt5_initialized =
false;
6044 int stagsave = stagprec,
6046 if (!CXSC_sqrt5_initialized)
6049 std::cout << SaveOpt;
6051 str =
"+11E3779B97F4A8e7FD";
6052 str >> CXSC_sqrt5[0];
6053 str =
"-1F506319FCFD19e7C6";
6054 str >> CXSC_sqrt5[1];
6055 str =
"+1B906821044ED8e790";
6056 str >> CXSC_sqrt5[2];
6057 str =
"-18BB1B5C0F272Ce758";
6058 str >> CXSC_sqrt5[3];
6059 str =
"+11D0C18E952768e721";
6060 str >> CXSC_sqrt5[4];
6061 str =
"-1E9D585B0901F9e6E8";
6062 str >> CXSC_sqrt5[5];
6063 str =
"-1C7DD252073EC0e6B2";
6064 str >> CXSC_sqrt5[6];
6065 str =
"-1FCEF21EDAF7FAe67C";
6066 str >> CXSC_sqrt5[7];
6067 str =
"+160EB25D20799Be63E";
6068 str >> CXSC_sqrt5[8];
6069 str =
"-1C90F95285168Fe605";
6070 str >> CXSC_sqrt5[9];
6071 str =
"+1E1DFA160E75BCe5CF";
6072 str >> CXSC_sqrt5[10];
6073 str =
"-10A08E66CB368Ce593";
6074 str >> CXSC_sqrt5[11];
6075 str =
"+1C5371682CADD1e55D";
6076 str >> CXSC_sqrt5[12];
6077 str =
"-1998100220F4EDe526";
6078 str >> CXSC_sqrt5[13];
6079 str =
"+1C6771A0968663e4F0";
6080 str >> CXSC_sqrt5[14];
6081 str =
"+1DFB9E3C86CA7Ce4BA";
6082 str >> CXSC_sqrt5[15];
6083 str =
"-18AE38ED5304B1e483";
6084 str >> CXSC_sqrt5[16];
6085 str =
"+182A5FEC507706e44D";
6086 str >> CXSC_sqrt5[17];
6087 str =
"-1B5191A18C5647e415";
6088 str >> CXSC_sqrt5[18];
6089 str =
"+1F3AA4DB287AE4e3DD";
6090 str >> CXSC_sqrt5[19];
6091 str =
"+13CCCBA48E9CF3e3A7";
6092 str >> CXSC_sqrt5[20];
6093 str =
"-1BA6DC6F5C5A29e36F";
6094 str >> CXSC_sqrt5[21];
6095 str =
"-1C87E14FE4B628e339";
6096 str >> CXSC_sqrt5[22];
6097 str =
"+19D3E854210678e303";
6098 str >> CXSC_sqrt5[23];
6099 str =
"+1D54807166A5B3e2CC";
6100 str >> CXSC_sqrt5[24];
6101 str =
"+1D6987A242DB8De296";
6102 str >> CXSC_sqrt5[25];
6103 str =
"+11DEC88A541BA8e260";
6104 str >> CXSC_sqrt5[26];
6105 str =
"+1B91971F345A99e228";
6106 str >> CXSC_sqrt5[27];
6107 str =
"-1758726EB11AAFe1F2";
6108 str >> CXSC_sqrt5[28];
6109 str =
"+115613474B3372e1BA";
6110 str >> CXSC_sqrt5[29];
6111 str =
"+150CCED228BEBFe184";
6112 str >> CXSC_sqrt5[30];
6113 str =
"-13BFAB17A99623e14E";
6114 str >> CXSC_sqrt5[31];
6115 str =
"-17397D0B07EFCEe115";
6116 str >> CXSC_sqrt5[32];
6117 str =
"+157D728069CE1Ee0DC";
6118 str >> CXSC_sqrt5[33];
6119 str =
"+10B046030D58E1e0A6";
6120 str >> CXSC_sqrt5[34];
6121 str =
"-1A8870A118821Ce06E";
6122 str >> CXSC_sqrt5[35];
6123 str =
"-1BD96261F224FBe038";
6124 str >> CXSC_sqrt5[36];
6125 str =
"+1FDBEC758D20C8e002";
6126 str >> CXSC_sqrt5[37];
6127 str =
"+10000000000000e000";
6128 str >> CXSC_sqrt5[38];
6129 str =
"+10000000000001e000";
6130 str >> CXSC_sqrt5[39];
6132 CXSC_sqrt5_initialized =
true;
6133 std::cout << RestoreOpt;
6138 for (
int i=0; i<=stagmax; i++)
6139 y[i+1] = CXSC_sqrt5[i];
6141 stagprec = stagsave;
6144 return lx_interval(-1021,y);
6147 static real CXSC_sqrt7[40];
6148 static bool CXSC_sqrt7_initialized =
false;
6154 int stagsave = stagprec,
6156 if (!CXSC_sqrt7_initialized)
6159 std::cout << SaveOpt;
6161 str =
"+152A7FA9D2F8EAe7FD";
6162 str >> CXSC_sqrt7[0];
6163 str =
"-121C62B033C079e7C7";
6164 str >> CXSC_sqrt7[1];
6165 str =
"-177CAAD6200612e78E";
6166 str >> CXSC_sqrt7[2];
6167 str =
"-1EFA880DC72D64e756";
6168 str >> CXSC_sqrt7[3];
6169 str =
"-171D206D5B1A4Ce71C";
6170 str >> CXSC_sqrt7[4];
6171 str =
"+119392FA9B0494e6E3";
6172 str >> CXSC_sqrt7[5];
6173 str =
" +17BB8A64890057e6AA";
6174 str >> CXSC_sqrt7[6];
6175 str =
"-17E89300383DDEe674";
6176 str >> CXSC_sqrt7[7];
6177 str =
"+130FB7AF68A6FBe63E";
6178 str >> CXSC_sqrt7[8];
6179 str =
"+1322281D303D36e606";
6180 str >> CXSC_sqrt7[9];
6181 str =
"+1996109A16D3B1e5D0";
6182 str >> CXSC_sqrt7[10];
6183 str =
"+1F239C301DFBB4e599";
6184 str >> CXSC_sqrt7[11];
6185 str =
"-1B5CA40AB771A2e560";
6186 str >> CXSC_sqrt7[12];
6187 str =
"-1675711487FEAAe527";
6188 str >> CXSC_sqrt7[13];
6189 str =
"+122CB7FA26ABA5e4F1";
6190 str >> CXSC_sqrt7[14];
6191 str =
"+1059211B7D5398e4BA";
6192 str >> CXSC_sqrt7[15];
6193 str =
"-10F15BFA46EB7Fe484";
6194 str >> CXSC_sqrt7[16];
6195 str =
"+15AB71566CE72Be44E";
6196 str >> CXSC_sqrt7[17];
6197 str =
"-1386BDCA3845C7e417";
6198 str >> CXSC_sqrt7[18];
6199 str =
"+158978E1A883F0e3E1";
6200 str >> CXSC_sqrt7[19];
6201 str =
"+1F8A772604CAF1e3AB";
6202 str >> CXSC_sqrt7[20];
6203 str =
"-169730DF195425e374";
6204 str >> CXSC_sqrt7[21];
6205 str =
"+121341C1C58312e33D";
6206 str >> CXSC_sqrt7[22];
6207 str =
"+1117A6A8D5A423e307";
6208 str >> CXSC_sqrt7[23];
6209 str =
"-12D6F266C4AE34e2D0";
6210 str >> CXSC_sqrt7[24];
6211 str =
"-1B8D3340BC4497e299";
6212 str >> CXSC_sqrt7[25];
6213 str =
"-1E0712BA5C43CFe263";
6214 str >> CXSC_sqrt7[26];
6215 str =
"+14BF59F22FDCEDe22D";
6216 str >> CXSC_sqrt7[27];
6217 str =
"-189028E9147846e1F3";
6218 str >> CXSC_sqrt7[28];
6219 str =
"-1BBE8044991D23e1BB";
6220 str >> CXSC_sqrt7[29];
6221 str =
"+1B07A12AB80C0Ae185";
6222 str >> CXSC_sqrt7[30];
6223 str =
"+1970A29C5148A7e14E";
6224 str >> CXSC_sqrt7[31];
6225 str =
"-18DBF939495F77e117";
6226 str >> CXSC_sqrt7[32];
6227 str =
"-1865ECB3F101B4e0E1";
6228 str >> CXSC_sqrt7[33];
6229 str =
"-1DCDFCFE6050DFe0A4";
6230 str >> CXSC_sqrt7[34];
6231 str =
"+1E635021BBF848e06B";
6232 str >> CXSC_sqrt7[35];
6233 str =
"+15C53CF344AF94e035";
6234 str >> CXSC_sqrt7[36];
6235 str =
"+124CB182B20E69e000";
6236 str >> CXSC_sqrt7[37];
6237 str =
"-10000000000001e000";
6238 str >> CXSC_sqrt7[38];
6239 str =
"-10000000000000e000";
6240 str >> CXSC_sqrt7[39];
6242 CXSC_sqrt7_initialized =
true;
6243 std::cout << RestoreOpt;
6248 for (
int i=0; i<=stagmax; i++)
6249 y[i+1] = CXSC_sqrt7[i];
6251 stagprec = stagsave;
6254 return lx_interval(-1021,y);
6257 static real CXSC_One_m[3];
6258 static bool CXSC_One_m_initialized =
false;
6265 int stagsave = stagprec,
6268 if (!CXSC_One_m_initialized)
6271 std::cout << SaveOpt;
6273 str =
"+10000000000000e7FE";
6274 str >> CXSC_One_m[0];
6275 str =
"-10000000000001e000";
6276 str >> CXSC_One_m[1];
6277 str =
"-10000000000001e000";
6278 str >> CXSC_One_m[2];
6279 CXSC_One_m_initialized =
true;
6280 std::cout << RestoreOpt;
6285 for (
int i=0; i<=stagmax; i++)
6286 y[i+1] = CXSC_One_m[i];
6288 stagprec = stagsave;
6291 return lx_interval(-1023,y);
6294 static real CXSC_One_p[3];
6295 static bool CXSC_One_p_initialized =
false;
6302 int stagsave = stagprec,
6305 if (!CXSC_One_p_initialized)
6308 std::cout << SaveOpt;
6310 str =
"+10000000000000e7FE";
6311 str >> CXSC_One_p[0];
6312 str =
"+10000000000001e000";
6313 str >> CXSC_One_p[1];
6314 str =
"+10000000000001e000";
6315 str >> CXSC_One_p[2];
6316 CXSC_One_p_initialized =
true;
6317 std::cout << RestoreOpt;
6322 for (
int i=0; i<=stagmax; i++)
6323 y[i+1] = CXSC_One_p[i];
6325 stagprec = stagsave;
6328 return lx_interval(-1023,y);
6331 static real CXSC_Ln10r[40];
6332 static bool CXSC_Ln10r_initialized =
false;
6338 int stagsave = stagprec,
6340 if (!CXSC_Ln10r_initialized)
6343 std::cout << SaveOpt;
6345 str =
"+1BCB7B1526E50Ee7FC";
6346 str >> CXSC_Ln10r[0];
6347 str =
"+195355BAAAFAD3e7C5";
6348 str >> CXSC_Ln10r[1];
6349 str =
"+1EE191F71A3012e78E";
6350 str >> CXSC_Ln10r[2];
6351 str =
"+17268808E8FCB5e757";
6352 str >> CXSC_Ln10r[3];
6353 str =
"+13DE3A94F1D509e71F";
6354 str >> CXSC_Ln10r[4];
6355 str =
"+1DF42805E7E524e6E8";
6356 str >> CXSC_Ln10r[5];
6357 str =
"+11AAC96323250Be6B2";
6358 str >> CXSC_Ln10r[6];
6359 str =
"-1CE63884C058E4e67C";
6360 str >> CXSC_Ln10r[7];
6361 str =
"-1A1C82EA3969BAe646";
6362 str >> CXSC_Ln10r[8];
6363 str =
"+1B4F6686AD7A33e610";
6364 str >> CXSC_Ln10r[9];
6365 str =
"-1B97C8035FFC70e5DA";
6366 str >> CXSC_Ln10r[10];
6367 str =
"+1630771369962Ee59F";
6368 str >> CXSC_Ln10r[11];
6369 str =
"-1E15BD37B295AFe569";
6370 str >> CXSC_Ln10r[12];
6371 str =
"-132484B432318Be533";
6372 str >> CXSC_Ln10r[13];
6373 str =
"+15430212AE68C0e4FD";
6374 str >> CXSC_Ln10r[14];
6375 str =
"+1351923B322731e4C7";
6376 str >> CXSC_Ln10r[15];
6377 str =
"+11F934D794D64Fe491";
6378 str >> CXSC_Ln10r[16];
6379 str =
"+13E4B475D9FF20e45A";
6380 str >> CXSC_Ln10r[17];
6381 str =
"+185D9B63ED9A24e424";
6382 str >> CXSC_Ln10r[18];
6383 str =
"+1ADC650C65E948e3ED";
6384 str >> CXSC_Ln10r[19];
6385 str =
"-1149FBC70C04EAe3B6";
6386 str >> CXSC_Ln10r[20];
6387 str =
"+1056270A8CDF9Ce380";
6388 str >> CXSC_Ln10r[21];
6389 str =
"-1D339476D1076Fe34A";
6390 str >> CXSC_Ln10r[22];
6391 str =
"-1635343A8B5E85e314";
6392 str >> CXSC_Ln10r[23];
6393 str =
"+1DB78151377249e2DC";
6394 str >> CXSC_Ln10r[24];
6395 str =
"+14DD9BD4601639e2A6";
6396 str >> CXSC_Ln10r[25];
6397 str =
"+1D545BF0E9F470e26F";
6398 str >> CXSC_Ln10r[26];
6399 str =
"+17CC4CE204C9F6e239";
6400 str >> CXSC_Ln10r[27];
6401 str =
"+10CED2851AF1ABe200";
6402 str >> CXSC_Ln10r[28];
6403 str =
"-16C9D9EB4EF234e1C9";
6404 str >> CXSC_Ln10r[29];
6405 str =
"-1D67966CCC4205e192";
6406 str >> CXSC_Ln10r[30];
6407 str =
"-1A83D3193C0A22e15C";
6408 str >> CXSC_Ln10r[31];
6409 str =
"-17066494F5F3BEe126";
6410 str >> CXSC_Ln10r[32];
6411 str =
"+12A7753E2FBCACe0F0";
6412 str >> CXSC_Ln10r[33];
6413 str =
"+1FE8D8E367317Be0BA";
6414 str >> CXSC_Ln10r[34];
6415 str =
"+12BB8A7F6B3745e084";
6416 str >> CXSC_Ln10r[35];
6417 str =
"+1D906BB4F052BDe04B";
6418 str >> CXSC_Ln10r[36];
6419 str =
"+1FEED057798219e013";
6420 str >> CXSC_Ln10r[37];
6421 str =
"+100000000010E1e000";
6422 str >> CXSC_Ln10r[38];
6423 str =
"+100000000010E2e000";
6424 str >> CXSC_Ln10r[39];
6426 CXSC_Ln10r_initialized =
true;
6427 std::cout << RestoreOpt;
6432 for (
int i=0; i<=stagmax; i++)
6433 y[i+1] = CXSC_Ln10r[i];
6435 stagprec = stagsave;
6438 return lx_interval(-1023,y);
6443 static real CXSC_Pid4[40];
6444 static bool CXSC_Pid4_initialized =
false;
6450 int stagsave = stagprec,
6452 if (!CXSC_Pid4_initialized)
6455 std::cout << SaveOpt;
6457 str =
"+1921FB54442D18e7FC";
6458 str >> CXSC_Pid4[0];
6459 str =
"+11A62633145C07e7C6";
6460 str >> CXSC_Pid4[1];
6461 str =
"-1F1976B7ED8FBCe78E";
6462 str >> CXSC_Pid4[2];
6463 str =
"+14CF98E804177De758";
6464 str >> CXSC_Pid4[3];
6465 str =
"+131D89CD9128A5e722";
6466 str >> CXSC_Pid4[4];
6467 str =
"+10F31C6809BBDFe6E8";
6468 str >> CXSC_Pid4[5];
6469 str =
"+1519B3CD3A431Be6B1";
6470 str >> CXSC_Pid4[6];
6471 str =
"+18158536F92F8Ae67A";
6472 str >> CXSC_Pid4[7];
6473 str =
"+1BA7F09AB6B6A9e642";
6474 str >> CXSC_Pid4[8];
6475 str =
"-1EDD0DBD2544CFe60A";
6476 str >> CXSC_Pid4[9];
6477 str =
"+179FB1BD1310BAe5D3";
6478 str >> CXSC_Pid4[10];
6479 str =
"+1A637ED6B0BFF6e59D";
6480 str >> CXSC_Pid4[11];
6481 str =
"-1A485FCA40908Ee566";
6482 str >> CXSC_Pid4[12];
6483 str =
"-1E501295D98169e52F";
6484 str >> CXSC_Pid4[13];
6485 str =
"-1160DBEE83B4E0e4F9";
6486 str >> CXSC_Pid4[14];
6487 str =
"-19B6D799AE131Ce4C1";
6488 str >> CXSC_Pid4[15];
6489 str =
"+16CF70801F2E28e48B";
6490 str >> CXSC_Pid4[16];
6491 str =
"+163BF0598DA483e455";
6492 str >> CXSC_Pid4[17];
6493 str =
"+1871574E69A459e41F";
6494 str >> CXSC_Pid4[18];
6495 str =
"-15C0B6CC281F27e3E3";
6496 str >> CXSC_Pid4[19];
6497 str =
"+15D23DCA3AD962e3AD";
6498 str >> CXSC_Pid4[20];
6499 str =
"-1CE8654EFBD56Ae376";
6500 str >> CXSC_Pid4[21];
6501 str =
"-1184AB5BE23DA6e33F";
6502 str >> CXSC_Pid4[22];
6503 str =
"+166D670C354E4Be309";
6504 str >> CXSC_Pid4[23];
6505 str =
"-10D9FEC3A2E4FEe2D3";
6506 str >> CXSC_Pid4[24];
6507 str =
"+1943042F86520Ce29C";
6508 str >> CXSC_Pid4[25];
6509 str =
"-1B9D1C931C41C6e265";
6510 str >> CXSC_Pid4[26];
6511 str =
"-188D3E7F179FC6e22D";
6512 str >> CXSC_Pid4[27];
6513 str =
"-1361F1744FE176e1F7";
6514 str >> CXSC_Pid4[28];
6515 str =
"+1F6B8ABBE0DE99e1C0";
6516 str >> CXSC_Pid4[29];
6517 str =
"-169B10EA1A04B5e18A";
6518 str >> CXSC_Pid4[30];
6519 str =
"-14FD1CF8CD56D0e154";
6520 str >> CXSC_Pid4[31];
6521 str =
"-18AB54A8D7516Fe11E";
6522 str >> CXSC_Pid4[32];
6523 str =
"+186263E8144056e0E7";
6524 str >> CXSC_Pid4[33];
6525 str =
"-1AE34AEAAA77A5e0B0";
6526 str >> CXSC_Pid4[34];
6527 str =
"+16998B8682283De07A";
6528 str >> CXSC_Pid4[35];
6529 str =
"+19D42A90D5EF8Ee042";
6530 str >> CXSC_Pid4[36];
6531 str =
"+174C9D9F70A08Be00C";
6532 str >> CXSC_Pid4[37];
6533 str =
"+100000000000DBe000";
6534 str >> CXSC_Pid4[38];
6535 str =
"+100000000000DCe000";
6536 str >> CXSC_Pid4[39];
6538 CXSC_Pid4_initialized =
true;
6539 std::cout << RestoreOpt;
6544 for (
int i=0; i<=stagmax; i++)
6545 y[i+1] = CXSC_Pid4[i];
6547 stagprec = stagsave;
6550 return lx_interval(-1022,y);
6555 static real CXSC_Pid2[40];
6556 static bool CXSC_Pid2_initialized =
false;
6562 int stagsave = stagprec,
6564 if (!CXSC_Pid2_initialized)
6567 std::cout << SaveOpt;
6569 str =
"+1921FB54442D18e7FC";
6570 str >> CXSC_Pid2[0];
6571 str =
"+11A62633145C07e7C6";
6572 str >> CXSC_Pid2[1];
6573 str =
"-1F1976B7ED8FBCe78E";
6574 str >> CXSC_Pid2[2];
6575 str =
"+14CF98E804177De758";
6576 str >> CXSC_Pid2[3];
6577 str =
"+131D89CD9128A5e722";
6578 str >> CXSC_Pid2[4];
6579 str =
"+10F31C6809BBDFe6E8";
6580 str >> CXSC_Pid2[5];
6581 str =
"+1519B3CD3A431Be6B1";
6582 str >> CXSC_Pid2[6];
6583 str =
"+18158536F92F8Ae67A";
6584 str >> CXSC_Pid2[7];
6585 str =
"+1BA7F09AB6B6A9e642";
6586 str >> CXSC_Pid2[8];
6587 str =
"-1EDD0DBD2544CFe60A";
6588 str >> CXSC_Pid2[9];
6589 str =
"+179FB1BD1310BAe5D3";
6590 str >> CXSC_Pid2[10];
6591 str =
"+1A637ED6B0BFF6e59D";
6592 str >> CXSC_Pid2[11];
6593 str =
"-1A485FCA40908Ee566";
6594 str >> CXSC_Pid2[12];
6595 str =
"-1E501295D98169e52F";
6596 str >> CXSC_Pid2[13];
6597 str =
"-1160DBEE83B4E0e4F9";
6598 str >> CXSC_Pid2[14];
6599 str =
"-19B6D799AE131Ce4C1";
6600 str >> CXSC_Pid2[15];
6601 str =
"+16CF70801F2E28e48B";
6602 str >> CXSC_Pid2[16];
6603 str =
"+163BF0598DA483e455";
6604 str >> CXSC_Pid2[17];
6605 str =
"+1871574E69A459e41F";
6606 str >> CXSC_Pid2[18];
6607 str =
"-15C0B6CC281F27e3E3";
6608 str >> CXSC_Pid2[19];
6609 str =
"+15D23DCA3AD962e3AD";
6610 str >> CXSC_Pid2[20];
6611 str =
"-1CE8654EFBD56Ae376";
6612 str >> CXSC_Pid2[21];
6613 str =
"-1184AB5BE23DA6e33F";
6614 str >> CXSC_Pid2[22];
6615 str =
"+166D670C354E4Be309";
6616 str >> CXSC_Pid2[23];
6617 str =
"-10D9FEC3A2E4FEe2D3";
6618 str >> CXSC_Pid2[24];
6619 str =
"+1943042F86520Ce29C";
6620 str >> CXSC_Pid2[25];
6621 str =
"-1B9D1C931C41C6e265";
6622 str >> CXSC_Pid2[26];
6623 str =
"-188D3E7F179FC6e22D";
6624 str >> CXSC_Pid2[27];
6625 str =
"-1361F1744FE176e1F7";
6626 str >> CXSC_Pid2[28];
6627 str =
"+1F6B8ABBE0DE99e1C0";
6628 str >> CXSC_Pid2[29];
6629 str =
"-169B10EA1A04B5e18A";
6630 str >> CXSC_Pid2[30];
6631 str =
"-14FD1CF8CD56D0e154";
6632 str >> CXSC_Pid2[31];
6633 str =
"-18AB54A8D7516Fe11E";
6634 str >> CXSC_Pid2[32];
6635 str =
"+186263E8144056e0E7";
6636 str >> CXSC_Pid2[33];
6637 str =
"-1AE34AEAAA77A5e0B0";
6638 str >> CXSC_Pid2[34];
6639 str =
"+16998B8682283De07A";
6640 str >> CXSC_Pid2[35];
6641 str =
"+19D42A90D5EF8Ee042";
6642 str >> CXSC_Pid2[36];
6643 str =
"+174C9D9F70A08Be00C";
6644 str >> CXSC_Pid2[37];
6645 str =
"+100000000000DBe000";
6646 str >> CXSC_Pid2[38];
6647 str =
"+100000000000DCe000";
6648 str >> CXSC_Pid2[39];
6650 CXSC_Pid2_initialized =
true;
6651 std::cout << RestoreOpt;
6656 for (
int i=0; i<=stagmax; i++)
6657 y[i+1] = CXSC_Pid2[i];
6659 stagprec = stagsave;
6662 return lx_interval(-1021,y);
6667 static real CXSC_Pi2[40];
6668 static bool CXSC_Pi2_initialized =
false;
6674 int stagsave = stagprec,
6676 if (!CXSC_Pi2_initialized)
6679 std::cout << SaveOpt;
6681 str =
"+1921FB54442D18e7FC";
6683 str =
"+11A62633145C07e7C6";
6685 str =
"-1F1976B7ED8FBCe78E";
6687 str =
"+14CF98E804177De758";
6689 str =
"+131D89CD9128A5e722";
6691 str =
"+10F31C6809BBDFe6E8";
6693 str =
"+1519B3CD3A431Be6B1";
6695 str =
"+18158536F92F8Ae67A";
6697 str =
"+1BA7F09AB6B6A9e642";
6699 str =
"-1EDD0DBD2544CFe60A";
6701 str =
"+179FB1BD1310BAe5D3";
6702 str >> CXSC_Pi2[10];
6703 str =
"+1A637ED6B0BFF6e59D";
6704 str >> CXSC_Pi2[11];
6705 str =
"-1A485FCA40908Ee566";
6706 str >> CXSC_Pi2[12];
6707 str =
"-1E501295D98169e52F";
6708 str >> CXSC_Pi2[13];
6709 str =
"-1160DBEE83B4E0e4F9";
6710 str >> CXSC_Pi2[14];
6711 str =
"-19B6D799AE131Ce4C1";
6712 str >> CXSC_Pi2[15];
6713 str =
"+16CF70801F2E28e48B";
6714 str >> CXSC_Pi2[16];
6715 str =
"+163BF0598DA483e455";
6716 str >> CXSC_Pi2[17];
6717 str =
"+1871574E69A459e41F";
6718 str >> CXSC_Pi2[18];
6719 str =
"-15C0B6CC281F27e3E3";
6720 str >> CXSC_Pi2[19];
6721 str =
"+15D23DCA3AD962e3AD";
6722 str >> CXSC_Pi2[20];
6723 str =
"-1CE8654EFBD56Ae376";
6724 str >> CXSC_Pi2[21];
6725 str =
"-1184AB5BE23DA6e33F";
6726 str >> CXSC_Pi2[22];
6727 str =
"+166D670C354E4Be309";
6728 str >> CXSC_Pi2[23];
6729 str =
"-10D9FEC3A2E4FEe2D3";
6730 str >> CXSC_Pi2[24];
6731 str =
"+1943042F86520Ce29C";
6732 str >> CXSC_Pi2[25];
6733 str =
"-1B9D1C931C41C6e265";
6734 str >> CXSC_Pi2[26];
6735 str =
"-188D3E7F179FC6e22D";
6736 str >> CXSC_Pi2[27];
6737 str =
"-1361F1744FE176e1F7";
6738 str >> CXSC_Pi2[28];
6739 str =
"+1F6B8ABBE0DE99e1C0";
6740 str >> CXSC_Pi2[29];
6741 str =
"-169B10EA1A04B5e18A";
6742 str >> CXSC_Pi2[30];
6743 str =
"-14FD1CF8CD56D0e154";
6744 str >> CXSC_Pi2[31];
6745 str =
"-18AB54A8D7516Fe11E";
6746 str >> CXSC_Pi2[32];
6747 str =
"+186263E8144056e0E7";
6748 str >> CXSC_Pi2[33];
6749 str =
"-1AE34AEAAA77A5e0B0";
6750 str >> CXSC_Pi2[34];
6751 str =
"+16998B8682283De07A";
6752 str >> CXSC_Pi2[35];
6753 str =
"+19D42A90D5EF8Ee042";
6754 str >> CXSC_Pi2[36];
6755 str =
"+174C9D9F70A08Be00C";
6756 str >> CXSC_Pi2[37];
6757 str =
"+100000000000DBe000";
6758 str >> CXSC_Pi2[38];
6759 str =
"+100000000000DCe000";
6760 str >> CXSC_Pi2[39];
6762 CXSC_Pi2_initialized =
true;
6763 std::cout << RestoreOpt;
6768 for (
int i=0; i<=stagmax; i++)
6769 y[i+1] = CXSC_Pi2[i];
6771 stagprec = stagsave;
6774 return lx_interval(-1019,y);
6779 static real CXSC_Pi2r[40];
6780 static bool CXSC_Pi2r_initialized =
false;
6786 int stagsave = stagprec,
6788 if (!CXSC_Pi2r_initialized)
6791 std::cout << SaveOpt;
6793 str =
"+145F306DC9C883e7FC";
6794 str >> CXSC_Pi2r[0];
6795 str =
"-16B01EC5417056e7C6";
6796 str >> CXSC_Pi2r[1];
6797 str =
"-16447E493AD4CEe790";
6798 str >> CXSC_Pi2r[2];
6799 str =
"+1E21C820FF28B2e75A";
6800 str >> CXSC_Pi2r[3];
6801 str =
"-1508510EA79237e723";
6802 str >> CXSC_Pi2r[4];
6803 str =
"+1B8E909374B802e6EB";
6804 str >> CXSC_Pi2r[5];
6805 str =
"-1B6D115F62E6DEe6B5";
6806 str >> CXSC_Pi2r[6];
6807 str =
"-180F10A71A76B3e67E";
6808 str >> CXSC_Pi2r[7];
6809 str =
"+1CFBA208D7D4BBe647";
6810 str >> CXSC_Pi2r[8];
6811 str =
"-12EDEC598E3F65e60F";
6812 str >> CXSC_Pi2r[9];
6813 str =
"-1741037D8CDC54e5D8";
6814 str >> CXSC_Pi2r[10];
6815 str =
"+1CC1A99CFA4E42e5A2";
6816 str >> CXSC_Pi2r[11];
6817 str =
"+17E2EF7E4A0EC8e56B";
6818 str >> CXSC_Pi2r[12];
6819 str =
"-1DA00087E99FC0e52F";
6820 str >> CXSC_Pi2r[13];
6821 str =
"-10D0EE74A5F593e4F9";
6822 str >> CXSC_Pi2r[14];
6823 str =
"+1F6D367ECF27CBe4C1";
6824 str >> CXSC_Pi2r[15];
6825 str =
"+136E9E8C7ECD3De488";
6826 str >> CXSC_Pi2r[16];
6827 str =
"-100AE9456C229Ce452";
6828 str >> CXSC_Pi2r[17];
6829 str =
"-141A0E84C2F8C6e419";
6830 str >> CXSC_Pi2r[18];
6831 str =
"-10EB5ADA2B2809e3E0";
6832 str >> CXSC_Pi2r[19];
6833 str =
"-10277039517BD5e3AA";
6834 str >> CXSC_Pi2r[20];
6835 str =
"+198237E3DB5D60e36E";
6836 str >> CXSC_Pi2r[21];
6837 str =
"-1E6087BECA1794e338";
6838 str >> CXSC_Pi2r[22];
6839 str =
"+1DA9E391615EE6e301";
6840 str >> CXSC_Pi2r[23];
6841 str =
"+1B086599855F15e2C9";
6842 str >> CXSC_Pi2r[24];
6843 str =
"-17E5EFDC8009E0e293";
6844 str >> CXSC_Pi2r[25];
6845 str =
"+135CC9CC418185e25B";
6846 str >> CXSC_Pi2r[26];
6847 str =
"+156CA73A8C960Ee225";
6848 str >> CXSC_Pi2r[27];
6849 str =
"+13DE04635A3E21e1EE";
6850 str >> CXSC_Pi2r[28];
6851 str =
"-18F260C88C5FDBe1B7";
6852 str >> CXSC_Pi2r[29];
6853 str =
"-157CA63B89746Ae181";
6854 str >> CXSC_Pi2r[30];
6855 str =
"+1CA6DDAF44D157e149";
6856 str >> CXSC_Pi2r[31];
6857 str =
"+19053EA5FF0705e111";
6858 str >> CXSC_Pi2r[32];
6859 str =
"+1FBF19F419616Fe0DA";
6860 str >> CXSC_Pi2r[33];
6861 str =
"+13E60C9F6EF0CFe0A3";
6862 str >> CXSC_Pi2r[34];
6863 str =
"+126EF6B1E5EF8Ae06D";
6864 str >> CXSC_Pi2r[35];
6865 str =
"-18BC1946A1B01Ce034";
6866 str >> CXSC_Pi2r[36];
6867 str =
"-12780EDE6F8384e000";
6868 str >> CXSC_Pi2r[37];
6869 str =
"+10000000000000e000";
6870 str >> CXSC_Pi2r[38];
6871 str =
"+10000000000001e000";
6872 str >> CXSC_Pi2r[39];
6874 CXSC_Pi2r_initialized =
true;
6875 std::cout << RestoreOpt;
6880 for (
int i=0; i<=stagmax; i++)
6881 y[i+1] = CXSC_Pi2r[i];
6883 stagprec = stagsave;
6886 return lx_interval(-1024,y);
6891 static real CXSC_Pip2[40];
6892 static bool CXSC_Pip2_initialized =
false;
6898 int stagsave = stagprec,
6900 if (!CXSC_Pip2_initialized)
6903 std::cout << SaveOpt;
6905 str =
"+13BD3CC9BE45DEe7FD";
6906 str >> CXSC_Pip2[0];
6907 str =
"+1692B71366CC04e7C7";
6908 str >> CXSC_Pip2[1];
6909 str =
"+18358E10ACD480e791";
6910 str >> CXSC_Pip2[2];
6911 str =
"-1F2F5DD7997DDFe75A";
6912 str >> CXSC_Pip2[3];
6913 str =
"+129E39B47B884Ee71F";
6914 str >> CXSC_Pip2[4];
6915 str =
"-12CF7459DD5DAFe6E9";
6916 str >> CXSC_Pip2[5];
6917 str =
"-11842F87B5FE0Fe6B3";
6918 str >> CXSC_Pip2[6];
6919 str =
"+1FFD8A79616A21e67D";
6920 str >> CXSC_Pip2[7];
6921 str =
"+12492A6663E899e647";
6922 str >> CXSC_Pip2[8];
6923 str =
"-1A15F4352CC511e610";
6924 str >> CXSC_Pip2[9];
6925 str =
"-1301AA1792FF3Ce5D9";
6926 str >> CXSC_Pip2[10];
6927 str =
"+122B6F31626EFEe5A3";
6928 str >> CXSC_Pip2[11];
6929 str =
"+1B317FA13BDD8Fe56D";
6930 str >> CXSC_Pip2[12];
6931 str =
"+16F83B49040075e537";
6932 str >> CXSC_Pip2[13];
6933 str =
"-1B1890A945FE17e501";
6934 str >> CXSC_Pip2[14];
6935 str =
"+12DCD389B96CDBe4CB";
6936 str >> CXSC_Pip2[15];
6937 str =
"-1743F5DDE2F157e492";
6938 str >> CXSC_Pip2[16];
6939 str =
"-153F96FFD4AEB5e45B";
6940 str >> CXSC_Pip2[17];
6941 str =
"+13CD6F5847D569e423";
6942 str >> CXSC_Pip2[18];
6943 str =
"+1471E79A7B0882e3EC";
6944 str >> CXSC_Pip2[19];
6945 str =
"-14C5022456E37Ae3B6";
6946 str >> CXSC_Pip2[20];
6947 str =
"-1471463BD938A3e380";
6948 str >> CXSC_Pip2[21];
6949 str =
"+13EABA147FEB41e349";
6950 str >> CXSC_Pip2[22];
6951 str =
"-1D7FBCA9B23073e312";
6952 str >> CXSC_Pip2[23];
6953 str =
"-17B06B8196DD15e2DC";
6954 str >> CXSC_Pip2[24];
6955 str =
"-13A91786954EA1e2A6";
6956 str >> CXSC_Pip2[25];
6957 str =
"+1C841C914201E8e26F";
6958 str >> CXSC_Pip2[26];
6959 str =
"-1BDD5D6465807De239";
6960 str >> CXSC_Pip2[27];
6961 str =
"-1BD8C694B35945e202";
6962 str >> CXSC_Pip2[28];
6963 str =
"+181914426DA9A7e1CC";
6964 str >> CXSC_Pip2[29];
6965 str =
"-1C83BE2430C1FEe192";
6966 str >> CXSC_Pip2[30];
6967 str =
"+16530E2CE920C0e157";
6968 str >> CXSC_Pip2[31];
6969 str =
"+103B8F2850B82Ee121";
6970 str >> CXSC_Pip2[32];
6971 str =
"-1F116B01D43595e0EB";
6972 str >> CXSC_Pip2[33];
6973 str =
"-13AF6BD210759Fe0B5";
6974 str >> CXSC_Pip2[34];
6975 str =
"+1F82CDE6A1FFF3e07E";
6976 str >> CXSC_Pip2[35];
6977 str =
"+1C8EF198F1ACD2e048";
6978 str >> CXSC_Pip2[36];
6979 str =
"+18077590C18251e011";
6980 str >> CXSC_Pip2[37];
6981 str =
"-10000000002C7Ee000";
6982 str >> CXSC_Pip2[38];
6983 str =
"-10000000002C7De000";
6984 str >> CXSC_Pip2[39];
6986 CXSC_Pip2_initialized =
true;
6987 std::cout << RestoreOpt;
6992 for (
int i=0; i<=stagmax; i++)
6993 y[i+1] = CXSC_Pip2[i];
6995 stagprec = stagsave;
6998 return lx_interval(-1019,y);
7003 static real CXSC_Sqrt2r[40];
7004 static bool CXSC_Sqrt2r_initialized =
false;
7010 int stagsave = stagprec,
7012 if (!CXSC_Sqrt2r_initialized)
7015 std::cout << SaveOpt;
7017 str =
"+16A09E667F3BCDe7FC";
7018 str >> CXSC_Sqrt2r[0];
7019 str =
"-1BDD3413B26456e7C6";
7020 str >> CXSC_Sqrt2r[1];
7021 str =
"+157D3E3ADEC175e790";
7022 str >> CXSC_Sqrt2r[2];
7023 str =
"+12775099DA2F59e758";
7024 str >> CXSC_Sqrt2r[3];
7025 str =
"+160CCE64552BF2e71F";
7026 str >> CXSC_Sqrt2r[4];
7027 str =
"+1821D5C5161D46e6E6";
7028 str >> CXSC_Sqrt2r[5];
7029 str =
"-1C032046F8498Ee6B0";
7030 str >> CXSC_Sqrt2r[6];
7031 str =
"+1EE950BC8738F7e678";
7032 str >> CXSC_Sqrt2r[7];
7033 str =
"-1AC3FDBC64E103e642";
7034 str >> CXSC_Sqrt2r[8];
7035 str =
"+13B469101743A1e60A";
7036 str >> CXSC_Sqrt2r[9];
7037 str =
"+15E3E9CA60B38Ce5D4";
7038 str >> CXSC_Sqrt2r[10];
7039 str =
"+11BC337BCAB1BDe599";
7040 str >> CXSC_Sqrt2r[11];
7041 str =
"-1BBA5DEE9D6E7De563";
7042 str >> CXSC_Sqrt2r[12];
7043 str =
"-1438DD083B1CC4e52D";
7044 str >> CXSC_Sqrt2r[13];
7045 str =
"+1B56A28E2EDFA7e4F7";
7046 str >> CXSC_Sqrt2r[14];
7047 str =
"+1CCB2A634331F4e4C1";
7048 str >> CXSC_Sqrt2r[15];
7049 str =
"-1BD9056876F83Ee48A";
7050 str >> CXSC_Sqrt2r[16];
7051 str =
"-1234FA22AB6BEFe454";
7052 str >> CXSC_Sqrt2r[17];
7053 str =
"+19040CA4A81395e41D";
7054 str >> CXSC_Sqrt2r[18];
7055 str =
"-15249C0BC4082De3E7";
7056 str >> CXSC_Sqrt2r[19];
7057 str =
"+13A02CEBC93E0Ce3B1";
7058 str >> CXSC_Sqrt2r[20];
7059 str =
"+109936AF354A2Ee37B";
7060 str >> CXSC_Sqrt2r[21];
7061 str =
"-1AE4730CBE4908e345";
7062 str >> CXSC_Sqrt2r[22];
7063 str =
"+11B6380826E010e30E";
7064 str >> CXSC_Sqrt2r[23];
7065 str =
"-1CDCAD0CCD5A16e2D5";
7066 str >> CXSC_Sqrt2r[24];
7067 str =
"-1084BC28012BC8e29C";
7068 str >> CXSC_Sqrt2r[25];
7069 str =
"-1C035DDECF8216e265";
7070 str >> CXSC_Sqrt2r[26];
7071 str =
"+18907DEAA070B0e22B";
7072 str >> CXSC_Sqrt2r[27];
7073 str =
"+1FCBDDEA2F7DC3e1F5";
7074 str >> CXSC_Sqrt2r[28];
7075 str =
"+18C41C51757FB0e1BE";
7076 str >> CXSC_Sqrt2r[29];
7077 str =
"-189A5B616B1381e188";
7078 str >> CXSC_Sqrt2r[30];
7079 str =
"+165C417EFF0B88e152";
7080 str >> CXSC_Sqrt2r[31];
7081 str =
"-1627043F832999e11A";
7082 str >> CXSC_Sqrt2r[32];
7083 str =
"+105E5FCA017092e0E3";
7084 str >> CXSC_Sqrt2r[33];
7085 str =
"-187A16D6A8FDCAe0AD";
7086 str >> CXSC_Sqrt2r[34];
7087 str =
"-1838421AE0AE62e072";
7088 str >> CXSC_Sqrt2r[35];
7089 str =
"-165073EB433984e03C";
7090 str >> CXSC_Sqrt2r[36];
7091 str =
"+1F0A42F9DA4A6Ce006";
7092 str >> CXSC_Sqrt2r[37];
7093 str =
"+10000000000002e000";
7094 str >> CXSC_Sqrt2r[38];
7095 str =
"+10000000000003e000";
7096 str >> CXSC_Sqrt2r[39];
7098 CXSC_Sqrt2r_initialized =
true;
7099 std::cout << RestoreOpt;
7104 for (
int i=0; i<=stagmax; i++)
7105 y[i+1] = CXSC_Sqrt2r[i];
7107 stagprec = stagsave;
7110 return lx_interval(-1022,y);
7115 static real CXSC_Sqrt3d2[40];
7116 static bool CXSC_Sqrt3d2_initialized =
false;
7122 int stagsave = stagprec,
7124 if (!CXSC_Sqrt3d2_initialized)
7127 std::cout << SaveOpt;
7129 str =
"+1BB67AE8584CAAe7FC";
7130 str >> CXSC_Sqrt3d2[0];
7131 str =
"+1CEC95D0B5C1E3e7C6";
7132 str >> CXSC_Sqrt3d2[1];
7133 str =
"-1F11DB689F2CCFe78E";
7134 str >> CXSC_Sqrt3d2[2];
7135 str =
"+13DA4798C720A6e758";
7136 str >> CXSC_Sqrt3d2[3];
7137 str =
"+121B9169B89243e722";
7138 str >> CXSC_Sqrt3d2[4];
7139 str =
"-1813508751212Be6E9";
7140 str >> CXSC_Sqrt3d2[5];
7141 str =
"-1B3D547B775C1Ee6B2";
7142 str >> CXSC_Sqrt3d2[6];
7143 str =
"-19D986D92E2F0Ae679";
7144 str >> CXSC_Sqrt3d2[7];
7145 str =
"+1A34334CE806B6e642";
7146 str >> CXSC_Sqrt3d2[8];
7147 str =
"+1A383B9E122E61e60C";
7148 str >> CXSC_Sqrt3d2[9];
7149 str =
"+1C61D736F2F6F2e5D5";
7150 str >> CXSC_Sqrt3d2[10];
7151 str =
"-10AF49233F9250e59E";
7152 str >> CXSC_Sqrt3d2[11];
7153 str =
"-1558A109EC0523e567";
7154 str >> CXSC_Sqrt3d2[12];
7155 str =
"+1F799D4D4FF2BCe531";
7156 str >> CXSC_Sqrt3d2[13];
7157 str =
"-1AD7B219E34EDBe4FB";
7158 str >> CXSC_Sqrt3d2[14];
7159 str =
"+15AB940B6677E3e4C5";
7160 str >> CXSC_Sqrt3d2[15];
7161 str =
"-1D9B2A8203B8F0e48E";
7162 str >> CXSC_Sqrt3d2[16];
7163 str =
"-1DB0C8975A3834e458";
7164 str >> CXSC_Sqrt3d2[17];
7165 str =
"-1BCAAB3F6BE884e422";
7166 str >> CXSC_Sqrt3d2[18];
7167 str =
"+14C70ADB1EC1BBe3E8";
7168 str >> CXSC_Sqrt3d2[19];
7169 str =
"-14E1EF77987E55e3AF";
7170 str >> CXSC_Sqrt3d2[20];
7171 str =
"-19695FC6269D28e378";
7172 str >> CXSC_Sqrt3d2[21];
7173 str =
"+10D0652AAC5936e342";
7174 str >> CXSC_Sqrt3d2[22];
7175 str =
"-1BD0891D370824e30C";
7176 str >> CXSC_Sqrt3d2[23];
7177 str =
"-129B4C6252D061e2D4";
7178 str >> CXSC_Sqrt3d2[24];
7179 str =
"+1DC9B1A4C31275e29E";
7180 str >> CXSC_Sqrt3d2[25];
7181 str =
"+11FF9B8422294Ee267";
7182 str >> CXSC_Sqrt3d2[26];
7183 str =
"-1E4A6AA47F3A85e231";
7184 str >> CXSC_Sqrt3d2[27];
7185 str =
"+17043E01AA3F3De1FA";
7186 str >> CXSC_Sqrt3d2[28];
7187 str =
"+188EF377D2D5B6e1C0";
7188 str >> CXSC_Sqrt3d2[29];
7189 str =
"-1735E8C815F031e185";
7190 str >> CXSC_Sqrt3d2[30];
7191 str =
"-1B89330FD8417Ce14F";
7192 str >> CXSC_Sqrt3d2[31];
7193 str =
"+16D1A627670F5Ce117";
7194 str >> CXSC_Sqrt3d2[32];
7195 str =
"+1AF43BBA8154D3e0DB";
7196 str >> CXSC_Sqrt3d2[33];
7197 str =
"+1DA9A969A91295e0A5";
7198 str >> CXSC_Sqrt3d2[34];
7199 str =
"-1636594394C675e06E";
7200 str >> CXSC_Sqrt3d2[35];
7201 str =
"+1064B9DA1A3185e037";
7202 str >> CXSC_Sqrt3d2[36];
7203 str =
"-1CE514CF1825CCe001";
7204 str >> CXSC_Sqrt3d2[37];
7205 str =
"+10000000000000e000";
7206 str >> CXSC_Sqrt3d2[38];
7207 str =
"+10000000000001e000";
7208 str >> CXSC_Sqrt3d2[39];
7210 CXSC_Sqrt3d2_initialized =
true;
7211 std::cout << RestoreOpt;
7216 for (
int i=0; i<=stagmax; i++)
7217 y[i+1] = CXSC_Sqrt3d2[i];
7219 stagprec = stagsave;
7222 return lx_interval(-1022,y);
7227 static real CXSC_Sqrt3r[40];
7228 static bool CXSC_Sqrt3r_initialized =
false;
7234 int stagsave = stagprec,
7236 if (!CXSC_Sqrt3r_initialized)
7239 std::cout << SaveOpt;
7241 str =
"+1279A74590331Ce7FC";
7242 str >> CXSC_Sqrt3r[0];
7243 str =
"+134863E0792BEDe7C6";
7244 str >> CXSC_Sqrt3r[1];
7245 str =
"-1A82F9E6C53222e790";
7246 str >> CXSC_Sqrt3r[2];
7247 str =
"-1CB0F41134253Ae75A";
7248 str >> CXSC_Sqrt3r[3];
7249 str =
"+1859ED919EC30Be724";
7250 str >> CXSC_Sqrt3r[4];
7251 str =
"+1454874FB1F3F4e6ED";
7252 str >> CXSC_Sqrt3r[5];
7253 str =
"-1DE69C6D3D2741e6B7";
7254 str >> CXSC_Sqrt3r[6];
7255 str =
"+17EEC450C48BE1e681";
7256 str >> CXSC_Sqrt3r[7];
7257 str =
"-16F743EEE65D53e64B";
7258 str >> CXSC_Sqrt3r[8];
7259 str =
"-1887B505D7E7C2e613";
7260 str >> CXSC_Sqrt3r[9];
7261 str =
"-1484D2E10C1161e5DC";
7262 str >> CXSC_Sqrt3r[10];
7263 str =
"-1A0B1F86177FB7e5A6";
7264 str >> CXSC_Sqrt3r[11];
7265 str =
"+1FE389D3F2C54Ee56E";
7266 str >> CXSC_Sqrt3r[12];
7267 str =
"+1F29F77C671544e538";
7268 str >> CXSC_Sqrt3r[13];
7269 str =
"-16CE74ED77D9BEe502";
7270 str >> CXSC_Sqrt3r[14];
7271 str =
"-1E38708FF0CCB5e4CC";
7272 str >> CXSC_Sqrt3r[15];
7273 str =
"-1F13BCC70157D1e496";
7274 str >> CXSC_Sqrt3r[16];
7275 str =
"+17EC34CF9B1930e460";
7276 str >> CXSC_Sqrt3r[17];
7277 str =
"-117A638EFF3A8Be429";
7278 str >> CXSC_Sqrt3r[18];
7279 str =
"-16A8EF69C312C5e3F3";
7280 str >> CXSC_Sqrt3r[19];
7281 str =
"-1835C4B4FD2883e3BC";
7282 str >> CXSC_Sqrt3r[20];
7283 str =
"+178E66E7009A44e386";
7284 str >> CXSC_Sqrt3r[21];
7285 str =
"-136FD3299CE38Ae350";
7286 str >> CXSC_Sqrt3r[22];
7287 str =
"+10CE607E925CC3e31A";
7288 str >> CXSC_Sqrt3r[23];
7289 str =
"-1AC2B71232EC37e2E4";
7290 str >> CXSC_Sqrt3r[24];
7291 str =
"-1ACAD8486879A7e2AD";
7292 str >> CXSC_Sqrt3r[25];
7293 str =
"+1B7C6155125817e277";
7294 str >> CXSC_Sqrt3r[26];
7295 str =
"-1CE6286338DB54e240";
7296 str >> CXSC_Sqrt3r[27];
7297 str =
"-13819B52815439e20A";
7298 str >> CXSC_Sqrt3r[28];
7299 str =
"-159653496BB604e1D3";
7300 str >> CXSC_Sqrt3r[29];
7301 str =
"+1E3CEA8BB81EF5e19C";
7302 str >> CXSC_Sqrt3r[30];
7303 str =
"+1C0A89B6922280e165";
7304 str >> CXSC_Sqrt3r[31];
7305 str =
"+1A7F02B9E11970e12F";
7306 str >> CXSC_Sqrt3r[32];
7307 str =
"-197D70AA62CA0Be0F9";
7308 str >> CXSC_Sqrt3r[33];
7309 str =
"-18FF1CC85B90E7e0C3";
7310 str >> CXSC_Sqrt3r[34];
7311 str =
"+19C2DC378988CFe08B";
7312 str >> CXSC_Sqrt3r[35];
7313 str =
"-1A1BB3467EF366e055";
7314 str >> CXSC_Sqrt3r[36];
7315 str =
"+1166CBADB2F273e01F";
7316 str >> CXSC_Sqrt3r[37];
7317 str =
"+1000000B453C22e000";
7318 str >> CXSC_Sqrt3r[38];
7319 str =
"+1000000B453C23e000";
7320 str >> CXSC_Sqrt3r[39];
7322 CXSC_Sqrt3r_initialized =
true;
7323 std::cout << RestoreOpt;
7328 for (
int i=0; i<=stagmax; i++)
7329 y[i+1] = CXSC_Sqrt3r[i];
7331 stagprec = stagsave;
7334 return lx_interval(-1022,y);
7339 static real CXSC_Er[40];
7340 static bool CXSC_Er_initialized =
false;
7346 int stagsave = stagprec,
7348 if (!CXSC_Er_initialized)
7351 std::cout << SaveOpt;
7353 str =
"+178B56362CEF38e7FC";
7355 str =
"-1CA8A4270FADF5e7C5";
7357 str =
"-1837912B3FD2AAe78F";
7359 str =
"-152711999FB68Ce759";
7361 str =
"-17AD7C1289274Ee723";
7363 str =
"+17E8E56842B705e6E5";
7365 str =
"-1D24CB13796C2De6AF";
7367 str =
"-1456AABDA5C8F2e678";
7369 str =
"+1229F03C6276DDe642";
7371 str =
"-1569CFC4F53109e60C";
7373 str =
"-155B63C9B68091e5D4";
7375 str =
"+1580CF14DC087Ce59E";
7377 str =
"+1F9FF222313669e567";
7379 str =
"+15BC9CB1A22487e531";
7381 str =
"-1857E415C89B13e4FA";
7383 str =
"+13DF75706E3643e4C4";
7385 str =
"+13BDF5B7646234e48C";
7387 str =
"+1C956A5A3BE55De456";
7389 str =
"-167243FE9CD95Ee41F";
7391 str =
"+1798666D9D76F9e3E9";
7393 str =
"-195BC96299ED95e3B3";
7395 str =
"-1962287D82F280e37D";
7397 str =
"+1C3CF6DDC027D8e347";
7399 str =
"-182A3C09F5C0B7e310";
7401 str =
"+181C26FE7F6AB1e2DA";
7403 str =
"+19F6D7E4825294e2A4";
7405 str =
"+1BBC423BEA892Fe26D";
7407 str =
"+1342C7A3A14AB4e237";
7409 str =
"+12A70DFB042173e201";
7411 str =
"-10325653502352e1CB";
7413 str =
"-10AD4492DE41FFe191";
7415 str =
"-1E4529AB93CDA1e156";
7417 str =
"+1128833F39DF0Ae11E";
7419 str =
"-1E7EDF8F9B8A50e0E8";
7421 str =
"+1A42CBDB5BB8D0e0B0";
7423 str =
"+1973F3BD8250A1e07A";
7425 str =
"+116AF9EF0E6C71e040";
7427 str =
"-1786993285AA7Ae00A";
7429 str =
"-1000000000007De000";
7431 str =
"-1000000000007Ce000";
7434 CXSC_Er_initialized =
true;
7435 std::cout << RestoreOpt;
7440 for (
int i=0; i<=stagmax; i++)
7441 y[i+1] = CXSC_Er[i];
7443 stagprec = stagsave;
7446 return lx_interval(-1023,y);
7451 static real CXSC_Ep2[40];
7452 static bool CXSC_Ep2_initialized =
false;
7458 int stagsave = stagprec,
7460 if (!CXSC_Ep2_initialized)
7463 std::cout << SaveOpt;
7465 str =
"+1D8E64B8D4DDAEe7FC";
7467 str =
"-19E62E22EFCA4Ce7C5";
7469 str =
"+1577508F5CF5EDe78F";
7471 str =
"-186EF0294C2511e759";
7473 str =
"+177D109F148782e722";
7475 str =
"+166BBC354AB700e6EB";
7477 str =
"-1273AEC0115969e6B5";
7479 str =
"-1C5AE00D3BEEF1e67F";
7481 str =
"+15ACA3FDC9595Fe647";
7483 str =
"-113FCDFE2B1F0Ce610";
7485 str =
"+10EEDFD1AE90C9e5DA";
7486 str >> CXSC_Ep2[10];
7487 str =
"+1D2CB8EDC7078Be5A4";
7488 str >> CXSC_Ep2[11];
7489 str =
"+11827A19F175F8e56E";
7490 str >> CXSC_Ep2[12];
7491 str =
"-10267512A9BFB2e537";
7492 str >> CXSC_Ep2[13];
7493 str =
"-19A1E2FC413AE3e500";
7494 str >> CXSC_Ep2[14];
7495 str =
"+1170C7A5981ADBe4CA";
7496 str >> CXSC_Ep2[15];
7497 str =
"-1FC991480067CFe494";
7498 str >> CXSC_Ep2[16];
7499 str =
"-12E9A54CF5CFB5e45D";
7500 str >> CXSC_Ep2[17];
7501 str =
"-166FA6C468910Ae425";
7502 str >> CXSC_Ep2[18];
7503 str =
"+10FA9B7050AF8De3EE";
7504 str >> CXSC_Ep2[19];
7505 str =
"+198127CED41761e3B7";
7506 str >> CXSC_Ep2[20];
7507 str =
"+107FD1EB487B65e380";
7508 str >> CXSC_Ep2[21];
7509 str =
"+1B63EE064187DBe348";
7510 str >> CXSC_Ep2[22];
7511 str =
"+13C943324AF1B5e311";
7512 str >> CXSC_Ep2[23];
7513 str =
"+16AAE6F376094Ee2DA";
7514 str >> CXSC_Ep2[24];
7515 str =
"+15DBB3D45B5A29e2A4";
7516 str >> CXSC_Ep2[25];
7517 str =
"-181BC5BF587296e26E";
7518 str >> CXSC_Ep2[26];
7519 str =
"-1819FC0B42A502e235";
7520 str >> CXSC_Ep2[27];
7521 str =
"-1E06AE15A2D879e1FF";
7522 str >> CXSC_Ep2[28];
7523 str =
"+171395ABE3E6CEe1C8";
7524 str >> CXSC_Ep2[29];
7525 str =
"-1B76514AE69513e192";
7526 str >> CXSC_Ep2[30];
7527 str =
"-1707F6C56433B7e15C";
7528 str >> CXSC_Ep2[31];
7529 str =
"+108C1FADE66FE9e126";
7530 str >> CXSC_Ep2[32];
7531 str =
"+1FB253285CC9E2e0F0";
7532 str >> CXSC_Ep2[33];
7533 str =
"-16B3E49A6C1691e0B9";
7534 str >> CXSC_Ep2[34];
7535 str =
"-12B135E875C44Ae080";
7536 str >> CXSC_Ep2[35];
7537 str =
"+1385B11510C48Ce04A";
7538 str >> CXSC_Ep2[36];
7539 str =
"-184E63EB2E35F1e010";
7540 str >> CXSC_Ep2[37];
7541 str =
"+1000000000063Ee000";
7542 str >> CXSC_Ep2[38];
7543 str =
"+1000000000064Ee000";
7544 str >> CXSC_Ep2[39];
7546 CXSC_Ep2_initialized =
true;
7547 std::cout << RestoreOpt;
7552 for (
int i=0; i<=stagmax; i++)
7553 y[i+1] = CXSC_Ep2[i];
7555 stagprec = stagsave;
7558 return lx_interval(-1019,y);
7563 static real CXSC_Ep2r[40];
7564 static bool CXSC_Ep2r_initialized =
false;
7570 int stagsave = stagprec,
7572 if (!CXSC_Ep2r_initialized)
7575 std::cout << SaveOpt;
7577 str =
"+1152AAA3BF81CCe7FD";
7578 str >> CXSC_Ep2r[0];
7579 str =
"-1809224547B4BFe7C7";
7580 str >> CXSC_Ep2r[1];
7581 str =
"-16A8E079134F13e791";
7582 str >> CXSC_Ep2r[2];
7583 str =
"+14564CACF0994Ee759";
7584 str >> CXSC_Ep2r[3];
7585 str =
"+1B796438129AF8e723";
7586 str >> CXSC_Ep2r[4];
7587 str =
"-1ACFED57EF2AE5e6ED";
7588 str >> CXSC_Ep2r[5];
7589 str =
"-1A968CBDBB5D9De6B6";
7590 str >> CXSC_Ep2r[6];
7591 str =
"+1A7238CBD97B71e67D";
7592 str >> CXSC_Ep2r[7];
7593 str =
"-146C53DB77BB01e646";
7594 str >> CXSC_Ep2r[8];
7595 str =
"-1EEC161C3EBBD7e60D";
7596 str >> CXSC_Ep2r[9];
7597 str =
"-12D084DC157ACEe5D6";
7598 str >> CXSC_Ep2r[10];
7599 str =
"+12A61F46883347e5A0";
7600 str >> CXSC_Ep2r[11];
7601 str =
"+1993BAF10CAE0Be565";
7602 str >> CXSC_Ep2r[12];
7603 str =
"+1F9224351178FFe52F";
7604 str >> CXSC_Ep2r[13];
7605 str =
"-1C366D1C7BA64Ae4F8";
7606 str >> CXSC_Ep2r[14];
7607 str =
"-17D9938EFA4657e4C1";
7608 str >> CXSC_Ep2r[15];
7609 str =
"+1B6668DF0C1286e48B";
7610 str >> CXSC_Ep2r[16];
7611 str =
"+1F7A4FFC9B48C6e451";
7612 str >> CXSC_Ep2r[17];
7613 str =
"+1F3E3AF6F17591e41B";
7614 str >> CXSC_Ep2r[18];
7615 str =
"+1B1E0C69EE87BEe3E4";
7616 str >> CXSC_Ep2r[19];
7617 str =
"+12DF95CABED5A7e3AD";
7618 str >> CXSC_Ep2r[20];
7619 str =
"+1665EF8CBE7C05e377";
7620 str >> CXSC_Ep2r[21];
7621 str =
"-1B3C417ABEAD6Be340";
7622 str >> CXSC_Ep2r[22];
7623 str =
"-1A19C35B2B0C58e30A";
7624 str >> CXSC_Ep2r[23];
7625 str =
"+18607193ADB301e2D2";
7626 str >> CXSC_Ep2r[24];
7627 str =
"-1BB2016A08F428e298";
7628 str >> CXSC_Ep2r[25];
7629 str =
"+1154B5B7FEDB3Ee262";
7630 str >> CXSC_Ep2r[26];
7631 str =
"-13AE5C2DBEA451e22C";
7632 str >> CXSC_Ep2r[27];
7633 str =
"-10F60BC60CDBFCe1F6";
7634 str >> CXSC_Ep2r[28];
7635 str =
"+1F540F667B3746e1BE";
7636 str >> CXSC_Ep2r[29];
7637 str =
"-1B205D40167EC7e187";
7638 str >> CXSC_Ep2r[30];
7639 str =
"+1C8A0A08DE85F9e151";
7640 str >> CXSC_Ep2r[31];
7641 str =
"+1856ED169F0183e11B";
7642 str >> CXSC_Ep2r[32];
7643 str =
"-147D787794462Ce0E4";
7644 str >> CXSC_Ep2r[33];
7645 str =
"+1516AB11B003F3e0AB";
7646 str >> CXSC_Ep2r[34];
7647 str =
"-1D652A20732EA1e075";
7648 str >> CXSC_Ep2r[35];
7649 str =
"-12EB9F673FF3EDe03F";
7650 str >> CXSC_Ep2r[36];
7651 str =
"+1A5FE9239C5237e008";
7652 str >> CXSC_Ep2r[37];
7653 str =
"-1000000000002Ce000";
7654 str >> CXSC_Ep2r[38];
7655 str =
"-1000000000002Be000";
7656 str >> CXSC_Ep2r[39];
7658 CXSC_Ep2r_initialized =
true;
7659 std::cout << RestoreOpt;
7664 for (
int i=0; i<=stagmax; i++)
7665 y[i+1] = CXSC_Ep2r[i];
7667 stagprec = stagsave;
7670 return lx_interval(-1025,y);
7675 static real CXSC_Ep2Pi[40];
7676 static bool CXSC_Ep2Pi_initialized =
false;
7682 int stagsave = stagprec,
7684 if (!CXSC_Ep2Pi_initialized)
7687 std::cout << SaveOpt;
7689 str =
"+10BBEEE9177E19e7FD";
7690 str >> CXSC_Ep2Pi[0];
7691 str =
"+1C7DD9272526B1e7C5";
7692 str >> CXSC_Ep2Pi[1];
7693 str =
"+15200F57AB89EDe78F";
7694 str >> CXSC_Ep2Pi[2];
7695 str =
"-1FCCB6EDBE9C36e758";
7696 str >> CXSC_Ep2Pi[3];
7697 str =
"+1BEA0BF179A589e722";
7698 str >> CXSC_Ep2Pi[4];
7699 str =
"-1F3AD5A6B77F9Ee6EC";
7700 str >> CXSC_Ep2Pi[5];
7701 str =
"-1622F702B57637e6B5";
7702 str >> CXSC_Ep2Pi[6];
7703 str =
"-100C09AE818734e67C";
7704 str >> CXSC_Ep2Pi[7];
7705 str =
"+10DA7ADA79EFE6e642";
7706 str >> CXSC_Ep2Pi[8];
7707 str =
"+1FF9BF48B72959e60B";
7708 str >> CXSC_Ep2Pi[9];
7709 str =
"-17AD7A3F6D2A14e5D5";
7710 str >> CXSC_Ep2Pi[10];
7711 str =
"+1FCD4B0FA971E4e59E";
7712 str >> CXSC_Ep2Pi[11];
7713 str =
"+193A2CDC04526Be567";
7714 str >> CXSC_Ep2Pi[12];
7715 str =
"-18CBE5FDFAF25Fe531";
7716 str >> CXSC_Ep2Pi[13];
7717 str =
"+1D47EEE171DA93e4FA";
7718 str >> CXSC_Ep2Pi[14];
7719 str =
"-15B0F8DA29DB32e4C4";
7720 str >> CXSC_Ep2Pi[15];
7721 str =
"-19207AD7E637D8e48C";
7722 str >> CXSC_Ep2Pi[16];
7723 str =
"+191CA743F265A6e456";
7724 str >> CXSC_Ep2Pi[17];
7725 str =
"+1A15069182EF28e41F";
7726 str >> CXSC_Ep2Pi[18];
7727 str =
"-1D58BF80B501B6e3E9";
7728 str >> CXSC_Ep2Pi[19];
7729 str =
"+1435920A849065e3B3";
7730 str >> CXSC_Ep2Pi[20];
7731 str =
"-11931903C826FBe37C";
7732 str >> CXSC_Ep2Pi[21];
7733 str =
"+169B0688CF564Ee346";
7734 str >> CXSC_Ep2Pi[22];
7735 str =
"-12539A43ACDD10e309";
7736 str >> CXSC_Ep2Pi[23];
7737 str =
"+172B8963B0CE58e2D3";
7738 str >> CXSC_Ep2Pi[24];
7739 str =
"-13E6A7B1E3A306e29D";
7740 str >> CXSC_Ep2Pi[25];
7741 str =
"-17F20768EDB9E7e267";
7742 str >> CXSC_Ep2Pi[26];
7743 str =
"+130F006E28050Fe22F";
7744 str >> CXSC_Ep2Pi[27];
7745 str =
"+149C245E1C5FEFe1F9";
7746 str >> CXSC_Ep2Pi[28];
7747 str =
"-102CDEE5CA2F95e1C2";
7748 str >> CXSC_Ep2Pi[29];
7749 str =
"+1040AABBBB0BFBe18B";
7750 str >> CXSC_Ep2Pi[30];
7751 str =
"+18D7DB731409F2e154";
7752 str >> CXSC_Ep2Pi[31];
7753 str =
"-1868ADF8479A20e11A";
7754 str >> CXSC_Ep2Pi[32];
7755 str =
"+1BCB4CE8F6AF6Ae0E2";
7756 str >> CXSC_Ep2Pi[33];
7757 str =
"-1A6BA8B081A793e0AC";
7758 str >> CXSC_Ep2Pi[34];
7759 str =
"-1DE2841143A816e075";
7760 str >> CXSC_Ep2Pi[35];
7761 str =
"+1CB5B248339C0Ee03F";
7762 str >> CXSC_Ep2Pi[36];
7763 str =
"-1B1B84E7980944e007";
7764 str >> CXSC_Ep2Pi[37];
7765 str =
"-10000000000003e000";
7766 str >> CXSC_Ep2Pi[38];
7767 str =
"-10000000000002e000";
7768 str >> CXSC_Ep2Pi[39];
7770 CXSC_Ep2Pi_initialized =
true;
7771 std::cout << RestoreOpt;
7776 for (
int i=0; i<=stagmax; i++)
7777 y[i+1] = CXSC_Ep2Pi[i];
7779 stagprec = stagsave;
7782 return lx_interval(-1013,y);
7787 static real CXSC_EpPid2[40];
7788 static bool CXSC_EpPid2_initialized =
false;
7794 int stagsave = stagprec,
7796 if (!CXSC_EpPid2_initialized)
7799 std::cout << SaveOpt;
7801 str =
"+133DEDC855935Fe7FD";
7802 str >> CXSC_EpPid2[0];
7803 str =
"+13E45A768FB73Ce7C7";
7804 str >> CXSC_EpPid2[1];
7805 str =
"-1FB31CF300FF3Ce791";
7806 str >> CXSC_EpPid2[2];
7807 str =
"-1E80D8BEB83F79e75B";
7808 str >> CXSC_EpPid2[3];
7809 str =
"-14A3DE039142DDe722";
7810 str >> CXSC_EpPid2[4];
7811 str =
"-18792D7A37282Be6E7";
7812 str >> CXSC_EpPid2[5];
7813 str =
"-19DF43A5980C28e6B1";
7814 str >> CXSC_EpPid2[6];
7815 str =
"-1C6F0F641C0D67e67B";
7816 str >> CXSC_EpPid2[7];
7817 str =
"-1779C86C2DB5ACe645";
7818 str >> CXSC_EpPid2[8];
7819 str =
"+168521EE91B16Fe60D";
7820 str >> CXSC_EpPid2[9];
7821 str =
"+12530F905D97BDe5D7";
7822 str >> CXSC_EpPid2[10];
7823 str =
"+13498112CB7585e5A1";
7824 str >> CXSC_EpPid2[11];
7825 str =
"+1BA4546B13A434e56B";
7826 str >> CXSC_EpPid2[12];
7827 str =
"+14FF791C56421Ce534";
7828 str >> CXSC_EpPid2[13];
7829 str =
"-1F375C223A2152e4FE";
7830 str >> CXSC_EpPid2[14];
7831 str =
"-126AB0C8C77412e4C8";
7832 str >> CXSC_EpPid2[15];
7833 str =
"-1B39C9C0B8C54Ae490";
7834 str >> CXSC_EpPid2[16];
7835 str =
"-167741414E31E3e459";
7836 str >> CXSC_EpPid2[17];
7837 str =
"+1DEFB4462546C1e421";
7838 str >> CXSC_EpPid2[18];
7839 str =
"-10F7B89CC30514e3E9";
7840 str >> CXSC_EpPid2[19];
7841 str =
"+1E87D3145A3CEEe3B3";
7842 str >> CXSC_EpPid2[20];
7843 str =
"+18AA09D5CD3B7Be37D";
7844 str >> CXSC_EpPid2[21];
7845 str =
"+1E738C390E548Be347";
7846 str >> CXSC_EpPid2[22];
7847 str =
"+147542CC36F28Be30E";
7848 str >> CXSC_EpPid2[23];
7849 str =
"+1B217FFE679632e2D8";
7850 str >> CXSC_EpPid2[24];
7851 str =
"+1A8F3962771086e2A0";
7852 str >> CXSC_EpPid2[25];
7853 str =
"-187231F1E3EFC2e26A";
7854 str >> CXSC_EpPid2[26];
7855 str =
"-15010B009CF001e233";
7856 str >> CXSC_EpPid2[27];
7857 str =
"-1F22E68271119Fe1FB";
7858 str >> CXSC_EpPid2[28];
7859 str =
"+11CA8D2164A3BAe1C5";
7860 str >> CXSC_EpPid2[29];
7861 str =
"+1C20B237A324D7e18F";
7862 str >> CXSC_EpPid2[30];
7863 str =
"-18C70E40461930e157";
7864 str >> CXSC_EpPid2[31];
7865 str =
"+1025F32E109A37e120";
7866 str >> CXSC_EpPid2[32];
7867 str =
"-12087D5EA8F469e0EA";
7868 str >> CXSC_EpPid2[33];
7869 str =
"-14E1EE796B734Ae0B4";
7870 str >> CXSC_EpPid2[34];
7871 str =
"-176EBB3BB1E41Ce07E";
7872 str >> CXSC_EpPid2[35];
7873 str =
"+1374F617B0FF49e048";
7874 str >> CXSC_EpPid2[36];
7875 str =
"+1D28C408575ECEe011";
7876 str >> CXSC_EpPid2[37];
7877 str =
"-10000000006878e000";
7878 str >> CXSC_EpPid2[38];
7879 str =
"-10000000006877e000";
7880 str >> CXSC_EpPid2[39];
7882 CXSC_EpPid2_initialized =
true;
7883 std::cout << RestoreOpt;
7888 for (
int i=0; i<=stagmax; i++)
7889 y[i+1] = CXSC_EpPid2[i];
7891 stagprec = stagsave;
7894 return lx_interval(-1020,y);
7899 static real CXSC_EpPid4[40];
7900 static bool CXSC_EpPid4_initialized =
false;
7906 int stagsave = stagprec,
7908 if (!CXSC_EpPid4_initialized)
7911 std::cout << SaveOpt;
7913 str =
"+118BD669471CAAe7FD";
7914 str >> CXSC_EpPid4[0];
7915 str =
"+1F0ED609715756e7C7";
7916 str >> CXSC_EpPid4[1];
7917 str =
"-1B9C7B871FE1DBe791";
7918 str >> CXSC_EpPid4[2];
7919 str =
"+15C0FECE98F209e75A";
7920 str >> CXSC_EpPid4[3];
7921 str =
"+18C9FACC5DF3CEe724";
7922 str >> CXSC_EpPid4[4];
7923 str =
"+15EDE838B4A399e6EC";
7924 str >> CXSC_EpPid4[5];
7925 str =
"-1C7EFACA363051e6B6";
7926 str >> CXSC_EpPid4[6];
7927 str =
"-1A1EBEA1646411e680";
7928 str >> CXSC_EpPid4[7];
7929 str =
"+1AEF54E68CE03Be649";
7930 str >> CXSC_EpPid4[8];
7931 str =
"-11250CB97FDDBFe60F";
7932 str >> CXSC_EpPid4[9];
7933 str =
"-169ADC0E65B8A7e5D8";
7934 str >> CXSC_EpPid4[10];
7935 str =
"+198A501DB90EDDe5A2";
7936 str >> CXSC_EpPid4[11];
7937 str =
"-1586909A3F6365e56B";
7938 str >> CXSC_EpPid4[12];
7939 str =
"+1BE542410F8CE7e535";
7940 str >> CXSC_EpPid4[13];
7941 str =
"+1E7EEC51889EECe4FF";
7942 str >> CXSC_EpPid4[14];
7943 str =
"-1913C9FC19333Ce4C9";
7944 str >> CXSC_EpPid4[15];
7945 str =
"+1112C71EA1E6F0e492";
7946 str >> CXSC_EpPid4[16];
7947 str =
"-1C4CCF0F5D1E14e45B";
7948 str >> CXSC_EpPid4[17];
7949 str =
"+1AC4A72310FA27e425";
7950 str >> CXSC_EpPid4[18];
7951 str =
"-13EC6A07AD7C15e3EE";
7952 str >> CXSC_EpPid4[19];
7953 str =
"+1114CC16D255A3e3B6";
7954 str >> CXSC_EpPid4[20];
7955 str =
"+17FA54DD584C6Ee380";
7956 str >> CXSC_EpPid4[21];
7957 str =
"-1BBFE0D94FA881e34A";
7958 str >> CXSC_EpPid4[22];
7959 str =
"-1AACE950D75AB5e314";
7960 str >> CXSC_EpPid4[23];
7961 str =
"-1C197FC5941652e2DD";
7962 str >> CXSC_EpPid4[24];
7963 str =
"-1FC33183282E6Ee2A7";
7964 str >> CXSC_EpPid4[25];
7965 str =
"+15ADA6B92D282Ee26A";
7966 str >> CXSC_EpPid4[26];
7967 str =
"-10CC6C2A9B1995e233";
7968 str >> CXSC_EpPid4[27];
7969 str =
"+1767402CD3F07Be1FC";
7970 str >> CXSC_EpPid4[28];
7971 str =
"-134D3B2AED1AACe1C5";
7972 str >> CXSC_EpPid4[29];
7973 str =
"+1C87E322B76BC8e18D";
7974 str >> CXSC_EpPid4[30];
7975 str =
"+1CBF921AE01812e157";
7976 str >> CXSC_EpPid4[31];
7977 str =
"+16B04C1CCCDEAEe11D";
7978 str >> CXSC_EpPid4[32];
7979 str =
"+11D2A5DAE175A6e0E5";
7980 str >> CXSC_EpPid4[33];
7981 str =
"-1D6F0482D56D0Ee0AF";
7982 str >> CXSC_EpPid4[34];
7983 str =
"-1E1B89C6DE0660e079";
7984 str >> CXSC_EpPid4[35];
7985 str =
"-1202BA3792C129e042";
7986 str >> CXSC_EpPid4[36];
7987 str =
"+1B23FE2BAFDF56e00A";
7988 str >> CXSC_EpPid4[37];
7989 str =
"-100000000000DEe000";
7990 str >> CXSC_EpPid4[38];
7991 str =
"-100000000000DDe000";
7992 str >> CXSC_EpPid4[39];
7994 CXSC_EpPid4_initialized =
true;
7995 std::cout << RestoreOpt;
8000 for (
int i=0; i<=stagmax; i++)
8001 y[i+1] = CXSC_EpPid4[i];
8003 stagprec = stagsave;
8006 return lx_interval(-1021,y);
8093 lx_real
sqrt(
const lx_real& x)
noexcept
8094 {
return mid(
sqrt(lx_interval(x))); }
8095 lx_real
sqr(
const lx_real& x)
noexcept
8096 {
return mid(
sqr(lx_interval(x))); }
8097 lx_real
ln(
const lx_real& x)
noexcept
8098 {
return mid(
ln(lx_interval(x))); }
8099 lx_real
log2(
const lx_real& x)
noexcept
8100 {
return mid(
log2(lx_interval(x))); }
8101 lx_real
log10(
const lx_real& x)
noexcept
8102 {
return mid(
log10(lx_interval(x))); }
8103 lx_real
lnp1(
const lx_real& x)
noexcept
8104 {
return mid(
lnp1(lx_interval(x))); }
8105 lx_real
exp(
const lx_real& x)
noexcept
8106 {
return mid(
exp(lx_interval(x))); }
8107 lx_real
exp2(
const lx_real& x)
noexcept
8108 {
return mid(
exp2(lx_interval(x))); }
8109 lx_real
exp10(
const lx_real& x)
noexcept
8110 {
return mid(
exp10(lx_interval(x))); }
8111 lx_real
expm1(
const lx_real& x)
noexcept
8112 {
return mid(
expm1(lx_interval(x))); }
8114 {
return mid(
power(lx_interval(x),r)); }
8115 lx_real
pow(
const lx_real& x,
const lx_real& y)
noexcept
8116 {
return mid(
pow(lx_interval(x),lx_interval(y))); }
8117 lx_real
xp1_pow_y(
const lx_real& x,
const lx_real& y)
noexcept
8118 {
return mid(
xp1_pow_y(lx_interval(x),lx_interval(y))); }
8119 lx_real
sin(
const lx_real& x)
noexcept
8120 {
return mid(
sin(lx_interval(x))); }
8122 {
return mid(
sin_n(lx_interval(x),n)); }
8123 lx_real
cos(
const lx_real& x)
noexcept
8124 {
return mid(
cos(lx_interval(x))); }
8126 {
return mid(
cos_n(lx_interval(x),n)); }
8127 lx_real
tan(
const lx_real& x)
noexcept
8128 {
return mid(
tan(lx_interval(x))); }
8129 lx_real
cot(
const lx_real& x)
noexcept
8130 {
return mid(
cot(lx_interval(x))); }
8133 lx_real
atan(
const lx_real& x)
noexcept
8134 {
return mid(
atan(lx_interval(x))); }
8139 lx_real
asin(
const lx_real& x)
noexcept
8140 {
return mid(
asin(lx_interval(x))); }
8141 lx_real
acos(
const lx_real& x)
noexcept
8142 {
return mid(
acos(lx_interval(x))); }
8143 lx_real
acot(
const lx_real& x)
noexcept
8144 {
return mid(
acot(lx_interval(x))); }
8145 lx_real
sinh(
const lx_real& x)
noexcept
8146 {
return mid(
sinh(lx_interval(x))); }
8147 lx_real
cosh(
const lx_real& x)
noexcept
8148 {
return mid(
cosh(lx_interval(x))); }
8149 lx_real
tanh(
const lx_real& x)
noexcept
8150 {
return mid(
tanh(lx_interval(x))); }
8151 lx_real
coth(
const lx_real& x)
noexcept
8152 {
return mid(
coth(lx_interval(x))); }
8155 lx_real
asinh(
const lx_real& x)
noexcept
8156 {
return mid(
asinh(lx_interval(x))); }
8157 lx_real
acosh(
const lx_real& x)
noexcept
8158 {
return mid(
acosh(lx_interval(x))); }
8161 lx_real
atanh(
const lx_real& x)
noexcept
8162 {
return mid(
atanh(lx_interval(x))); }
8167 lx_real
acoth(
const lx_real& x)
noexcept
8168 {
return mid(
acoth(lx_interval(x))); }
8173 lx_real
sqrtx2y2(
const lx_real& x,
const lx_real& y)
noexcept
8174 {
return mid(
sqrtx2y2(lx_interval(x),lx_interval(y))); }
8177 lx_real
sqrt(
const lx_real& x,
int n)
noexcept
8178 {
return mid(
sqrt(lx_interval(x),n)); }
The Scalar Type interval.
interval & operator=(const real &a)
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_interval.
The Multiple-Precision Data Type l_real.
The namespace cxsc, providing all functionality of the class library C-XSC.
lx_interval Sqrt2Pi_lx_interval() noexcept
Enclosure-Interval for .
l_interval wide_max(void)
Returns a wide interval with maximum exponent 1020.
lx_interval Er_lx_interval() noexcept
Enclosure-Interval for .
cinterval sqrtp1m1(const cinterval &z) noexcept
Calculates .
lx_interval Catalan_lx_interval() noexcept
Enclosure-Interval for .
cinterval exp2(const cinterval &z) noexcept
Calculates .
cinterval sqrt1mx2(const cinterval &z) noexcept
Calculates .
lx_real LnPi_lx_real() noexcept
lx_real approximation for
const real MinReal
Smallest normalized representable floating-point number.
cinterval asinh(const cinterval &z) noexcept
Calculates .
lx_interval SqrtPi_lx_interval() noexcept
Enclosure-Interval for .
l_interval point_max(void)
Returns a point interval with maximum exponent 1020.
lx_real One_m_lx_real() noexcept
lx_real approximation for
lx_real Er_lx_real() noexcept
lx_real approximation for
cinterval coth(const cinterval &z) noexcept
Calculates .
lx_real Sqrt3r_lx_real() noexcept
lx_real approximation for
lx_real SqrtPir_lx_real() noexcept
lx_real approximation for
l_interval Pi2_l_interval() noexcept
Enclosure-Interval for .
lx_interval expo2zero(const lx_interval &a)
b = expo2zero(a) returns with
lx_real E_lx_real() noexcept
lx_real approximation for
cinterval log2(const cinterval &z) noexcept
Calculates .
lx_real EulerGamma_lx_real() noexcept
lx_real approximation for
lx_interval Sqrt2r_lx_interval() noexcept
Enclosure-Interval for .
cinterval power(const cinterval &z, int n) noexcept
Calculates .
cinterval log10(const cinterval &z) noexcept
Calculates .
lx_interval Ln10r_lx_interval() noexcept
Enclosure-Interval for .
const real MaxReal
Greatest representable floating-point number.
lx_interval EpPid4_lx_interval() noexcept
Enclosure-Interval for .
lx_real Ln2r_lx_real() noexcept
lx_real approximation for
lx_interval cos_n(const lx_interval &x, const real &n) noexcept
Calculates .
lx_interval Pir_lx_interval() noexcept
Enclosure-Interval for .
lx_real sqrt5_lx_real() noexcept
lx_real approximation for
cinterval ln(const cinterval &z) noexcept
Calculates .
lx_real One_p_lx_real() noexcept
lx_real approximation for
lx_interval E_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Pi2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval acothp1(const lx_interval &x) noexcept
Calculates .
lx_interval Sqrt2_lx_interval() noexcept
Enclosure-Interval for .
bool Is_Integer(const real &x)
Returns 1 if x is an integer value and if .
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
int expo_gr(const l_interval &x)
lx_interval Sqrt3_lx_interval() noexcept
Enclosure-Interval for .
lx_real Sqrt3d2_lx_real() noexcept
lx_real approximation for
lx_interval Ln2_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Sqrt2Pir_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Pid4_lx_interval() noexcept
Enclosure-Interval for .
lx_interval sqrt7_lx_interval() noexcept
Enclosure-Interval for .
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
lx_interval LnPi_lx_interval() noexcept
Enclosure-Interval for .
const real minreal
Smallest positive denormalized representable floating-point number.
lx_interval Ln2Pi_lx_interval() noexcept
Enclosure-Interval for .
lx_real EpPid2_lx_real() noexcept
lx_real approximation for
lx_real Sqrt2Pir_lx_real() noexcept
lx_real approximation for
cinterval pow(const cinterval &z, const interval &p) noexcept
Calculates .
lx_real EpPi_lx_real() noexcept
lx_real approximation for
lx_interval EpPi_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Sqrt3d2_lx_interval() noexcept
Enclosure-Interval for .
lx_real upper_bnd(const lx_real &x) noexcept
Returns a rather small upper bound of x.
lx_interval Ln10_lx_interval() noexcept
Enclosure-Interval for .
lx_interval EpPid2_lx_interval() noexcept
Enclosure-Interval for .
cinterval sinh(const cinterval &z) noexcept
Calculates .
lx_interval atanh1m(const lx_interval &x) noexcept
Calculates .
lx_real Pi2_lx_real() noexcept
lx_real approximation for
cinterval asin(const cinterval &z) noexcept
Calculates .
interval acoshp1(const interval &x)
Calculates .
lx_real Pi2r_lx_real() noexcept
lx_real approximation for
cinterval tan(const cinterval &z) noexcept
Calculates .
lx_real Ln2_lx_real() noexcept
lx_real approximation for
lx_interval sqrt5_lx_interval() noexcept
Enclosure-Interval for .
cinterval exp10(const cinterval &z) noexcept
Calculates .
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
lx_real Sqrt2Pi_lx_real() noexcept
lx_real approximation for
lx_interval Sqrt3r_lx_interval() noexcept
Enclosure-Interval for .
lx_real Pir_lx_real() noexcept
lx_real approximation for
lx_real Pid2_lx_real() noexcept
lx_real approximation for
lx_real Pid3_lx_real() noexcept
lx_real approximation for
lx_real Pid4_lx_real() noexcept
lx_real approximation for
lx_real Ln10r_lx_real() noexcept
lx_real approximation for
cinterval acos(const cinterval &z) noexcept
Calculates .
cinterval sqrtx2m1(const cinterval &z) noexcept
Calculates .
cinterval acosh(const cinterval &z) noexcept
Calculates .
lx_real Ln10_lx_real() noexcept
lx_real approximation for
lx_interval sin_n(const lx_interval &x, const real &n) noexcept
Calculates .
l_interval wide_any(int n)
Returns a wide interval with exponent n, .
lx_interval Ep2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval SqrtPir_lx_interval() noexcept
Enclosure-Interval for .
cinterval cosh(const cinterval &z) noexcept
Calculates .
lx_real Sqrt2r_lx_real() noexcept
lx_real approximation for
cinterval cos(const cinterval &z) noexcept
Calculates .
real add_real(const real &a, const real &b) noexcept
Returns a,b must be integers with .
lx_interval Ln2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Ep2_lx_interval() noexcept
Enclosure-Interval for .
lx_interval One_p_lx_interval() noexcept
Enclosure-Interval for .
lx_real Catalan_lx_real() noexcept
lx_real approximation for
lx_real Sqrt2_lx_real() noexcept
lx_real approximation for
lx_real Ep2_lx_real() noexcept
lx_real approximation for
cinterval sqrt1px2(const cinterval &z) noexcept
Calculates .
lx_real lower_bnd(const lx_real &x) noexcept
Returns a rather great lower bound of x.
cinterval exp(const cinterval &z) noexcept
Calculates .
lx_real Ep2Pi_lx_real() noexcept
lx_real approximation for
real sub_real(const real &a, const real &b) noexcept
Returns a,b must be integers with .
lx_interval Pi_lx_interval() noexcept
Enclosure-Interval for .
cinterval tanh(const cinterval &z) noexcept
Calculates .
interval ln_sqrtx2y2(const interval &x, const interval &y) noexcept
Calculates .
const real Pi2_real
Constant for rounded to the nearest machine number.
lx_interval Pid2_lx_interval() noexcept
Enclosure-Interval for .
lx_real Pip2_lx_real() noexcept
lx_real approximation for
cinterval expm1(const cinterval &z) noexcept
Calculates .
cinterval cot(const cinterval &z) noexcept
Calculates .
lx_interval Ep2Pi_lx_interval() noexcept
Enclosure-Interval for .
lx_real SqrtPi_lx_real() noexcept
lx_real approximation for
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
cinterval sqrt(const cinterval &z) noexcept
Calculates .
cinterval acot(const cinterval &z) noexcept
Calculates .
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
lx_interval Pid3_lx_interval() noexcept
Enclosure-Interval for .
cinterval sqr(const cinterval &z) noexcept
Calculates .
lx_interval atanhm1p(const lx_interval &x) noexcept
Calculates .
lx_real EpPid4_lx_real() noexcept
lx_real approximation for
cinterval lnp1(const cinterval &z) noexcept
Calculates .
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
cinterval atan(const cinterval &z) noexcept
Calculates .
cinterval atanh(const cinterval &z) noexcept
Calculates .
lx_interval acothm1m(const lx_interval &x) noexcept
Calculates .
l_interval point_any(int n)
Returns a point interval with exponent n.
lx_real Sqrt3_lx_real() noexcept
lx_real approximation for
cinterval acoth(const cinterval &z) noexcept
Calculates .
lx_interval Pi2_lx_interval() noexcept
Enclosure-Interval for .
interval sqrtx2y2(const interval &x, const interval &y) noexcept
Calculates .
lx_real Pi_lx_real() noexcept
lx_real approximation for
lx_interval One_m_lx_interval() noexcept
Enclosure-Interval for .
lx_real Ln2Pi_lx_real() noexcept
lx_real approximation for
int expo_sm(const l_interval &x)
lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y) noexcept
Calculates .
lx_interval Pip2_lx_interval() noexcept
Enclosure-Interval for .
cinterval sin(const cinterval &z) noexcept
Calculates .
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
lx_real Ep2r_lx_real() noexcept
lx_real approximation for
real AbsMin(const interval &x)
Computes the smallest absolute value .
lx_interval EulerGamma_lx_interval() noexcept
Enclosure-Interval for .
lx_real sqrt7_lx_real() noexcept
lx_real approximation for