C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
lx_interval.cpp
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: lx_interval.cpp,v 1.13 2014/01/30 17:23:47 cxsc Exp $ */
25 
26 
27 /*
28 ** F. Blomquist, University of Wuppertal, 19.09.2007;
29 */
30 
31 #include "lx_interval.hpp"
32 
33 //class lx_real;
34 
35 namespace cxsc {
36 
37 // ----------------------------------------------------------------------
38 // ------------ Functions related to type lx_interval: ------------------
39 // ----------------------------------------------------------------------
40 
41 lx_interval::lx_interval(const real& n, const string &s) throw()
42 // Constructor:
43 // (10^n, string) --- > (ex,li) vom Typ lx_interval
44 // string s must be of the form:
45 // s = "[1.234567,1.234567]"; or: s = "[0,0]";
46 // or: s = "[1.234567e+20,1.234568e+20]";
47 // or: s = "[1.234567e-20,1.234568e-20]";
48 // or: s = "[0,1]"; or: s = "[-1,0]"; or: s = "[-1,+1]";
49 // (ex,li) is an optimal inclusion of 10^n*s;
50 
51 // Not allowed strings:
52 // s = "1.234567"; or: s = "1.234567e+20";
53 // or: s = "[1.2,1.2"; or: s = "1.2,1.2]";
54 // or: s = "+[1.2,1.2]"; or: s = "-[1.2,1.2]";
55 
56 {
57  const real c1 = 3.3219280948873623; // c1 = ln(10)/ln(2)
58  const real c2 = 2.711437152598000E+015;
59  const real c3 = 10000.0;
60  l_interval x(0);
61  lx_interval u,v;
62  real y,ay,r;
63  int p,q,stagsave;
64  bool neg;
65 
66  stagsave = stagprec;
67 
68  if (!Is_Integer(n))
69  cxscthrow(REAL_NOT_ALLOWED(
70  "lx_interval(const real&, const string& )"));
71  // Check for brackets [...] in string s:
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;
79  x = x + 0; // To get StagPrec(x) = actual value of stagprec;
80  s >> x; // [a,b] <= x; x of type l_interval;
81 
82  if (x==0)
83  {
84  li = 0; ex = 0;
85  }
86  else
87  {
88  neg = (n<0);
89  y = n*c1;
90  y = std::floor(_double(y));
91  ay = abs(y); r = abs(n);
92  if (ay>=Max_Int_R)
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));
97  if (r > c2)
98  {
99  v = lx_interval(ay-c3,l_interval(1));
100  times2pown(u,-c3);
101  }
102  if (neg) u = v/u;
103  else u = u/v;
104  u = u*lx_interval(0,x);
105  li = li_part(u);
106  r = expo(u);
107  ex = add_real(y,r);
108  }
109  stagprec = stagsave;
110  li = adjust(li);
111 }
112 
113 void scale_down(lx_interval &a)
114 // scale_down skaliert a moeglichst weit nach unten, ohne
115 // dass dabei binaere Stellen verloren gehen.
116 // Der mathematische Wert von a bleibt dabei erhalten, d.h.
117 // 2^(a.ex)*a.li hat vor und nach der Skalierung stets den
118 // gleichen mathematischen Wert.
119 {
120  int d;
121  d = -1021 - expo_sm(a.li);
122  // In case of a.li=0 we get d>0, and so nothing is done!
123  if (d<0)
124  {
125  Times2pown(a.li,d); // a.li = a.li * 2^d
126  a.ex = sub_real(a.ex,d);
127  }
128 }
129 
130 void scale_up(lx_interval &a)
131 // scale_up skaliert a.li moeglichst weit nach oben.
132 // Nach der Skalierung wird jedoch a.li + a.li keinen Overflow
133 // erzeugen.
134 // 2^(a.ex)*a.li hat fuer d>0 vor und nach der Skalierung stets
135 // den gleichen Wert. Nur im Fall d<0 kann es durch die
136 // Skalierung nach unten nur zu einer minimalen Aufblaehung kommen,
137 // denn im Fall d<0 nimmt d nur die Werte d = -1,-2 an.
138 {
139  int d;
140  d = 1022 - expo_gr(a.li);
141  if (d>-4) // if (d>-3) is also possible!
142  {
143  Times2pown(a.li,d); // a.li = a.li * 2^d
144  a.ex = sub_real(a.ex,d); // to keep 2^(a.ex)*a.li constant.
145  }
146 }
147 
148 l_interval & l_interval::operator = (const lx_interval &a) throw()
149 {
150  int exa;
151  real p(expo(a)),exr;
152  l_interval al(li_part(a));
153  l_real lrI(Inf(al)), lrS(Sup(al)); // Neu !!!!!
154  exa = expo_gr(al);
155  if (exa<-100000) return (*this) = al; // al = 0;
156  exr = p + exa;
157  if (exr > 1024)
158  cxscthrow(OVERFLOW_ERROR("LX_INTERVAL_UNREALIZABLE_AS_L_INTERVAL: l_interval & operator = (const lx_interval &a)"));
159  Times2pown(al,p);
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));
164  return (*this) = al;
165 }
166 
167 interval & interval::operator = (const lx_interval &a) throw()
168 {
169  l_interval al;
170  interval z;
171  al = a;
172  z = al;
173  return (*this) = z;
174 }
175 
176 l_interval times2powr(const l_real &a, const real &r)
177 // b = times2powr(a,r); returns an inclusion of a*2^r <= b;
178 // This inclusion holds only, if the following condition is
179 // fulfilled:
180 // **************************************************************
181 // * For r in [-2100,+2100] r must be an integer value; *
182 // **************************************************************
183 // The above condition is NOT tested in this function !!
184 // If r lies outside [-2100,+2100] then it holds a*2^r <= b for
185 // any real number, unless an overflow occurs.
186 // The function is for the internal use only!
187 // Blomquist, 25.02,2008;
188 {
189  l_interval res(0),ai;
190  double dbl;
191  int ex;
192 
193  if ( a != 0 )
194  {
195  ai = l_interval(a);
196 
197  if (abs(r)<2147483647)
198  {
199  dbl = _double(r);
200  ex = (int) dbl;
201  Times2pown(ai,ex);
202  res = ai;
203  }
204  else
205  if (r < -2147483645)
206  {
207  Times2pown(ai,-3000);
208  res = ai;
209  }
210  else
211  Times2pown(ai,3000); // produces overflow!
212  }
213  return res;
214 }
215 
216 lx_interval expo2zero(const lx_interval &a) throw(OVERFLOW_ERROR)
217 // The exponent to base 2 of the object a is set to zero.
218 // The return value res is an inclusion of the object a
219 // unless an overflow occurs.
220 {
221  lx_interval res(0);
222  l_interval la(li_part(a));
223  int exa(expo_gr(la));
224  real na(expo(a)), r;
225 
226  if (exa > -100000) // a != 0;
227  {
228  r = add_real(exa,na);
229  if (r > 1024)
230  cxscthrow(OVERFLOW_ERROR(
231  "lx_interval expo2zero(lx_interval &)"));
232  Times2pown(la,na);
233  res = lx_interval(0.0,la);
234  }
235 
236  return res;
237 }
238 
239 lx_interval::lx_interval(const lx_real& a, const lx_real& b) throw()
240 {
241  lx_real a_(a),b_(b);
242  l_real lr;
243  l_interval h;
244  bool a_zero(eq_zero(a)), b_zero(eq_zero(b));
245  real na,nb,d;
246  if (a_zero || b_zero)
247  if (a_zero)
248  {
249  ex = expo(b);
250  li = l_interval(0,lr_part(b));
251  } else
252  {
253  ex = expo(a);
254  li = l_interval(lr_part(a),0);
255  }
256  else
257  { // Now we have: a,b != 0:
258  scale_up(a_);
259  scale_up(b_);
260  na = expo(a_); nb = expo(b_);
261  if (na >= nb)
262  {
263  if (na==nb) // the most common case!
264  {
265  ex = na;
266  li = l_interval(lr_part(a_),lr_part(b_));
267  }
268  else // na > nb:
269  {
270  d = na - nb;
271  if (d>Max_Int_R)
272  d = Max_Int_R;
273  ex = na;
274  lr = lr_part(b_);
275  h = times2powr(lr,-d);
276  li = l_interval(lr_part(a_),Sup(h));
277  }
278  }
279  else // na < nb:
280  {
281  d = nb - na;
282  if (d>Max_Int_R)
283  d = Max_Int_R;
284  ex = nb;
285  lr = lr_part(a_);
286  h = times2powr(lr,-d);
287  li = l_interval(Inf(h),lr_part(b_));
288  }
289  }
290 }
291 
292 lx_interval operator + (const lx_interval &a, const lx_interval &b) throw()
293 {
294  const real c1 = 10000.0;
295  int stagsave = stagprec,
296  stagmax = 39,
297  exa,exb;
298  real sa,sb,p,n;
299 
300  if (stagprec>stagmax) stagprec = stagmax;
301 
302  l_interval a1,b1;
303  lx_interval res,A(a),B(b);
304  interval z;
305 
306  A = Blow(A); // If |a| is too small, a is inflated.
307  B = Blow(B); // A <= Blow(A) is guaranteed!
308  // With these inflations a+b <= A+B is guaranteed and
309  // A+B is calculated without an error message unless
310  // |A| or |B| are too great.
311  a1 = li_part(A); b1 = li_part(B);
312  exa = expo_gr(a1);
313  exb = expo_gr(b1);
314 
315  if (exa<-100000) return b; // summand a = 0
316  if (exb<-100000) return a; // summand b = 0
317 
318  // a,b <> 0:
319  sa = add_real(exa,expo(A));
320  sb = add_real(exb,expo(B));
321  if (sa > sb) // |a| >= |b|
322  {
323  p = 1022 - exa; // p >= 0
324  Times2pown(a1,p);
325  n = sub_real(expo(A),p);
326  if (n>0 && expo(B)<sub_real(n,c1))
327  {
328  z = b1;
329  if (Sup(z)<=0.0)
330  b1 = l_interval(-MinReal,0);
331  else
332  if (Inf(z)>=0.0)
333  b1 = l_interval(0,MinReal);
334  else
335  b1 = l_interval(-MinReal,MinReal);
336  }
337  else
338  {
339  p = sub_real(expo(B),n);
340  Times2pown(b1,p);
341  }
342  } else
343  {
344  p = 1022 - exb; // p >= 0
345  Times2pown(b1,p);
346  n = sub_real(expo(B),p);
347  if (n>0 && expo(A)<sub_real(n,c1))
348  {
349  z = a1;
350  if (Sup(z)<=0.0)
351  a1 = l_interval(-MinReal,0);
352  else
353  if (Inf(z)>=0.0)
354  a1 = l_interval(0,MinReal);
355  else
356  a1 = l_interval(-MinReal,MinReal);
357  }
358  else
359  {
360  p = sub_real(expo(A),n);
361  Times2pown(a1,p);
362  }
363  }
364  a1 = a1 + b1; // normal staggered addition
365  res = lx_interval(n,a1);
366 
367  stagprec = stagsave;
368  res = adjust(res);
369  return res;
370 }
371 
372 lx_interval operator * (const lx_interval &a, const lx_interval &b) throw()
373 {
374  int stagsave = stagprec,
375  stagmax = 39,
376  exa,exb,d,D,k;
377  real na,nb,diff;
378 
379  if (stagprec > stagmax) stagprec = stagmax;
380 
381  l_interval al,bl;
382  lx_interval a_(a),b_(b),res(0);
383 
384  a_ = Blow(a_); // a_ is inflated, if |a_| is too small
385  b_ = Blow(b_); // a_ = [0,0] remains unchanged
386 
387  scale_down(a_); scale_down(b_);
388 
389  al = li_part(a_); bl = li_part(b_);
390  exa = expo_gr(al);
391  exb = expo_gr(bl);
392 
393  if (exa>-100000 && exb>-100000) // Beide Faktoren sind <> 0:
394  {
395  if (exa+exb <= 1022)
396  {
397  if (exa<0)
398  {
399  Times2pown(al,-exa);
400  na = add_real(expo(a_),exa); // a = 2^na * al;
401  d = 1022 - exb;
402  }
403  else // exa >= 0
404  {
405  na = expo(a_);
406  d = 1022 - (exa+exb);
407  }
408  Times2pown(bl,d);
409  nb = sub_real(expo(b_),d); // b = 2^nb * bl;
410  }
411  else // exa+exb > 1022
412  {
413  d = exa + exb - 1022; // d > 0;
414  if (exa>exb)
415  {
416  D = exa - exb; // D > 0;
417  if (d <= D)
418  {
419  Times2pown(al,-d);
420  na = add_real(expo(a_),d); // a = 2^na * al;
421  nb = expo(b_);
422  }
423  else // d > D;
424  {
425  k = d - D;
426  if (k%2 != 0) k++;
427  k = k/2;
428  Times2pown(bl,-k);
429  nb = add_real(expo(b_),k); // b = 2^nb * bl;
430  k = k + D;
431  Times2pown(al,-k);
432  na = add_real(expo(a_),k); // a = 2^na * al;
433  }
434  }
435  else // exb >= exa
436  {
437  D = exb - exa; // D > 0;
438  if (d <= D)
439  {
440  Times2pown(bl,-d);
441  nb = add_real(expo(b_),d); // b = 2^nb * bl;
442  na = expo(a_);
443  }
444  else // d > D
445  {
446  k = d - D;
447  if (k%2 != 0) k++;
448  k = k/2;
449  Times2pown(al,-k);
450  na = add_real(expo(a_),k); // a = 2^na * al;
451  k = k + D;
452  Times2pown(bl,-k);
453  nb = add_real(expo(b_),k); // b = 2^nb * bl;
454  }
455  }
456  }
457  al = al*bl; // normal staggered multiplication
458 
459  if (na+nb<-Max_Int_R) // Underflow:
460  {
461  diff = (Max_Int_R + na) + nb; // diff < 0;
462  Times2pown(al,diff);
463 
464  if (Inf(al)>0)
465  SetInf(al,0.0);
466  else
467  if (Sup(al)<0)
468  SetSup(al,0.0);
469 
470  res = lx_interval(Max_Int_N,al);
471  }
472  else // Without underflow
473  {
474  na = add_real(na,nb); // Hier normale Rechnung!
475  res = lx_interval(na,al);
476  // Caution: This else-block can deliver an interval res,
477  // with a so small |res| value , that for example
478  // res * res produces an error message. To avoide this
479  // message, res will be sufficiently inflated:
480 
481  if (na<Max_Int_N) // Only in extreme cases!
482  {
483  if (Inf(al)>0)
484  SetInf(al,0.0);
485  else
486  if (Sup(al)<0)
487  SetSup(al,0.0);
488 
489  res = lx_interval(Max_Int_N,al);
490  }
491  }
492 
493  }
494  stagprec = stagsave;
495  res = adjust(res);
496  return res;
497 } // operator *
498 
499 lx_interval operator / (const lx_interval &a, const lx_interval &b)
500  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
501 {
502  int stagsave = stagprec,
503  stagmax = 39,
504  exa,exb,d;
505  real na,nb,diff;
506  if (stagprec>stagmax) stagprec = stagmax;
507 
508  interval z;
509  l_interval al,bl;
510  lx_interval a_(a),b_(b),res;
511 
512  a_ = Blow(a_); // a_ is inflated, if |a_| is too small
513  b_ = Blow(b_); // a_ = [0,0] remains unchanged
514 
515  scale_down(a_);
516  scale_down(b_);
517  al = li_part(a_); bl = li_part(b_);
518 
519  exa = expo_gr(al);
520  exb = expo_gr(bl);
521 
522  if (exb < -100000)
523  cxscthrow(ERROR_LINTERVAL_DIV_BY_ZERO("lx_interval operator/(const lx_interval &a, const lx_interval &b)"));
524 
525  if (exa < -100000) return a;
526  // Now it holds: a,b <> 0:
527 
528  bool bl_point( point_intv(bl) );
529 
530  // First: scaling the nominator al to 1022:
531  d = 1022 - exa;
532  Times2pown(al,d); // expo_gr(al) = 1022;
533  na = sub_real(expo(a_),d); // a = 2^na * al;
534 
535  if (bl_point)
536  {
537  if (0<=exb && exb<=511)
538  nb = expo(b_);
539  else
540  if (exb<0)
541  { // scaling the denominator bl to 0:
542  Times2pown(bl,-exb);
543  nb = add_real(expo(b_),exb); // b = 2^nb * bl;
544  }
545  else // exb > 511;
546  // Now scaling the denominator bl to 511:
547  {
548  d = 511 - exb;
549  Times2pown(bl,d);
550  nb = sub_real(expo(b_),d);
551  }
552  }
553  else // scaling the denominator bl to 511:
554  {
555  d = 511 - exb;
556  Times2pown(bl,d);
557  nb = sub_real(expo(b_),d);
558  }
559 
560  z = al;
561  al = al / bl; // Normal staggered division;
562  // However, with too wide interval operands an overflow is possible:
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)"));
565 
566  if (na-nb<-Max_Int_R) // Underflow:
567  {
568  diff = (Max_Int_R - nb) + na; // diff < 0;
569  Times2pown(al,diff);
570 
571  if (Inf(al)>0)
572  SetInf(al,0.0);
573  else
574  if (Sup(al)<0)
575  SetSup(al,0.0);
576 
577  res = lx_interval(Max_Int_N,al);
578  // +2100 delivers an additional inflation
579  // to avoide too small results
580  }
581  else
582  { // Without underflow:
583  na = sub_real(na,nb); // Hier normale Rechnung!
584  res = lx_interval(na,al);
585  // Caution: This else-block can deliver an interval res,
586  // with a so small |res| value , that for example
587  // res * res produces an error message. To avoide this
588  // message, res will be sufficiently inflated:
589 
590  if (na<Max_Int_N) // Only in extreme cases!
591  {
592  if (Inf(al)>0)
593  SetInf(al,0.0);
594  else
595  if (Sup(al)<0)
596  SetSup(al,0.0);
597 
598  res = lx_interval(Max_Int_N,al);
599  }
600  }
601 
602  stagprec = stagsave;
603  res = adjust(res);
604  return res;
605 }
606 
607 // ----------------------- Input --------------------------------------------
608 
609 std::string & operator >> (std::string &s, lx_interval &a) throw()
610 // Writes string s to variable a of type lx_interval
611 // and returns an empty string s;
612 // Example: s = "{-4000,[2,2]}" delivers an interval a
613 // with: 10^(-4000)*[2,2] <= a;
614 // Whitespaces are NOT allowed in s !
615 {
616  l_interval la;
617  real exr;
618  int i;
619 
620  s = skipwhitespacessinglechar (s, '{');
621  s >> exr;
622  s = skipwhitespacessinglechar (s, ',');
623  i = s.find("]");
624  s.erase(i+1);
625  a = lx_interval(exr,s);
626  s = "";
627 
628  return s;
629 }
630 
631 void operator >> (const std::string &s, lx_interval &a) throw()
632 {
633 // Writes strings s to variable a of type lx_interval;
634  std::string r(s);
635  r >> a;
636 }
637 
638 void operator >> (const char *s, lx_interval &a) throw()
639 {
640  std::string r(s);
641  r >> a;
642 }
643 
644 bool StrContains(const string &s, const char &a, const char &b)
645 // returns 1, if s contains char a or char b, otherwise 0;
646 {
647  int ia,ib;
648  ia = s.find(a,0);
649  ib = s.find(b,0);
650  return (ia>=0 || ib>=0);
651 }
652 
653 std::istream & operator >> (std::istream &s, lx_interval &a) throw()
654 // s must have the form: { p,[r1,r2] }, where r1<=r2 are real values
655 // and the exponent p of type real must be an integer value to base 10;
656 // The integer value condition and r1<=r2 are tested in the constructor
657 // call: a = lx_interval(exr,str);
658 // Blomquist, 27.01.2008;
659 {
660  char c;
661  real exr;
662  string str,sh;
663 
664  skipeolnflag = inpdotflag = true;
665  c = skipwhitespacessinglechar (s, '{');
666  if (inpdotflag) s.putback(c);
667  s >> SaveOpt >> exr;
668  c = skipwhitespacessinglechar (s, ',');
669  if (inpdotflag) s.putback(c);
670  skipeolnflag = inpdotflag = true;
671  s >> str >> RestoreOpt;
672 
673  while ( !StrContains(str,']','}') )
674  {
675  c = skipwhitespaces (s);
676  if (inpdotflag && c != '}') s.putback(c);
677  if (c == '}') break;
678  if (c == ' ') break;
679  s >> sh;
680  str = str + sh;
681  }
682 
683  a = lx_interval(exr,str);
684 
685  if (!waseolnflag)
686  {
687  skipeolnflag = false; inpdotflag = true;
688  c = skipwhitespaces (s);
689  if (inpdotflag && c != '}')
690  s.putback(c);
691  }
692 
693  return s;
694 }
695 
696 // ----------------------- Output --------------------------------------------
697 
698 void Bin2Dec(const lx_interval& a, real& p, l_interval& m)
699 // Calculates for a given interval a of type lx_interval the
700 // exponent p and the classic staggered interval m of type
701 // l_interval, so that the inclusion
702 // a <= 10^p * m is guaranteed.
703 // Blomquist, 26.09.2008;
704 {
705  const real c1 = 0.301029995663981195;
706  const real c2 = 9.007199254738000E+015;
707  const real c3 = 10000.0;
708  l_interval x;
709  lx_interval u,v;
710  real y,k,l;
711  int stagsave;
712  bool neg;
713 
714  stagsave = stagprec;
715  stagprec = stagprec + 1;
716 
717  x = li_part(a);
718  y = expo(a);
719  neg = y<0;
720  if (x==0)
721  {
722  p = 0; m = 0;
723  }
724  else
725  {
726  p = y*c1;
727  p = std::floor(_double(p));
728  y = abs(y);
729  u = lx_interval(y,l_interval(1));
730  v = power( lx_interval(0,l_interval(10)),abs(p) );
731  if (y > c2)
732  {
733  u = lx_interval(y-c3,l_interval(1));
734  times2pown(v,-c3);
735  }
736  if (neg) u = v/u;
737  else u = u/v;
738  u = u*lx_interval(0,x);
739  m = li_part(u);
740  k = expo(u);
741  l = k*c1;
742  l = std::floor(_double(l)) + 1;
743  p = p+l;
744  u = lx_interval(k,l_interval(1)) /
745  power( lx_interval(0,l_interval(10)),l );
746  u = u * lx_interval(0,m);
747  k = expo(u);
748  m = li_part(u);
749  Times2pown(m,k);
750  }
751  stagprec = stagsave;
752  m = adjust(m);
753 } // Bin2Dec(...)
754 
755 std::ostream& operator << (std::ostream& s,const lx_interval& a) throw()
756 // An interval a of type lx_interval is written to the
757 // output channel in the decimal form:
758 // { 10**(p), l_interval m } = 10^p * m;
759 // The following inclusion is realized: a <= 10^p * m;
760 // Blomquist, 18.01.2008;
761 {
762  real p;
763  l_interval m;
764 
765  Bin2Dec(a,p,m);
766 
767  s << "{ "
768  << "10**("
769  << SaveOpt << SetPrecision(0,0) << Fixed << p << RestoreOpt
770  << ")"
771  << "*"
772  << m
773  << " }";
774  return s;
775 }
776 
777 std::string & operator << (std::string &s, const lx_interval &a) throw()
778 // The value of a variable a of type lx_interval is copied to a string s.
779 // s has the form: {2**(ex), li} = 2^ex * li;
780 {
781  std::stringstream ss;
782  string str;
783  s+="{2**(";
784  ss << SaveOpt << SetPrecision(0,0) << Fixed << a.ex << RestoreOpt;
785  ss >> str;
786  s += str;
787  s+=")*";
788  s << a.li;
789  s+='}';
790  return s;
791 }
792 
793 
794 // ----- Help Functions, declared in lx_interval.hpp outside ---------------
795 // --------------------- the class lx_interval------------------------------
796 
798 // returns a staggered point interval with maximum exponent 1020,
799 // whereby nearly all mantissa bits are set.
800 {
801  l_real lr;
802  l_interval li = sqrt(l_interval(3.995)), res(li);
803  times2pown(li,1019);
804  lr = Inf(li);
805  lr = ((lr + Inf(res)) + MinReal) + minreal;
806  res = l_interval(lr);
807  return res;
808 }
809 
811 // returns a staggered point interval with exponent n,
812 // whereby nearly all mantissa bits are set.
813 // -1074 <= n <= +1020;
814 {
815  int n_(n);
816  l_interval res;
817 
818  if (n_>1020) n_ = 1020;
819  if (n_<-1074) n_ = -1074;
820  res = point_max();
821  times2pown(res,n_ - 1020);
822  return l_interval(Inf(res+MinReal));
823 }
824 
826 // returns a staggered interval a with maximum exponent 1020
827 // and diam(a)>0, whereby nearly all mantissa bits are set.
828 {
829  l_interval a = point_max();
830  return a + interval(MinReal,2*MinReal);
831 }
832 
834 // returns a staggered point interval a with exponent n,
835 // and diam(a)>0, whereby nearly all mantissa bits are set.
836 // -1074 <= n <= +1020;
837 {
838  l_interval a = point_any(n);
839  return a + interval(MinReal,2*MinReal);
840 }
841 
842 // ----------------------------------------------------------------------------
843 // ---------------- Functions related to class lx_real ------------------------
844 // ----------------------------------------------------------------------------
845 
846  lx_real::lx_real(const real& n, const string &s) throw()
847 // Constructor:
848 // (10^n, string) --- > (ex,lr) vom Typ lx_real
849 // string s must be of the form:
850 // s = "1.234567"; or: s = "0";
851 // or: s = "1.234567e+20";
852 // or: s = "1.234567e-20";
853 // (ex,li) is an approximation of 10^n*s;
854 {
855  const real c1 = 3.3219280948873623; // c1 = ln(10)/ln(2)
856  const real c2 = 2.711437152598000E+015;
857  const real c3 = 10000.0;
858  l_real x(0);
859  lx_interval u,v;
860  real y,ay,r;
861  int stagsave;
862  bool neg;
863 
864  stagsave = stagprec;
865 
866  if (!Is_Integer(n))
867  cxscthrow(REAL_NOT_ALLOWED(
868  "lx_real(const real&, const string& )"));
869  stagprec = stagprec +1;
870  x = x + 0; // To get StagPrec(x) = actual value of stagprec;
871  s >> x; // x ~ s; x of type l_real;
872  if (x==0)
873  {
874  lr = 0; ex = 0;
875  }
876  else
877  {
878  neg = (n<0);
879  y = n*c1;
880  y = std::floor(_double(y));
881  ay = abs(y); r = abs(n);
882  if (ay>=Max_Int_R)
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));
887  if (r > c2)
888  {
889  v = lx_interval(ay-c3,l_interval(1));
890  times2pown(u,-c3);
891  }
892  if (neg) u = v/u;
893  else u = u/v;
894  u = u*lx_interval(0,l_interval(x));
895  lr = mid(li_part(u));
896  r = expo(u);
897  ex = add_real(y,r);
898  }
899  stagprec = stagsave;
900  lr = adjust(lr);
901 }
902 
903  std::string & operator >> (std::string &s, lx_real &a) throw()
904 // Writes string s to variable a of type lx_real
905 // and returns an empty string s;
906 // Example: s = "{-4000,2}" delivers a value a
907 // with: 10^(-4000)*2 ~ a;
908 {
909  real exr;
910  int i;
911 
912  s = skipwhitespacessinglechar (s, '{');
913  s >> exr;
914  s = skipwhitespacessinglechar (s, ',');
915  i = s.find("}");
916  s.erase(i+1);
917  a = lx_real(exr,s);
918  s = "";
919 
920  return s;
921 }
922 
923  void operator >> (const std::string &s, lx_real &a) throw()
924 {
925  // Writes string s to variable a of type lx_real;
926  std::string r(s);
927  r >> a;
928 }
929 
930  void operator >> (const char *s, lx_real &a) throw()
931 {
932  std::string r(s);
933  r >> a;
934 }
935 
936  bool Str_Contains(const string &s, const char &a, const char &b)
937 // returns 1, if s contains char a or char b, otherwise 0;
938 {
939  int ia,ib;
940  ia = s.find(a,0);
941  ib = s.find(b,0);
942  return (ia>=0 || ib>=0);
943 }
944 
945  std::istream & operator >> (std::istream &s, lx_real &a) throw()
946 // s must have the form: { p,r }, where r is a real value
947 // and the exponent p of type real must be an integer value to base 10;
948 // The integer value condition is tested in the constructor call:
949 // a = lx_interval(exr,str);
950 // Blomquist, 06.101.2008;
951 {
952  char c;
953  real exr;
954  string str,sh;
955  skipeolnflag = inpdotflag = true;
956  c = skipwhitespacessinglechar (s, '{');
957  if (inpdotflag) s.putback(c);
958  s >> SaveOpt >> exr;
959  c = skipwhitespacessinglechar (s, ',');
960  if (inpdotflag) s.putback(c);
961  skipeolnflag = inpdotflag = true;
962  s >> str >> RestoreOpt;
963  while ( !Str_Contains(str,']','}') )
964  {
965  c = skipwhitespaces (s);
966  if (inpdotflag && c != '}') s.putback(c);
967  if (c == '}') break;
968  if (c == ' ') break;
969  s >> sh;
970  str = str + sh;
971  }
972 
973  a = lx_real(exr,str);
974 
975  if (!waseolnflag)
976  {
977  skipeolnflag = false; inpdotflag = true;
978  c = skipwhitespaces (s);
979  if (inpdotflag && c != '}')
980  s.putback(c);
981  }
982  return s;
983 }
984 
985 
986 bool operator == (const lx_real &a, const lx_real &b) throw()
987 {
988  const real c1 = 1e20;
989  l_real ar(lr_part(a)), br(lr_part(b));
990  real na(expo(a)), nb(expo(b));
991  int exa(expo_gr(ar)), exb(expo_gr(br)),d;
992  bool a_0(exa<-100000), b_0(exb<-100000), res;
993  interval z(0);
994 
995  if (a_0 || b_0) res = (a_0 == b_0);
996  else // a,b <> 0:
997  {
998  d = exa-exb;
999  if (d>0)
1000  { // br nach oben skalieren: (Overflow dabei nicht moeglich!)
1001  Times2pown(br,z,d);
1002  nb = nb - d;
1003  if (abs(nb)>Max_Int_R)
1004  nb = c1; // equality not possible
1005  } else // d<=0:
1006  { // ar nach oben skalieren: (Overflow dabei nicht moeglich!)
1007  Times2pown(ar,z,-d);
1008  na = na + d;
1009  if (abs(na)>Max_Int_R)
1010  na = c1; // equality not possible
1011  }
1012  res = (na==nb && ar==br);
1013  }
1014  return res;
1015 }
1016 
1017 bool operator > (const lx_real &a, const lx_real &b) throw()
1018 {
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);
1021  real na,nb,d;
1022  double dbl;
1023  interval z(0);
1024  int D;
1025 
1026  if (zero_a) return sm_zero(b);
1027  if (zero_b) return gr_zero(a);
1028  // Now we have: a,b != 0:
1029  na = expo(a); nb = expo(b);
1030  d = na - nb;
1031 
1032  if (na==nb)
1033  bl = (lra >lrb);
1034  else
1035  if (na>nb)
1036  {
1037  if (d > 1024-expo_gr(lra))
1038  // Scaling not possible
1039  bl = (sign(lra)>0) ? true : false;
1040  else
1041  {
1042  dbl = _double(d);
1043  D = (int) dbl;
1044  Times2pown(lra,z,D);
1045  bl = lra > lrb;
1046  }
1047  }
1048  else // nb > na
1049  {
1050  if (d < expo_gr(lrb)-1024)
1051  // Scaling not possible
1052  bl = (sign(lrb)<0) ? true : false;
1053  else
1054  {
1055  dbl = _double(-d);
1056  D = (int) dbl;
1057  Times2pown(lrb,z,D);
1058  bl = lra > lrb;
1059  }
1060  }
1061 
1062  return bl;
1063 }
1064 
1065 void scale_up(lx_real &a) throw()
1066 // scale_up(a) scales a.lr upwardly as far as possible.
1067 // Notice: a.lr must absolutely be sorted, i.e. for
1068 // example: a.lr[1]=1e50, a.lr[2]=1e20, a.lr[3]=1;
1069 // In case of (d>0 && a.ex-d >= -Max_Int_R) the values
1070 // of 2^(a.ex)*a.lr are equal before and after the scaling.
1071 // In case of (d<=0 || a.ex-d < -Max_Int_R) no scaling is done.
1072 {
1073  interval z(0);
1074  int d;
1075  d = 1023 - expo_gr(a.lr); // d >= 0, if a.lr <> 0;
1076  if (d>0 && a.ex >= -Max_Int_R+d) // If (a==0) then d<0 and nothing is done!
1077  {
1078  Times2pown(a.lr,z,d); // a.lr wird mit 2^d multipliziert.
1079  a.ex = a.ex - d; // damit 2^(a.ex)*a.li konstant bleibt.
1080  }
1081 }
1082 
1083 void scale_down(lx_real &a) throw()
1084 // scale_down skaliert a moeglichst weit nach unten, ohne
1085 // dass dabei binaere Stellen verloren gehen.
1086 // Der mathematische Wert von a bleibt dabei erhalten, d.h.
1087 // 2^(a.ex)*a.li hat vor und nach der Skalierung stets den
1088 // gleichen mathematischen Wert.
1089 {
1090  interval z(0);
1091  int d;
1092  d = -1021 - expo_sm(a.lr);
1093  // In case of a.lr=0 we get d>0, and so nothing is done!
1094  if (d<0 && a.ex <= Max_Int_R+d)
1095  {
1096  Times2pown(a.lr,z,d); // a.lr = a.lr * 2^d
1097  a.ex = a.ex - d;
1098  }
1099 }
1100 
1101 
1102 lx_real upper_bnd(const lx_real& x) throw()
1103 // y = upper_bnd(x) calculates an upper bound y of x < y;
1104 // lr = lr_part(x); (See the following code.)
1105 // The components lr[1],lr[2], ... ,lr[StagPrec(x)] must be sorted!
1106 {
1107  int stagsave = stagprec,
1108  p(StagPrec(x)),ex_gr;
1109  stagprec = p;
1110 
1111  lx_real res;
1112  l_real lr(lr_part(x));
1113  real ex(expo(x));
1114 
1115  lr = lr + 0; // sorting the lr[i]
1116  res = lx_real(ex,lr);
1117  if (p>1)
1118  scale_up(res);
1119  lr = lr_part(res);
1120  ex = expo(res);
1121  ex_gr = expo_gr(lr);
1122  if (ex_gr>-10000000)
1123  { // x<>0:
1124  if (lr[1]==MaxReal)
1125  {
1126  times2pown(lr,-1);
1127  ex = add_real(ex,1);
1128  }
1129  lr[p] = succ(lr[p]);
1130  lr = lr + 0; // sorting lr !
1131  res = lx_real(ex,lr);
1132  }
1133  else // x = 0:
1134  {
1135  lr = minreal;
1136  lr = adjust(lr);
1137  lr = lr + 0; // sorting lr !
1138  res = lx_real(-Max_Int_R,lr);
1139  }
1140  stagprec = stagsave;
1141 
1142  return res;
1143 } // upper_bnd(...)
1144 
1145 lx_real lower_bnd(const lx_real& x) throw()
1146 // y = lower_bnd(x) calculates a rather great lower bound y of x > y;
1147 // lr = lr_part(x); (See the following code.)
1148 // The components lr[1],lr[2], ... ,lr[StagPrec(x)] must be sorted!
1149 {
1150  int stagsave = stagprec,
1151  p(StagPrec(x)),ex_gr;
1152 
1153  stagprec = p;
1154  lx_real res;
1155  l_real lr(lr_part(x));
1156  real ex(expo(x));
1157 
1158  lr = lr + 0; // sorting the lr[i]
1159  res = lx_real(ex,lr);
1160  if (p>1)
1161  scale_up(res);
1162  lr = lr_part(res);
1163  ex = expo(res);
1164  ex_gr = expo_gr(lr);
1165  if (ex_gr>-10000000)
1166  {
1167  if (lr[1]==-MaxReal)
1168  {
1169  times2pown(lr,-1);
1170  ex = add_real(ex,1);
1171  }
1172  lr[p] = pred(lr[p]);
1173  lr = lr + 0; // sorting lr !
1174  res = lx_real(ex,lr);
1175  }
1176  else // x = 0;
1177  {
1178  lr = -minreal;
1179  lr = adjust(lr);
1180  lr = lr + 0; // sorting lr !
1181  res = lx_real(-Max_Int_R,lr);
1182  }
1183  stagprec = stagsave;
1184  return res;
1185 } // lower_bnd(...)
1186 
1187 lx_real operator + (const lx_real &a, const lx_real &b) throw()
1188 // An approximation of (a+b) is calculated. In most of the cases
1189 // a maximum of accuracy is achieved.
1190 {
1191  //const real c1 = 10000.0;
1192  const int c2 = 1022,
1193  c3 = -100000;
1194  int stagsave = stagprec,
1195  stagmax = 39,
1196  exa,exb;
1197  real sa,sb,p,n;
1198 
1199  if (stagprec>stagmax) stagprec = stagmax;
1200  l_real a1,b1;
1201  lx_real res(0),A(a),B(b);
1202 
1203  a1 = lr_part(A); b1 = lr_part(B);
1204  exa = expo_gr(a1);
1205  exb = expo_gr(b1);
1206 
1207  if (exa<c3) return b; // summans a = 0;
1208  if (exb<c3) return a; // summans b = 0;
1209 
1210  // From now on: a,b <> 0
1211  sa = add_real(exa,expo(A));
1212  sb = add_real(exb,expo(B));
1213  if (sa > sb) // |a| >= |b|
1214  {
1215  p = c2 - exa;
1216  Times2pown(a1,p);
1217  n = sub_real(expo(A),p);
1218  p = sub_real(expo(B),n);
1219  Times2pown(b1,p);
1220  }
1221  else
1222  {
1223  p = c2 - exb;
1224  Times2pown(b1,p);
1225  n = sub_real(expo(B),p);
1226  p = sub_real(expo(A),n);
1227  Times2pown(a1,p);
1228  }
1229  a1 = a1 + b1;
1230  res = lx_real(n,a1);
1231 
1232  stagprec = stagsave;
1233  res = adjust(res);
1234  return res;
1235 }
1236 
1237 lx_real operator * (const lx_real& a, const lx_real& b) throw()
1238 // An approximation of (a*b) is calculated. In most of the cases
1239 // a maximum of accuracy is achieved.
1240 {
1241  int stagsave = stagprec,
1242  stagmax = 39,
1243  exa,exb,d,D,k;
1244  real na,nb,diff;
1245 
1246  if (stagprec > stagmax) stagprec = stagmax;
1247 
1248  l_real al,bl;
1249  lx_real a_(a),b_(b),res(0);
1250 
1251  scale_down(a_); scale_down(b_);
1252 
1253  al = lr_part(a_); bl = lr_part(b_);
1254  exa = expo_gr(al);
1255  exb = expo_gr(bl);
1256 
1257  if (exa>-100000 && exb>-100000) // Beide Faktoren sind <> 0:
1258  {
1259  if (exa+exb <= 1022)
1260  {
1261  if (exa<0)
1262  {
1263  Times2pown(al,-exa);
1264  na = add_real(expo(a_),exa); // a = 2^na * al;
1265  d = 1022 - exb;
1266  }
1267  else // exa >= 0
1268  {
1269  na = expo(a_);
1270  d = 1022 - (exa+exb);
1271  }
1272  Times2pown(bl,d);
1273  nb = sub_real(expo(b_),d); // b = 2^nb * bl;
1274  }
1275  else // exa+exb > 1022
1276  {
1277  d = exa + exb - 1022; // d > 0;
1278  if (exa>exb)
1279  {
1280  D = exa - exb; // D > 0;
1281  if (d <= D)
1282  {
1283  Times2pown(al,-d);
1284  na = add_real(expo(a_),d); // a = 2^na * al;
1285  nb = expo(b_);
1286  }
1287  else // d > D;
1288  {
1289  k = d - D;
1290  if (k%2 != 0) k++;
1291  k = k/2;
1292  Times2pown(bl,-k);
1293  nb = add_real(expo(b_),k); // b = 2^nb * bl;
1294  k = k + D;
1295  Times2pown(al,-k);
1296  na = add_real(expo(a_),k); // a = 2^na * al;
1297  }
1298  }
1299  else // exb >= exa
1300  {
1301  D = exb - exa; // D > 0;
1302  if (d <= D)
1303  {
1304  Times2pown(bl,-d);
1305  nb = add_real(expo(b_),d); // b = 2^nb * bl;
1306  na = expo(a_);
1307  }
1308  else // d > D
1309  {
1310  k = d - D;
1311  if (k%2 != 0) k++;
1312  k = k/2;
1313  Times2pown(al,-k);
1314  na = add_real(expo(a_),k); // a = 2^na * al;
1315  k = k + D;
1316  Times2pown(bl,-k);
1317  nb = add_real(expo(b_),k); // b = 2^nb * bl;
1318  }
1319  }
1320  }
1321  al = al*bl; // normal staggered multiplication
1322 
1323  if (na+nb<-Max_Int_R) // Underflow:
1324  {
1325  diff = (Max_Int_R + na) + nb; // diff < 0;
1326  Times2pown(al,diff);
1327  res = lx_real(-Max_Int_R,al);
1328  }
1329  else // Without underflow
1330  {
1331  na = add_real(na,nb); // Hier normale Rechnung!
1332  res = lx_real(na,al);
1333  }
1334 
1335  }
1336  stagprec = stagsave;
1337  res = adjust(res);
1338  return res;
1339 } // operator *
1340 
1341 lx_real operator / (const lx_real &a, const lx_real &b) throw(DIV_BY_ZERO)
1342 {
1343  int stagsave = stagprec,
1344  stagmax = 39,
1345  exa,exb,d;
1346  real na,nb,diff;
1347  if (stagprec>stagmax) stagprec = stagmax;
1348 
1349  l_real al,bl;
1350  lx_real a_(a),b_(b),res;
1351 
1352  scale_down(a_);
1353  scale_down(b_);
1354  al = lr_part(a_); bl = lr_part(b_);
1355 
1356  exa = expo_gr(al);
1357  exb = expo_gr(bl);
1358 
1359  if (exb < -100000)
1360  cxscthrow(DIV_BY_ZERO("lx_real operator/(const lx_real &a, const lx_real &b)"));
1361 
1362  if (exa < -100000) return a;
1363  // Now it holds: a,b <> 0:
1364  // First: scaling the nominator al to 1022:
1365  d = 1022 - exa;
1366  Times2pown(al,d); // expo_gr(al) = 1022;
1367  na = sub_real(expo(a_),d); // a = 2^na * al;
1368  if (0<=exb && exb<=511)
1369  nb = expo(b_);
1370  else
1371  if (exb<0)
1372  { // scaling the denominator bl to 0:
1373  Times2pown(bl,-exb);
1374  nb = add_real(expo(b_),exb); // b = 2^nb * bl;
1375  }
1376  else // exb > 511;
1377  // Now scaling the denominator bl to 511:
1378  {
1379  d = 511 - exb;
1380  Times2pown(bl,d);
1381  nb = sub_real(expo(b_),d);
1382  }
1383 
1384  al = al / bl; // Normal staggered division;
1385  if (na-nb<-Max_Int_R) // Underflow:
1386  {
1387  diff = (Max_Int_R - nb) + na; // diff < 0;
1388  Times2pown(al,diff);
1389  res = lx_real(-Max_Int_R,al);
1390  }
1391  else
1392  { // Without underflow:
1393  na = sub_real(na,nb); // Hier normale Rechnung!
1394  res = lx_real(na,al);
1395  }
1396 
1397  stagprec = stagsave;
1398  res = adjust(res);
1399 
1400  return res;
1401 } // operator /
1402 
1403 l_real & l_real::operator = (const lx_real& a) throw()
1404 {
1405  int exar;
1406  real p(expo(a)), exr;
1407  l_real ar(lr_part(a));
1408  exar = expo_gr(ar);
1409  if (exar<-100000) return (*this) = ar; // ar = 0;
1410  exr = p + exar;
1411  if (exr > 1024)
1412  cxscthrow(OVERFLOW_ERROR(
1413  "LX_REAL_UNREALIZABLE_AS_L_REAL: l_real & operator = (const lx_real& a)"));
1414  Times2pown(ar,p);
1415 
1416  return *this = ar;
1417 }
1418 
1419 real & real::operator = (const lx_real& a) throw()
1420 {
1421  l_real lr;
1422  real x;
1423 
1424  lr = a;
1425  x = lr;
1426 
1427  return *this = x;
1428 }
1429 
1430 // -------------------------------------------------------------------------------
1431 // -------------------------------------------------------------------------------
1432 
1433 real expo_RelDiam(const l_interval &x)
1434 // rd := RelDiam(x) is defined as usual;
1435 // rd '=' 2^n; n is returned by expo_RelDiam();
1436 // |n| is a good approximation of the first
1437 // common binary digits of the interval x.
1438 // x is a point interval --> n <= -2147483647
1439 // x = [4,5] --> n = -1;
1440 // x = [20000,20001] --> n = -14;
1441 // This function is only for the internal use!
1442 // Blomquist, 11.02.2008;
1443 {
1444  lx_real R;
1445  real n;
1446  lx_interval t;
1447  l_real r1(Inf(x)),r2(Sup(x));
1448  t = lx_interval(r2) - lx_interval(r1);
1449 
1450  if ( in(0.0,x) )
1451  R = Sup(t);
1452  else
1453  {
1454  R = Sup( t / lx_interval( AbsMin(x) ) );
1455  }
1456  n = expo(R) + expo_gr(lr_part(R));
1457 
1458  return n;
1459 } // expo_RelDiam()
1460 
1461 // --------------------------------------------------------------------------
1462 // -------------- Elementary functions of type lx_interval ------------------
1463 // --------------------------------------------------------------------------
1464 
1465 lx_interval sqrt(const lx_interval &a) throw()
1466 {
1467  int stagsave = stagprec,
1468  stagmax = 30; // l_imath.cpp: sqrt() uses stagmax = 30;
1469  if (stagprec>stagmax) stagprec = stagmax;
1470 
1471  lx_interval res;
1472  l_interval la(li_part(a));
1473  real na(expo(a)),r(0);
1474  int exa(expo_gr(la)),d;
1475 
1476  if (exa<-100000) res = 0.0; // la = 0;
1477  else // la <> 0;
1478  {
1479  if ( !Is_Integer(na/2) )
1480  {
1481  r = -1.0;
1482  if (na>0)
1483  na = (na-1)/2 + 1;
1484  else na = (na+1)/2;
1485  }
1486  else // na ist gerade
1487  na = na/2;
1488 
1489  d = 1024 - exa; // d >= 0;
1490  r = r - d;
1491  if ( !Is_Integer(r/2) )
1492  {
1493  r = r + 1;
1494  d--;
1495  }
1496  Times2pown(la,d);
1497  na = na + r/2;
1498  la = sqrt(la);
1499  res = lx_interval(na,la);
1500  }
1501 
1502  stagprec = stagsave;
1503  res = adjust(res);
1504  return res;
1505 } // sqrt()
1506 
1507 lx_interval sqr(const lx_interval &x) throw()
1508 {
1509  int stagsave = stagprec,
1510  stagmax = 39;
1511  if (stagprec>stagmax) stagprec = stagmax;
1512 
1513  lx_interval y;
1514  l_interval xl(li_part(x));
1515 
1516  if (Inf(xl) >= 0.0)
1517  y = x*x;
1518  else if (Sup(xl) <= 0.0)
1519  {
1520  y = lx_interval(expo(x),l_interval(-Sup(xl),-Inf(xl)));
1521  y = (y) * (y);
1522  } else
1523  {
1524  if (abs(Inf(xl)) >= abs(Sup(xl)))
1525  y = lx_interval(expo(x),l_interval(0.0,abs(Inf(xl))));
1526  else y = lx_interval(expo(x),l_interval(0.0,abs(Sup(xl))));
1527  y = (y) * (y);
1528  }
1529 
1530  stagprec = stagsave;
1531  y = adjust(y);
1532  return y;
1533 }
1534 
1535 lx_interval Lnp1(const lx_interval &x) throw()
1536 // Calculating an inclusion of ln(1+x) for
1537 // not too wide intervals, |x| <= 1e-7;
1538 // This function is for the internal use only,
1539 // see the functions ln(...), lnp1(...);
1540 // Blomquist, 27.02.2008;
1541 {
1542  lx_interval res(0),z2,zeta,Ri,Two;
1543  l_interval xli;
1544  int N,ex,p;
1545  real m,expox;
1546 
1547  p = stagprec;
1548  xli = li_part(x);
1549  ex = expo_gr(xli);
1550  if (ex>-100000) // x <> 0
1551  {
1552  expox = expo(x);
1553  if (expox < 3-27*p-ex) N = 0;
1554  else
1555  {
1556  m = ex + expox; // m = ex + expo(x);
1557  N = (int) _double( (53*p-4)/(2*(1-m)) );
1558  }
1559  // N: Polynomial degree, 0<=N<=42;
1560  zeta = x / (2+x);
1561  Two = lx_interval(2);
1562  Ri = lx_interval( Sup(abs(zeta)) );
1563  Ri = sqr(Ri);
1564  if (N==0)
1565  res = Two;
1566  else // N >= 1:
1567  {
1568  z2 = sqr(zeta); // z2 = zeta^2
1569  // Evaluating the polynomial:
1570  res = Two / (2*N+1); // res = a_(N)
1571  for (int i=N-1; i>=0; --i)
1572  res = res*z2 + Two/(2*i+1);
1573  // Calculating the absolute approximation error:
1574  Ri = power(Ri,N+1)/(N+1);
1575  }
1576  // Implementing the approximation error:
1577  res += lx_interval(lx_real(0),Sup(Ri));
1578  res *= zeta;
1579  } // x <> 0;
1580 
1581  return res;
1582 } // Lnp1(...)
1583 
1584 lx_interval Ln_(const lx_interval &x) throw()
1585 {
1586  lx_interval T(0.0);
1587  l_interval lx(li_part(x));
1588  interval z;
1589  real eps;
1590  int exa(expo_gr(lx)),k(0);
1591  real nx(expo(x)),n;
1592  // we have: Inf(x)>0 --> exa <> -2147483648:
1593  if (abs(nx)<5000)
1594  {
1595  n = exa + nx; // nx is a guaranteed integer!
1596  if (n==0 || n==1)
1597  {
1598  T = x - 1.0;
1599  lx = T;
1600  if (Sup(abs(lx))<1e-7)
1601  {
1602  T = Lnp1(T);
1603  goto fertig;
1604  }
1605  }
1606  }
1607  T = x;
1608  times2pown(T,-nx);
1609  times2pown(T,-exa); // T: 1st reduced argument
1610  lx = T;
1611  z = lx;
1612  eps = Sup(1-z);
1613  if (eps>1e-12)
1614  {
1615  eps = (ln(eps) + 6*ln_N[8])/ln_N[0];
1616  k = (int) _double(eps);
1617  if (k<=0) k = 0;
1618  }
1619  for (int j=1; j<=k; j++)
1620  T = sqrt(T); // T: 2nd reduced argument,
1621  // T = [2^k]sqrt(T);
1622  T = Lnp1(T-1.0);
1623  if (k>0) times2pown(T,k);
1624  T = nx*Ln2_lx_interval() + exa*Ln2_lx_interval() + T;
1625 
1626  fertig:
1627  return T;
1628 } // Ln_(...)
1629 
1630 lx_interval ln(const lx_interval &x) throw()
1631 {
1632  int stagsave = stagprec,
1633  stagmax = 39;
1634  if (stagprec>stagmax) stagprec = stagmax;
1635 
1636  lx_interval res,a;
1637 
1638  if (Inf(li_part(x))<=0) cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
1639  "lx_interval ln(const lx_interval &)"));
1640  // Now we have: Inf(x)>0:
1641  real r;
1642  r = expo_RelDiam(li_part(x));
1643  if (r > -107) // If the rel. diam of x is too great
1644  { // the ln function is calculated at the
1645  // boundary points of the interval x. Thus, the
1646  // inclusion res is: [Inf(res),Sup(a)]
1647  res = lx_interval(Inf(x));
1648  res = Ln_(res);
1649  a = lx_interval(Sup(x));
1650  a = Ln_(a);
1651  res = lx_interval(Inf(res),Sup(a));
1652  }
1653  else
1654  res = Ln_(x);
1655 
1656  stagprec = stagsave;
1657  res = adjust(res);
1658 
1659  return res;
1660 } // ln(...)
1661 
1662 lx_interval log2(const lx_interval &x) throw()
1663 {
1664  int stagsave = stagprec,
1665  stagmax = 39;
1666  if (stagprec>stagmax) stagprec = stagmax;
1667  lx_interval res;
1668 
1669  res = ln(x)/Ln2_lx_interval();
1670  stagprec = stagsave;
1671  res = adjust(res);
1672 
1673  return res;
1674 }
1675 
1676 lx_interval log10(const lx_interval &x) throw()
1677 {
1678  int stagsave = stagprec,
1679  stagmax = 39;
1680  if (stagprec>stagmax) stagprec = stagmax;
1681  lx_interval res;
1682 
1683  res = ln(x)/Ln10_lx_interval();
1684  stagprec = stagsave;
1685  res = adjust(res);
1686 
1687  return res;
1688 }
1689 
1690 lx_interval Lnp1_(const lx_interval &x) throw()
1691 {
1692  const real r = 1e-7;
1693  lx_interval res;
1694 
1695  res = (Inf(x)>-r && Sup(x)<r)? Lnp1(x) : Ln_(1.0+x);
1696 
1697  return res;
1698 } // Lnp1_(...)
1699 
1700 lx_interval lnp1(const lx_interval &x) throw()
1701 {
1702  int stagsave = stagprec,
1703  stagmax = 39;
1704  if (stagprec>stagmax) stagprec = stagmax;
1705 
1706  lx_interval res,a;
1707 
1708  if (Inf(x)<= -1) cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
1709  "lx_interval lnp1(const lx_interval &)"));
1710  // Now we have: Inf(x)>-1:
1711  real r;
1712 
1713  r = expo_RelDiam(li_part(x));
1714  if (r > -107) // If the rel. diam of x is too great
1715  { // the lnp1 function is calculated at the
1716  // boundary points of the interval x. Thus, the
1717  // inclusion res is: [Inf(res),Sup(a)]
1718  res = lx_interval(Inf(x));
1719  res = Lnp1_(res);
1720  a = lx_interval(Sup(x));
1721  a = Lnp1_(a);
1722  res = lx_interval(Inf(res),Sup(a));
1723  }
1724  else
1725  res = Lnp1_(x);
1726 
1727  stagprec = stagsave;
1728  res = adjust(res);
1729 
1730  return res;
1731 }
1732 
1733 // -------------------------------------------------------------------------
1734 // --------------------- power function ------------------------------------
1735 // -------------------------------------------------------------------------
1736 
1737 lx_interval Power_(const lx_interval &x, const real &n) throw()
1738 // Calculates the inclusion of [x]^n for integer values n.
1739 // The rel. diam of x should not be too great.
1740 // This function is only for the internal use! ( power(...) )
1741 // Blomquist, 11.02.2008;
1742 {
1743  real one(1.0),zhi(2.0),N(n),r;
1744  double dbl;
1745 
1746  lx_interval y,neu,X(x);
1747 
1748  if (x == one) y = x;
1749  else
1750  if (N == 0.0) y = one;
1751  else
1752  {
1753  if (N == 1) y = x;
1754  else
1755  if (N == 2) y = sqr(x);
1756  else
1757  {
1758  if (N < 0)
1759  {
1760  X = 1.0/X;
1761  N = -N;
1762  }
1763  // Initialisierung
1764  if ( !Is_Integer(N/2) )
1765  y = X;
1766  else y = one;
1767  neu = sqr(X); // neu = X*X;
1768  do {
1769  dbl = _double(N/zhi);
1770  dbl = std::floor(dbl);
1771  r = (real) dbl;
1772  if ( !Is_Integer( r/2 ) )
1773  y *= neu;
1774  zhi += zhi;
1775  if (zhi <= N)
1776  neu = sqr(neu); // neu = neu * neu;
1777  } while (zhi <= N);
1778  }
1779  }
1780 
1781  return y;
1782 } // Power_()
1783 
1784 lx_interval power(const lx_interval &x, const real &n) throw()
1785 {
1786  int stagsave = stagprec,
1787  stagmax = 38;
1788  if ( !(Is_Integer(n)) )
1789  cxscthrow(REAL_NOT_ALLOWED("lx_interval power(const lx_interval&, const real&)"));
1790 
1791  if (stagprec > stagmax)
1792  stagprec = stagmax;
1793 
1794  lx_interval res,a;
1795  real r;
1796 
1797  r = expo_RelDiam(li_part(x));
1798  if (r > -107) // If the rel. diam of x is too great
1799  { // the power function is calculated at the
1800  // boundary points of the interval x. Thus, the
1801  // inclusion res is the convex hull of these intervals:
1802  res = lx_interval(Inf(x));
1803  res = Power_(res,n);
1804  a = lx_interval(Sup(x));
1805  a = Power_(a,n);
1806  res = res | a; // Konvex hull
1807  }
1808  else
1809  res = Power_(x,n);
1810 
1811  stagprec = stagsave;
1812  res = adjust(res);
1813 
1814  return res;
1815 }
1816 
1817 
1818 // -------------------- Exponential Function -----------------------------
1819 
1820 int Poly_N_Exp(const lx_interval &x)
1821 // Calculation of the polynomial degee N:
1822 // Only for internal use in exp function !
1823 {
1824  lx_interval absx(abs(x));
1825  int N(0),
1826  m;
1827  real S(-53*StagPrec(x)*ln_N[0]),
1828  c,
1829  D; // S: -53*(precision of x)*ln(2);
1830 
1831  m = expo_gr(li_part(absx));
1832  if (m>-1000000)
1833  { // x != 0:
1834  c = add_real(m,expo(absx))*ln_N[0];
1835  D = c; // D(0) = m*ln(2);
1836  while (D > S) {
1837  N++;
1838  D = D + c - ln_N[N-1];
1839  }
1840  }
1841 
1842  return N;
1843 } // Poly_N_Exp()
1844 
1845 
1846 lx_interval Exp_(const lx_interval &x) throw()
1847 {
1848  int ex,n,N;
1849 
1850  real m;
1851  lx_interval res(1.0),absx,T;
1852  lx_real S;
1853 
1854  absx = abs(x);
1855  ex = expo_gr(li_part(absx));
1856  if (ex>-1000000)
1857  { // x != 0
1858  if (Sup(x) <= -6243314768166103.0)
1859  res = lx_interval(lx_real(0),lx_real(-Max_Int_R,l_real(minreal)));
1860  else
1861  {
1862  m = add_real(expo(absx),ex); // absx '=' 2^m
1863  n = (int) _double( (9*ln_N[8] + m*ln_N[0])/ln_N[0]);
1864  T = x;
1865  T = adjust(T);
1866  if (n>0)
1867  times2pown(T,-n); // T '=' 10^-9
1868  // T: reduced argument
1869  N = Poly_N_Exp(T); // N: Polynomial degree
1870  // Calculation of the N+1 polynomial coefficients
1871  // Koff[0], ... , Koff[N]:
1872  lx_interval *Koff = new lx_interval[N+1];
1873  Koff[0] = 1.0;
1874  for (int k=1; k<=N; k++)
1875  Koff[k] = Koff[k-1]/k;
1876  // Horner-evaluation of the polynomial P_N(T):
1877  res = Koff[N];
1878  for (int k=N-1; k>=0; k--)
1879  res = res*T + Koff[k];
1880  // Calculation of the absolute approximation error:
1881  Koff[0] = 1.0;
1882  for (int k=1; k<=N+1; k++)
1883  Koff[0] = Koff[0]*k; // Koff[0] = (N+1)!
1884  T = lx_interval( Sup(abs(T)) );
1885  T = (power(T,N+1)/Koff[0])/(1-T);
1886  // T: Inclusion of the absolute approximation error
1887  S = Sup(T);
1888  res = res + lx_interval(-S,S); // We now considered
1889  // the absolute approximation error of P_N(T).
1890  // the following loop is only used if n = 1,2,3,...
1891  for (int k=1; k<=n; k++)
1892  res = sqr(res);
1893  delete[] Koff;
1894  }
1895  }
1896  return res;
1897 } // Exp_(...)
1898 
1899 lx_interval exp(const lx_interval &x) throw()
1900 {
1901  int stagsave = stagprec,
1902  stagmax = 40;
1903 
1904  if (stagprec > stagmax)
1905  stagprec = stagmax;
1906  if (stagprec<3) stagprec = 3;
1907 
1908  lx_interval res,a;
1909  real r;
1910 
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));
1915  if (r > -107) // If the rel. diam of x is too great
1916  { // the exp function is calculated at the
1917  // boundary points of the interval x. Thus, the
1918  // inclusion res is the convex hull of these intervals:
1919  res = lx_interval(Inf(x));
1920  res = Exp_(res);
1921  a = lx_interval(Sup(x));
1922  a = Exp_(a);
1923  res = lx_interval(Inf(res),Sup(a));
1924  }
1925  else
1926  res = Exp_(x);
1927 
1928  stagprec = stagsave;
1929  res = adjust(res);
1930 
1931  return res;
1932 } // exp()
1933 
1934 lx_interval exp2(const lx_interval &x) throw()
1935 {
1936  int stagsave = stagprec,
1937  stagmax = 40;
1938  if (stagprec>stagmax) stagprec = stagmax;
1939  if (stagprec<3) stagprec = 3;
1940 
1941  lx_interval res;
1942  res = exp( x*Ln2_lx_interval() );
1943 
1944  stagprec = stagsave;
1945  res = adjust(res);
1946 
1947  return res;
1948 } // exp2(...)
1949 
1950 lx_interval exp10(const lx_interval &x) throw()
1951 {
1952  int stagsave = stagprec,
1953  stagmax = 40;
1954  if (stagprec>stagmax) stagprec = stagmax;
1955  if (stagprec<3) stagprec = 3;
1956 
1957  lx_interval res;
1958  res = exp( x*Ln10_lx_interval() );
1959 
1960  stagprec = stagsave;
1961  res = adjust(res);
1962 
1963  return res;
1964 } // exp10(...)
1965 
1966 lx_interval pow(const lx_interval &x, const lx_interval &e) throw()
1967 // Calculating an inclusion of x^y;
1968 // If y is an integer value n with
1969 // -9007199254740991.0 <= n <= +9007199254740991.0,
1970 // then power(x,n) is used, otherwise y = exp( e*ln(x) ), Inf(x)>0;
1971 // Blomquist, 03.03.2008;
1972 {
1973  int stagsave = stagprec,
1974  stagmax = 40;
1975  lx_interval y;
1976  lx_real supabse = Sup(abs(e));
1977  interval z;
1978  real r;
1979  bool fertig(false);
1980 
1981  if (point_intv(e))
1982  if (supabse < Max_Int_R)
1983  {
1984  z = e;
1985  r = Inf(z);
1986  if ( Is_Integer(r) )
1987  {
1988  if (r==1) y = x;
1989  else
1990  if (r==0) y = 1;
1991  else y = power(x,r);
1992  fertig = true;
1993  }
1994  }
1995  if (!fertig)
1996  {
1997  if (stagprec < stagmax) stagprec++;
1998  else stagprec = stagmax;
1999  y = exp( e*ln(x) );
2000  stagprec = stagsave;
2001  y = adjust(y);
2002  }
2003 
2004  return y;
2005 } // pow(...)
2006 
2007 lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y) throw()
2008 {
2009  int stagsave = stagprec,
2010  stagmax = 40;
2011  if (stagprec>stagmax) stagprec = stagmax;
2012  lx_interval res, su(1.0+x);
2013 
2014  if (point_intv(su) && Sup(su) == 1.0)
2015  res = 1.0;
2016  else
2017  if (point_intv(y) && Sup(y) == 1.0)
2018  res = su;
2019  else
2020  if (point_intv(y) && Sup(y) == 0.0)
2021  res = 1.0;
2022  else
2023  {
2024  if (stagprec < stagmax) stagprec++;
2025  else stagprec = stagmax;
2026  res = exp(y*lnp1(x));
2027  stagprec = stagsave;
2028  res = adjust(res);
2029  }
2030 
2031  return res;
2032 } // xp1_pow_y(...)
2033 
2034 int Poly_N_Expm1(const lx_interval &x)
2035 // Calculation of the polynomial degee N:
2036 // Only for internal use in Expm1(...)
2037 {
2038  lx_interval absx(abs(x));
2039  int N(0), m;
2040  real S(-53*stagprec*ln_N[0]),
2041  c,
2042  D; // S: -53*(Praezision von x)*ln(2);
2043  m = expo_gr(li_part(absx)); // Neu
2044  if (m>-1000000)
2045  {
2046  D = m + expo(absx); // Calculation of D is uncritical!
2047  c = D*ln_N[0];
2048  D = (D-1)*ln_N[0]; // D = (m-1)*ln(2);
2049  while (D > S)
2050  {
2051  N++;
2052  D = D + c - ln_N[N];
2053  }
2054  }
2055  return N;
2056 }
2057 
2058 lx_interval Expm1(const lx_interval &x)
2059 // e^x - 1; |x| <= 1e-7;
2060 // Only for internal use and for
2061 // not too wide intervals!
2062 {
2063  lx_interval res(0),Fak,D;
2064  lx_real S;
2065  int N;
2066  N = Poly_N_Expm1(x);
2067  // Calculation of the (N+1) Taylor coefficients
2068  lx_interval *Koff = new lx_interval[N+1];
2069  Koff[0] = 1.0;
2070  for (int k=1; k<=N; k++)
2071  Koff[k] = Koff[k-1]/(k+1);
2072  // Evaluation of the Taylor polynimial P_N(x) (Horner)
2073  res = Koff[N];
2074  for (int k=N-1; k>=0; k--)
2075  res = res*x + Koff[k];
2076  // Calculation of the absolute approximation error:
2077  Fak = 1.0;
2078  for (int k=1; k<=N+2; k++)
2079  Fak = Fak * k; // Fak = (N+2)!
2080  D = lx_interval( Sup(abs(x)) );
2081  D = (power(D,N+1)/Fak)/(1-D); // D: inclusion of the absolute
2082  // approximation error;
2083  S = Sup(D);
2084  res = res + lx_interval(-S,S); // Considering the approx. error;
2085  res = res * x;
2086  delete[] Koff;
2087  return res;
2088 }
2089 
2090 lx_interval EXPm1(const lx_interval &x) throw()
2091 // e^x - 1;
2092 // Only for internal use and for
2093 // not too wide intervals!
2094 {
2095  int stagsave = stagprec,
2096  stagmax = 40;
2097  lx_interval res;
2098  if (Sup(abs(x))<1e-7)
2099  res = Expm1(x);
2100  else
2101  {
2102  if (stagprec < stagmax) stagprec++;
2103  res = Exp_(x)-1;
2104  }
2105  stagprec = stagsave;
2106  res = adjust(res);
2107 
2108  return res;
2109 } // EXPm1(...)
2110 
2111 lx_interval expm1(const lx_interval &x) throw()
2112 // e^x - 1;
2113 {
2114  int stagsave = stagprec,
2115  stagmax = 40;
2116  if (stagprec > stagmax)
2117  stagprec = stagmax;
2118 
2119  lx_interval res,a;
2120  real r;
2121 
2122  r = expo_RelDiam(li_part(x));
2123  if (r > -107) // If the rel. diam of x is too great
2124  { // the expm1 function is calculated at the
2125  // boundary points of the interval x. Thus, due to
2126  // the monotony, the inclusion is given by:
2127  // res = [Inf(res),Sup(a)];
2128  res = lx_interval(Inf(x));
2129  res = EXPm1(res);
2130  a = lx_interval(Sup(x));
2131  a = EXPm1(a);
2132  res = lx_interval(Inf(res),Sup(a));
2133  }
2134  else
2135  res = EXPm1(x);
2136 
2137  stagprec = stagsave;
2138  res = adjust(res);
2139 
2140  return res;
2141 }
2142 
2143 // -------------------------- sin(...) --------------------------------------
2144 
2145 real 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 };
2149 // pot3_n[k] = 3^(k+1); k = 0,1,2, ... ,19;
2150 // pot3_n[0] = 3.0; ... pot3_n[19] = 3^20 = 3486784401.0;
2151 
2152  lx_interval Sin_Rek(const lx_interval &x, int n)
2153 // Only for internal use in sin-function.
2154  {
2155  lx_interval u,v;
2156  u = x;
2157  for (int k=1; k<=n; k++)
2158  { // Rekursion: u = u*(3-4*u^2);
2159  v = sqr(u);
2160  times2pown(v,2); // v = 4*sqr(u);
2161  u = u*(3-v);
2162  }
2163  return u;
2164  }
2165 
2166  int Poly_N_Sin(const lx_interval &x)
2167 // Calculation of the polynomial degee N:
2168 // Only for internal use in sin-function.
2169  {
2170  lx_interval absx(abs(x));
2171  int N(0),
2172  k;
2173  real S(-53*stagprec*ln_N[0]), // S: -53*(actual pecision)*ln(2);
2174  c,kr,D;
2175 
2176  k = expo_gr(li_part(absx));
2177  if (k>-1000000)
2178  { // x != 0
2179  kr = k + expo(absx);
2180  c = (2*kr)*ln_N[0];
2181  D = c - ln_N[4]; // D = D(0) = 2*kr*ln(2) - ln(3!);
2182  while (D > S)
2183  {
2184  N++;
2185  D = D + c - ln_N[2*N] - ln_N[2*N+1]; // Recursion formula
2186  }
2187  } // N=0 if x==0;
2188  return N;
2189  }
2190 
2191  l_real floor(const l_real &x)
2192 // Rounding to the next integer number z, with z <= x;
2193  {
2194  l_real y(x),z(0);
2195  int p(StagPrec(y)),k;
2196 
2197  y = y + 0; // Sorting the components.
2198 
2199  if (expo(y[1])>-1000000)
2200  // x != 0
2201  {
2202  k=1;
2203  while(expo(y[k])>=53 && k<=p)
2204  {
2205  z += y[k]; // Addition of the integer parts
2206  k++;
2207  }
2208  if (k<=p)
2209  z += std::floor(_double(y[k])); // Addition of the last
2210  } // floor part of y[k].
2211 
2212  return z;
2213  } // floor
2214 
2215  lx_interval sin(const lx_interval &x) throw()
2216 // Inclusion of sin(x)
2217 // Blomquist, 11.03.2008;
2218  {
2219  int stagsave = stagprec,
2220  stagmax = 39,
2221  n,N,exl;
2222  const real ln2 = 0.6931471806,
2223  ln10 = 2.302585093,
2224  ln3r = 0.9102392264, // 1/ln(3)
2225  MaxR = 1.71e308, // < MaxReal
2226  pi2 = 6.283185309; // pi2 > 2*pi
2227  l_interval xl;
2228  l_real m;
2229  real r,ex;
2230  interval z;
2231  bool bl(false);
2232 
2233  if (stagprec > stagmax)
2234  stagprec = stagmax;
2235 
2236  lx_interval res(0.0),T,Pi2;
2237  lx_real S,Si;
2238 
2239  if (Sup(abs(x))>MaxR)
2240  res = lx_interval(0,l_interval(-1,1));
2241  else
2242  if (diam(x)>pi2) // Pi2 > 2*pi;
2243  res = lx_interval(0,l_interval(-1,1));
2244  else // diam(x) <= 6.283185309 && Sup(abs(x)) <= MaxReal/1.05
2245  {
2246  ex = expo(x);
2247  exl = expo_gr(li_part(x));
2248  if (exl>-1000000)
2249  { // x != 0
2250  if (ex<-1080-exl) // sin(x) approx x
2251  if (0<=x)
2252  res = x;
2253  else
2254  if (Inf(x)>0)
2255  {
2256  Pi2 = lx_interval(Inf(x));
2257  T = Pi2 * One_m_lx_interval();
2258  res = lx_interval(Inf(T),Sup(x));
2259  }
2260  else
2261  {
2262  Pi2 = lx_interval(Sup(x));
2263  T = Pi2 * One_m_lx_interval();
2264  res = lx_interval(Inf(x),Sup(T));
2265  }
2266  else
2267  {
2268  xl = x;
2269  r = expo_RelDiam(li_part(x));
2270  if (r > -107) // If the rel. diam of x is too great
2271  { // the sin function is calculated using
2272  // the class l_interval
2273  xl = sin(xl);
2274  res = xl;
2275  }
2276  else
2277  {
2278  Pi2 = Pi_lx_interval();
2279  times2pown(Pi2,1); // Pi2 = 2*Pi
2280  m = floor( Inf(xl)/Inf(Pi2_l_interval()) );
2281  T = x - m*Pi2; // T: reduced argument
2282  xl = T; z = xl;
2283  if (diam(z)>Pi2_real)
2284  return lx_interval(0,l_interval(-1,1));
2285 
2286  r = expo( Sup(abs(z)) );
2287  n = (int) _double((r*ln2 + 8*ln10)*ln3r);
2288  // if (n<=0) then |z|<=10^(-8),
2289  // i.e. a second argument reduction is not necessary!
2290  // A second argument reduction exist <==> n>0.
2291  if (n>0)
2292  T = T / pot3_n[n-1]; // T = T / 3^n;
2293  // T is the reduced argument;
2294  N = Poly_N_Sin(T); // N: Polynomial degree;
2295 
2296  // Calculation of the N+1 polynomial coefficients
2297  // Koff[0], ... , Koff[N]:
2298  lx_interval *Koff = new lx_interval[N+1];
2299  Koff[0] = 1.0;
2300  for (int k=1; k<=N; k++)
2301  {
2302  m = 2*k;
2303  Koff[k] = -Koff[k-1]/(m*(m+1));
2304  }
2305  // Horner evaluation of the polynomial P_N(T^2):
2306  res = Koff[N]; Pi2 = sqr(T);
2307  for (int k=N-1; k>=0; k--)
2308  res = res*Pi2 + Koff[k];
2309  // Calculation of the absolute approximation error:
2310  Koff[0] = 1.0;
2311  for (int k=1; k<=N+1; k++)
2312  {
2313  m = 2*k;
2314  Koff[0] = Koff[0]*m*(m+1);
2315  } // Koff[0] = (2N+3)!
2316  Pi2 = lx_interval( Sup(abs(T)) );
2317  Pi2 = sqr(Pi2);
2318  Pi2 = power(Pi2,N+1)/Koff[0];
2319  // Pi2: Inclusion of the absolute approx. error
2320  S = Sup(Pi2);
2321  res = res + lx_interval(-S,S); // We now considered
2322  // the absolute approximation error of P_N(T^2).
2323  res = res*T; // res: Inclusion of sin(T/3^n)
2324  // Now calculating an inclusion of sin(T) using
2325  // the recurrence:
2326  res = Sin_Rek(res,n);
2327  delete[] Koff;
2328  }
2329  }
2330  }
2331  }
2332  stagprec = stagsave; // Restore the old stagprec value
2333  res = adjust(res);
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; }
2337  if (bl)
2338  res = lx_interval(Si,S);
2339  // Now -1 <= res <= +1 is guaranteed
2340 
2341  return res;
2342  } // sin()
2343 
2344  lx_interval sin_n(const lx_interval &x, const real& n) throw()
2345 // Inclusion of sin(n*Pi + x)
2346  {
2347  int stagsave = stagprec,
2348  stagmax = 39;
2349  if (stagprec > stagmax)
2350  stagprec = stagmax;
2351  lx_interval res;
2352 
2353  if ( !(Is_Integer(n)) )
2354  cxscthrow(REAL_NOT_ALLOWED("lx_interval sin_n(const lx_interval&, const real&)"));
2355 
2356  res = sin(x);
2357 // if (n%2 != 0) res = -res;
2358  if ( !(Is_Integer(n/2)) )
2359  res = -res;
2360 
2361  stagprec = stagsave; // Restore the old stagprec value
2362  res = adjust(res);
2363 
2364  return res;
2365  } // sin_n(...)
2366 
2367  lx_interval cos(const lx_interval &x) throw()
2368 // Inclusion of cos(x)
2369  {
2370  int stagsave = stagprec,
2371  stagmax = 39;
2372  if (stagprec > stagmax)
2373  stagprec = stagmax;
2374  lx_interval res;
2375  lx_real S,Si;
2376  bool bl(false);
2377 
2378  if (li_part(x)==0) res = 1.0;
2379  else
2380  {
2381  res = Pi_lx_interval();
2382  times2pown(res,-1); // res = Pi/2;
2383  res = x + res;
2384  res = sin(res);
2385  }
2386 
2387  stagprec = stagsave; // Restore the old stagprec value
2388  res = adjust(res);
2389 
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; }
2393  if (bl)
2394  res = lx_interval(Si,S);
2395  // Now -1 <= res <= +1 is realized
2396 
2397  return res;
2398  } // cos(...)
2399 
2400  lx_interval cos_n(const lx_interval &x, const real& n) throw()
2401 // Inclusion of cos((n+0.5)*Pi + x)
2402  {
2403  int stagsave = stagprec,
2404  stagmax = 39;
2405  if (stagprec > stagmax)
2406  stagprec = stagmax;
2407  lx_interval res;
2408 
2409  if ( !(Is_Integer(n)) )
2410  cxscthrow(REAL_NOT_ALLOWED("lx_interval cos_n(const lx_interval&, const real&)"));
2411  res = sin(x);
2412 // if (n%2 == 0) res = -res;
2413  if ( (Is_Integer(n/2)) )
2414  res = -res;
2415 
2416  stagprec = stagsave; // Restore the old stagprec value
2417  res = adjust(res);
2418 
2419  return res;
2420  } // cos_n(...)
2421 
2422  lx_interval tan(const lx_interval& x) throw()
2423  {
2424  lx_interval c,y;
2425 
2426  if (li_part(x) == 0)
2427  y = lx_interval(0,l_interval(0.0));
2428  else
2429  {
2430  c = cos(x);
2431  if (0.0 <= c)
2432  {
2433  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF("lx_interval tan(const lx_interval &x)"));
2434  }
2435  y = sin(x)/c;
2436  }
2437  return y;
2438  } // tan()
2439 
2440  lx_interval cot(const lx_interval & x) throw()
2441  {
2442  lx_interval s,y;
2443 
2444  s = sin(x);
2445  if (0.0 <= s)
2446  {
2447  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF("lx_interval cot(const lx_interval &x)"));
2448  }
2449  y = cos(x)/s;
2450 
2451  return y;
2452  } // cot()
2453 
2454  lx_interval sqrt1px2(const lx_interval &x) throw()
2455  { // Inclusion of sqrt(1+x^2)
2456  int ext,c(3210);
2457  real ex;
2458  lx_interval y(abs(x));
2459  ext = expo_gr(li_part(y));
2460  ex = expo(y);
2461 
2462  if (ext>-1000000 && ex>c)
2463  y = lx_interval(Inf(x),upper_bnd(Sup(x)));
2464  else
2465  if (ext<-1000000)
2466  y = lx_interval(0,l_interval(1));
2467  else // x != 0;
2468  y = (ex<-c)? 1.0 + lx_interval(lx_real(0),Sup(y)) : sqrt(1+sqr(y));
2469 
2470  return y;
2471  } // sqrt1px2()
2472 
2473  int Poly_N_Atan(const lx_interval &x)
2474 // Calculation of the polynomial degee N:
2475 // Only for the internal use in the Atan_-function.
2476  {
2477  lx_interval absx(abs(x));
2478  int N(0),
2479  ex;
2480  real S(-53*stagprec*ln_N[0]), // S: -53*(actual precision)*ln(2);
2481  c,D;
2482  ex = expo_gr(li_part(absx));
2483  if (ex>-1000000)
2484  { // x != 0
2485  D = ex + expo(absx); // Calculation of D is uncritical!
2486  c = D*ln_N[0];
2487  D = 2*D*ln_N[0] - ln_N[1]; // D = D(0) = 2ex*ln(2)-ln(3);
2488  while (D > S) {
2489  N++;
2490  D = (2*N+2)*c - ln_N[2*N+1];
2491  }
2492  } // N=0 if x==0;
2493  return N;
2494  } // Poly_N_Atan()
2495 
2496  lx_interval Atan_(const lx_interval &x) throw()
2497 // Inclusion of atan(x) for rather tight intervals x only!
2498 // Only for the internal use in atan(x)!
2499  {
2500  const int c(4);
2501  int exl, m(0), N;
2502  real ex(expo(x));
2503 
2504  lx_interval res(0.0),T,T2;
2505  l_interval xl(li_part(x));
2506  bool neg;
2507  lx_real Xl;
2508 
2509  exl = expo_gr(xl);
2510  if (exl>-100000)
2511  { // x != 0
2512  res = x;
2513  if ( abs(Inf(res))>lx_real(2092,8.567562) )
2514  {
2515  neg = Sup(xl)<0;
2516  res = Pi_lx_interval();
2517  times2pown(res,-1); // Pi/2 enclosed by res;
2518  if (neg) res = -res;
2519  }
2520  else
2521  if (ex<-1080-exl) // atan(x) approx x
2522  if (Inf(x)>0)
2523  {
2524  T2 = lx_interval(Inf(x));
2525  T = T2 * One_m_lx_interval();
2526  res = lx_interval(Inf(T),Sup(x));
2527  }
2528  else // Sup(x)<0, because x is a rather tight interval
2529  {
2530  T2 = lx_interval(Sup(x));
2531  T = T2 * One_m_lx_interval();
2532  res = lx_interval(Inf(x),Sup(T));
2533  }
2534  else
2535  { // Now with argument reduction (Rothmaier)
2536  ex = ex + exl;
2537  if (ex>1)
2538  m = (int) _double( (ln_N[0]+c*ln_N[8])/ln_N[0] );
2539  else
2540  if (ex>-10000)
2541  m = (int) _double((c*ln_N[8] + ex*ln_N[0])/ln_N[0]);
2542  T = x;
2543  // Now with m >= 0 transformations:
2544  for (int k=1; k<=m; k++)
2545  T = T /(1 + sqrt1px2(T)); // T: reduced argument
2546  // Now calculating the polynomial degree:
2547  N = Poly_N_Atan(T);
2548  // Calculation of the N+1 polynomial coefficients
2549  // Koff[0], ... , Koff[N]:
2550  lx_interval *Koff = new lx_interval[N+1];
2551  Koff[0] = 1.0;
2552  for (int k=1; k<=N; k++)
2553  {
2554  Koff[k] = lx_interval(0,l_interval(1))/ (2*k+1);
2555  if (k%2 != 0) Koff[k] = -Koff[k];
2556  }
2557  // Horner-evaluation of the polynomial P_N(T2):
2558  res = Koff[N];
2559  T2 = sqr(T);
2560  for (int k=N-1; k>=0; k--)
2561  res = res*T2 + Koff[k]; // res = P_N(T2)
2562  // Calculation of the absolute approximation error:
2563  T2 = lx_interval( Sup(abs(T)) );
2564  T2 = sqr(T2);
2565  T2 = power(T2,N+1)/(2*N+3);
2566  // T2: Inclusion of the absolute approximation error
2567  // Implementing the approximation error:
2568  Xl = Sup(T2);
2569  res += lx_interval(-Xl,Xl);
2570  res = T*res;
2571  if (m>0) times2pown(res,m);
2572  delete[] Koff;
2573  }
2574  }
2575 
2576  return res;
2577  } // Atan_()
2578 
2579  lx_interval atan(const lx_interval &x) throw()
2580  {
2581  int stagsave = stagprec,
2582  stagmax = 39;
2583 
2584  if (stagprec > stagmax)
2585  stagprec = stagmax;
2586 
2587  lx_interval res,a;
2588  real r;
2589 
2590  r = expo_RelDiam(li_part(x));
2591  if (r > -107) // If the rel. diam of x is too great
2592  { // the atan function is calculated at the
2593  // boundary points of the interval x. Thus, the
2594  // inclusion res is the convex hull of these intervals:
2595  res = lx_interval(Inf(x));
2596  res = Atan_(res);
2597  a = lx_interval(Sup(x));
2598  a = Atan_(a);
2599  res = lx_interval(Inf(res),Sup(a));
2600  }
2601  else
2602  res = Atan_(x);
2603 
2604  stagprec = stagsave;
2605  res = adjust(res);
2606 
2607  return res;
2608  } // atan()
2609 
2610 // ---------------------- sqrt(1-x^2) -----------------------------------
2611 
2612  lx_interval Sqrt1mx2_(const lx_interval &x) throw()
2613 // Inclusion of sqrt(1-x^2) for rather tight intervals x;
2614 // For the internal use only!!
2615 // Blomquist, 08.04.2008;
2616  {
2617  int exl;
2618 
2619  lx_interval res(1);
2620  l_interval li(li_part(x));
2621  real ex(expo(x));
2622 
2623  exl = expo_gr(li);
2624  if (exl>-100000)
2625  { // x != 0
2626  if (ex<=-2098-exl)
2627  { // Construction of the inclusion
2628  // interval [1 - 2^-2097,1], only possible if p>=2;
2629  res = lx_interval(-1023,l_interval(comp(0.5,1024)));
2630  li = li_part(res);
2631  li += 0; // To get the actual precision and sorting the li[k];
2632  li[StagPrec(li)] = -minreal; // minreal = 2^-1074;
2633  res = lx_interval(-1023,li);
2634  // res = 2^-1023*[2^1023 - 2^-1074,2^1023] = [1-2^-2097,1];
2635  }
2636  else
2637  res = (ex>=-exl)? sqrt( (1-x)*(1+x) ) : sqrt( 1-sqr(x) );
2638  }
2639  return res;
2640  } // Sqrt(1-x^2)
2641 
2642  lx_interval sqrt1mx2(const lx_interval &x) throw()
2643  {
2644  int stagsave = stagprec,
2645  stagmax = 39;
2646 
2647  if (stagprec > stagmax) stagprec = stagmax;
2648  if (stagprec==1) stagprec++; // stagprec >= 2;
2649 
2650  lx_interval res(abs(x)),a;
2651  real r;
2652 
2653  r = expo_RelDiam(li_part(res));
2654  if (r > -107) // If the rel. diam of x is too great
2655  { // the sqrt1mx2 function is calculated at the
2656  // boundary points of the interval x. Thus, the
2657  // inclusion res is the convex hull of these intervals:
2658  a = lx_interval(Inf(res));
2659  a = Sqrt1mx2_(a);
2660 
2661  res = lx_interval(Sup(res));
2662  res = Sqrt1mx2_(res);
2663 
2664  res = lx_interval(Inf(res),Sup(a));
2665  }
2666  else
2667  res = Sqrt1mx2_(res);
2668 
2669  stagprec = stagsave;
2670  res = adjust(res);
2671 
2672  return res;
2673  } // sqrt1mx2
2674 
2675 // ------------------- sqrt(x^2-1) ------------------------------------
2676 
2677  lx_interval sqrtx2m1(const lx_interval &x) throw()
2678 // Inclusion of sqrt(x^2-1)
2679 // Blomquist, 22.04.08;
2680  {
2681  int stagsave = stagprec,
2682  stagmax = 39;
2683  real ex(expo(x));
2684  if (stagprec>stagmax) stagprec = stagmax;
2685 
2686  lx_interval u(abs(x)),res;
2687  l_interval li(li_part(u));
2688  lx_real Infu(Inf(u));
2689 
2690  if (Infu < 1)
2691  {
2692  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF(
2693  "lx_interval sqrtx2m1(const lx_interval &x)"));
2694  }
2695  // Now: Inf(u) >= 1;
2696  if (ex > 1604-expo_gr(li))
2697  res = u + lx_interval(lx_real(-1),lx_real(0));
2698  else
2699  {
2700  res = sqrt( (u-1)*(u+1) );
2701  if (Inf(res)<=0 && Infu>1)
2702  {
2703  u = lx_interval(Infu);
2704  u = u + 1;
2705  times2pown(u,-2097);
2706  u = sqrt(u);
2707  res = lx_interval( Inf(u), Sup(res) );
2708  }
2709  }
2710 
2711  stagprec = stagsave;
2712  res = adjust(res);
2713 
2714  return res;
2715  } // sqrt(x^2-1)
2716 
2717 // ------------------- asin(x) ----------------------------------------
2718 
2719  lx_interval Asin_(const lx_interval& x) throw()
2720 // Inclusion of asin(x) for rather tight intervals x only!
2721 // Only for the internal use in asin(x)!
2722  {
2723  lx_interval y,pihalbe,h;
2724  bool neg;
2725 
2726  l_interval xl;
2727  interval z;
2728  xl = x;
2729  z = xl;
2730 
2731  real supabsz = Sup(abs(z)),
2732  infz = Inf(z),
2733  supz = Sup(z);
2734 
2735  pihalbe = Pi_lx_interval();
2736  times2pown(pihalbe,-1); // pihalbe = pi/2;
2737 
2738  if (infz == supz && supz == 0)
2739  y = 0;
2740  else
2741  if (infz == supz && supabsz == 1)
2742  {
2743  if (supz == 1.0)
2744  y = pihalbe;
2745  else y = -pihalbe;
2746  }
2747  else
2748  {
2749  if (0<=z)
2750  y = atan(x/sqrt1mx2(x));
2751  else
2752  {
2753  y = x;
2754  neg = Sup(z)<0;
2755  if (neg) y = -y;
2756  if (supabsz < 0.75)
2757  y = atan(y/sqrt1mx2(y));
2758  else
2759  y = pihalbe - atan(sqrt1mx2(y)/y);
2760  if (neg) y = -y;
2761  }
2762  }
2763 
2764  return y;
2765 } // Asin_(x)
2766 
2767  lx_interval asin(const lx_interval &x) throw()
2768  {
2769  int stagsave = stagprec,
2770  stagmax = 39;
2771 
2772  if (stagprec > stagmax)
2773  stagprec = stagmax;
2774 
2775  lx_interval res,a;
2776  real r;
2777 
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)"));
2781 
2782  r = expo_RelDiam(li_part(x));
2783  if (r > -107) // If the rel. diam of x is too great
2784  { // the asin function is calculated at the
2785  // boundary points of the interval x. Thus, the
2786  // inclusion res is the convex hull of these intervals:
2787  res = lx_interval(Inf(x));
2788  res = Asin_(res);
2789  a = lx_interval(Sup(x));
2790  a = Asin_(a);
2791  res = lx_interval(Inf(res),Sup(a));
2792  }
2793  else
2794  res = Asin_(x);
2795 
2796  stagprec = stagsave;
2797  res = adjust(res);
2798 
2799  return res;
2800  } // asin()
2801 
2802 // ------------------- acos(x) ----------------------------------------
2803 
2804  lx_interval Acos_(const lx_interval& x) throw()
2805 // Inclusion of acos(x) for rather tight intervals x only!
2806 // Only for the internal use in acos(x)!
2807 // Blomquist, 24.04.2008;
2808  {
2809  lx_interval y,pihalbe,pi;
2810  bool neg;
2811  l_interval xl;
2812  interval z;
2813 
2814  xl = x;
2815  z = xl;
2816 
2817  real supabsz = Sup(abs(z)),
2818  infz = Inf(z),
2819  supz = Sup(z);
2820 
2821  pi = Pi_lx_interval();
2822  pihalbe = pi;
2823  times2pown(pihalbe,-1); // pihalbe = pi/2;
2824 
2825  if (infz == supz && supz == 0)
2826  y = pihalbe;
2827  else
2828  if (infz == supz && supabsz == 1)
2829  {
2830  if (supz == 1.0)
2831  y = 0;
2832  else y = pi;
2833  }
2834  else
2835  {
2836  if (0<=z)
2837  y = pihalbe - atan(x/sqrt1mx2(x));
2838  else
2839  {
2840  y = x;
2841  neg = Sup(z)<0;
2842  if (neg) y = -y;
2843  if (supabsz < 0.25)
2844  y = pihalbe - atan(y/sqrt1mx2(y));
2845  else
2846  y = atan(sqrt1mx2(y)/y);
2847  if (neg) y = pi - y;
2848  }
2849  }
2850 
2851  return y;
2852 } // Acos_(x)
2853 
2854  lx_interval acos(const lx_interval &x) throw()
2855 // Blomquist, 24.04.2008;
2856  {
2857  int stagsave = stagprec,
2858  stagmax = 39;
2859 
2860  if (stagprec > stagmax)
2861  stagprec = stagmax;
2862 
2863  lx_interval res,a;
2864  real r;
2865 
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)"));
2869 
2870  r = expo_RelDiam(li_part(x));
2871  if (r > -107) // If the rel. diam of x is too great
2872  { // the acos function is calculated at the
2873  // boundary points of the interval x. Thus, the
2874  // inclusion res is the convex hull of these intervals:
2875  res = lx_interval(Inf(x));
2876  res = Acos_(res);
2877  a = lx_interval(Sup(x));
2878  a = Acos_(a);
2879  res = lx_interval(Inf(a),Sup(res));
2880  }
2881  else
2882  res = Acos_(x);
2883 
2884  stagprec = stagsave;
2885  res = adjust(res);
2886 
2887  return res;
2888  } // acos()
2889 
2890 
2891 // ------------------- acot(x) ----------------------------------------
2892 
2893  lx_interval Acot_(const lx_interval& x) throw()
2894 // codomain of acot(x): (0,pi);
2895 // acot(x) is continuous at x=0;
2896 // Blomquist, 25.04.2008;
2897  {
2898  int exl;
2899  real ex(expo(x));
2900  lx_interval y,pihalbe,pi;
2901  bool neg;
2902 
2903  l_interval xl(li_part(x));
2904  exl = expo_gr(xl);
2905 
2906  pi = Pi_lx_interval();
2907  pihalbe = pi;
2908  times2pown(pihalbe,-1); // pihalbe = pi/2;
2909 
2910  if (0<=xl)
2911  y = pihalbe - atan(x);
2912  else
2913  {
2914  y = x;
2915  neg = Sup(xl) < 0;
2916  if (neg) y = -y;
2917  if (ex<=-exl)
2918  if (ex<-exl-1580)
2919  y = pihalbe;
2920  else
2921  y = pihalbe - atan(y);
2922  else y = atan(1/y);
2923  if (neg) y = pi - y;
2924  }
2925 
2926  return y;
2927  } // Acot_(x)
2928 
2929  lx_interval acot(const lx_interval &x) throw()
2930 // Blomquist, 24.04.2008;
2931  {
2932  int stagsave = stagprec,
2933  stagmax = 39;
2934 
2935  if (stagprec > stagmax)
2936  stagprec = stagmax;
2937 
2938  lx_interval res,a;
2939  real r;
2940 
2941  r = expo_RelDiam(li_part(x));
2942  if (r > -107) // If the rel. diam of x is too great
2943  { // the acot function is calculated at the
2944  // boundary points of the interval x. Thus, the
2945  // inclusion res is the convex hull of these intervals:
2946  res = lx_interval(Inf(x));
2947  res = Acot_(res);
2948  a = lx_interval(Sup(x));
2949  a = Acot_(a);
2950  res = lx_interval(Inf(a),Sup(res));
2951  }
2952  else
2953  res = Acot_(x);
2954 
2955  stagprec = stagsave;
2956  res = adjust(res);
2957 
2958  return res;
2959  } // acot()
2960 
2961 // -------------------------- sinh(...) --------------------------------------
2962 
2963  lx_interval Sinh_(const lx_interval &x) throw()
2964 // Inclusion of sinh(x) for sufficiently tight intervals x
2965  {
2966  int exl;
2967  real ex;
2968  lx_interval res(0.0),T;
2969  l_interval xl(li_part(x));
2970  bool neg;
2971 
2972  ex = expo(x);
2973  exl = expo_gr(xl);
2974 
2975  if (0<=xl) // Null in x enthalten!
2976  {
2977  T = expm1(-x);
2978  res = -T*(1+1/(T+1));
2979  times2pown(res,-1);
2980  }
2981  else // Null ist nicht in x enthalten!
2982  if (ex<=-exl)
2983  { // |abs(x)| < 1;
2984  T = expm1(-x);
2985  res = -T*(1+1/(T+1));
2986  times2pown(res,-1);
2987  }
2988  else
2989  { // |abs(x)| >= 1;
2990  T = x;
2991  neg = Inf(xl)<0;
2992  if (neg) T = -T;
2993 
2994  if (ex>12-exl)
2995  {
2996  res = exp(T);
2997  times2pown(res,-1);
2998  res += l_interval(-0.5,0);
2999  }
3000  else
3001  {
3002  res = exp(T);
3003  res = res - 1/res;
3004  times2pown(res,-1);
3005  }
3006  if (neg) res = -res;
3007  }
3008 
3009  return res;
3010  } // Sinh_(...)
3011 
3012  lx_interval sinh(const lx_interval &x) throw()
3013  {
3014  int stagsave = stagprec,
3015  stagmax = 39;
3016 
3017  if (stagprec > stagmax)
3018  stagprec = stagmax;
3019 
3020  lx_interval res,a;
3021  real r;
3022 
3023  r = expo_RelDiam(li_part(x));
3024  if (r > -107) // If the rel. diam of x is too great
3025  { // the sinh function is calculated at the
3026  // boundary points of the interval x. Thus, the
3027  // inclusion res is the convex hull of these intervals:
3028  res = lx_interval(Inf(x));
3029  res = Sinh_(res);
3030  a = lx_interval(Sup(x));
3031  a = Sinh_(a);
3032  res = lx_interval(Inf(res),Sup(a));
3033  }
3034  else
3035  res = Sinh_(x);
3036 
3037  stagprec = stagsave;
3038  res = adjust(res);
3039 
3040  return res;
3041  } // sinh()
3042 
3043 // -------------------------- cosh(...) ------------------------------------
3044 
3045  lx_interval Cosh_(const lx_interval& x) throw()
3046 // codomain of cosh(x): [1,+infty);
3047 // This function is only used for tight intervals x,
3048 // with Inf(x)>=0;
3049 // Blomquist, 26.04.2008;
3050  {
3051  lx_interval y;
3052  lx_real Si;
3053  l_interval xl;
3054  interval z;
3055 
3056  xl = x;
3057  z = xl;
3058 
3059  y = exp(x);
3060  if (Inf(z)>4096)
3061  {
3062  times2pown(y,-1);
3063  y += l_interval(0,0.5);
3064  }
3065  else
3066  {
3067  y = y + 1/y;
3068  times2pown(y,-1);
3069  }
3070  Si = Inf(y);
3071  if (Si<1.0) y = lx_interval(lx_real(1.0),Sup(y));
3072 
3073  return y;
3074  } // Cosh_(x)
3075 
3076  lx_interval cosh(const lx_interval &x) throw()
3077  {
3078  int stagsave = stagprec,
3079  stagmax = 39;
3080 
3081  if (stagprec > stagmax)
3082  stagprec = stagmax;
3083 
3084  lx_interval res,a,y(abs(x));
3085  real r;
3086 
3087  r = expo_RelDiam(li_part(y));
3088  if (r > -107) // If the rel. diam of x is too great
3089  { // the cosh function is calculated at the
3090  // boundary points of the interval x. Thus, the
3091  // inclusion res is the convex hull of these intervals:
3092  res = lx_interval(Inf(y));
3093  res = Cosh_(res);
3094  a = lx_interval(Sup(y));
3095  a = Cosh_(a);
3096  res = lx_interval(Inf(res),Sup(a));
3097  }
3098  else
3099  res = Cosh_(y);
3100 
3101  stagprec = stagsave;
3102  res = adjust(res);
3103 
3104  return res;
3105  } // cosh()
3106 
3107 // -------------------------- tanh(...) ------------------------------------
3108 
3109  lx_interval Tanh_(const lx_interval& x) throw()
3110  {
3111 // Blomquist, 27.04.2008;
3112  int exl;
3113  real ex(expo(x));
3114  lx_interval y(x),t;
3115  lx_real Iy;
3116  bool neg;
3117  l_interval xl(li_part(x));
3118  exl = expo_gr(xl);
3119 
3120  if (0<=xl)
3121  {
3122  times2pown(y,1); // y = 2x;
3123  y = expm1(-y); // y = exp(-2x) - 1;
3124  y = -y/(2+y);
3125  }
3126  else
3127  { // 0 not included by x.
3128  if (ex<=-exl) // 0<|x|<1;
3129  {
3130  times2pown(y,1); // y = 2x;
3131  y = expm1(-y); // y = exp(-2x) - 1;
3132  y = -y/(2+y);
3133  }
3134  else
3135  { // |x| >= 1;
3136  neg = Sup(xl)<0;
3137  if (neg) y = -y; // Inf(y)>0, bzw. y = abs(x);
3138  Iy = Inf(y);
3139  ex = expo(Iy); exl = expo_gr(lr_part(Iy));
3140  if (ex >= -exl+13)
3141  y = lx_interval(Inf(One_m_lx_interval()),lx_real(1));
3142  else
3143  {
3144  times2pown(y,1); // y = 2x;
3145  y = exp(-y); // y = exp(-2x);
3146  y = (1-y) / (1+y);
3147  }
3148  if (neg) y = - y;
3149  }
3150  }
3151 
3152  return y;
3153  } // Tanh_(x)
3154 
3155  lx_interval tanh(const lx_interval &x) throw()
3156  {
3157  int stagsave = stagprec,
3158  stagmax = 39;
3159 
3160  if (stagprec > stagmax)
3161  stagprec = stagmax;
3162 
3163  lx_interval res,a;
3164  real r;
3165 
3166  r = expo_RelDiam(li_part(x));
3167  if (r > -107) // If the rel. diam of x is too great
3168  { // the tanh function is calculated at the
3169  // boundary points of the interval x. Thus, the
3170  // inclusion res is the convex hull of these intervals:
3171  res = lx_interval(Inf(x));
3172  res = Tanh_(res);
3173  a = lx_interval(Sup(x));
3174  a = Tanh_(a);
3175  res = lx_interval(Inf(res),Sup(a));
3176  }
3177  else
3178  res = Tanh_(x);
3179 
3180  stagprec = stagsave;
3181  res = adjust(res);
3182 
3183  return res;
3184  } // tanh()
3185 
3186 // -------------------------- coth(...) ------------------------------------
3187 
3188  lx_interval Coth_(const lx_interval& x) throw()
3189 // This function is only used for tight intervals x,
3190 // with Inf(x) > 0;
3191 // Blomquist, 27.04.2008;
3192  {
3193  int exl;
3194  lx_interval y(x);
3195  real ex(expo(x));
3196  lx_real Iy;
3197  l_interval xl(li_part(x));
3198 
3199  exl = expo_gr(xl);
3200 
3201  if (ex<=-exl) // 0<|x|<1;
3202  {
3203  times2pown(y,1); // y = 2x;
3204  y = expm1(-y); // y = exp(-2x) - 1;
3205  y = -(2+y)/y;
3206  }
3207  else
3208  { // |x| >= 1;
3209  Iy = Inf(y);
3210  ex = expo(Iy); exl = expo_gr(lr_part(Iy));
3211 
3212  if (ex>=-exl+13)
3213  y = lx_interval(lx_real(1),Sup(One_p_lx_interval()));
3214  else
3215  {
3216  times2pown(y,1); // y = 2x;
3217  y = exp(-y); // y = exp(-2x);
3218  y = (1+y) / (1-y);
3219  }
3220  }
3221 
3222  return y;
3223  } // coth(x)
3224 
3225  lx_interval coth(const lx_interval &x) throw()
3226 // Blomquist, 27.04.2008;
3227  {
3228  int stagsave = stagprec,
3229  stagmax = 39;
3230 
3231  if (stagprec > stagmax)
3232  stagprec = stagmax;
3233 
3234  l_interval xl(li_part(x));
3235  if (0<=xl)
3236  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3237  ("lx_interval coth(const lx_interval& x)"));
3238 
3239  lx_interval res,a,y(x);
3240  real r;
3241  bool neg(Sup(xl)<0);
3242 
3243  if (neg) y = -y; // Inf(y)>0;
3244 
3245  r = expo_RelDiam(xl);
3246  if (r > -107) // If the rel. diam of x is too great
3247  { // the coth function is calculated at the
3248  // boundary points of the interval x. Thus, the
3249  // inclusion res is the convex hull of these intervals:
3250  res = lx_interval(Inf(y));
3251  res = Coth_(res);
3252  a = lx_interval(Sup(y));
3253  a = Coth_(a);
3254  res = lx_interval(Inf(a),Sup(res));
3255  }
3256  else
3257  res = Coth_(y);
3258  if (neg) res = -res;
3259 
3260  stagprec = stagsave;
3261  res = adjust(res);
3262 
3263  return res;
3264  } // coth()
3265 
3266 // -------------------------- sqrt(1+x)-1 ------------------------------------
3267 
3268  lx_interval Sqrtp1m1_(const lx_interval& x) throw()
3269 // sqrtp1m1(x) calculates an inclusion of sqrt(x+1)-1;
3270 // Blomquist, 25.08.07;
3271  {
3272  int exl;
3273  lx_interval y(0),tmp;
3274  l_interval xl(li_part(x));
3275  interval z;
3276  real ex(expo(x));
3277  const real c = 0.1;
3278 
3279  exl = expo_gr(xl);
3280  if (exl>-1000000) // x != 0;
3281  {
3282  if (ex>-exl+500)
3283  y = sqrt(1+x) - 1;
3284  else
3285  {
3286  xl = x; // xl is an inclusion of x,
3287  z = xl; // and z is an inclusion of x;
3288  tmp = x+1;
3289  y = (z<=interval(-c,c))? x/(sqrt(tmp)+1) : sqrt(tmp)-1;
3290  }
3291  }
3292 
3293  return y;
3294  } // Sqrtp1m1_
3295 
3296  lx_interval sqrtp1m1(const lx_interval &x) throw()
3297  {
3298  int stagsave = stagprec,
3299  stagmax = 30;
3300 
3301  stagprec++;
3302  if (stagprec>stagmax) stagprec = stagmax;
3303 
3304  lx_interval res,a;
3305  real r;
3306 
3307  r = expo_RelDiam(li_part(x));
3308  if (r > -107) // If the rel. diam of x is too great
3309  { // the sqrtp1m1 function is calculated at the
3310  // boundary points of the interval x. Thus, the
3311  // inclusion res is the convex hull of these intervals:
3312  res = lx_interval(Inf(x));
3313  res = Sqrtp1m1_(res);
3314  a = lx_interval(Sup(x));
3315  a = Sqrtp1m1_(a);
3316  res = lx_interval(Inf(res),Sup(a));
3317  }
3318  else
3319  res = Sqrtp1m1_(x);
3320 
3321  stagprec = stagsave;
3322  res = adjust(res);
3323 
3324  return res;
3325  } // sqrtp1m1()
3326 
3327 
3328 // -------------------------- asinh(x) ------------------------------------
3329 
3330  lx_interval Asinh_(const lx_interval &x) throw()
3331 // Inclusion of asinh(x)
3332  {
3333  int exl;
3334  lx_interval res,u;
3335  lx_real S1,S2;
3336  l_interval xl(li_part(x));
3337  interval z;
3338  real ex;
3339  bool neg;
3340 
3341  ex = expo(x);
3342  exl = expo_gr(xl);
3343 
3344  if (0<=xl) // Null in x enthalten!
3345  {
3346  xl = x; // Falls hier Fehlermeldung, ist das OK,
3347  z = xl; // denn sonst ist x viel zu breit!!
3348  res = asinh(z); // Bis hier OK!!!
3349  }
3350  else // Null ist nicht in x enthalten!
3351  {
3352  neg = (Inf(xl)<0);
3353  u = (neg)? -x : x; // Inf(u)>0
3354  if (ex<=-exl-790)
3355  {
3356  std::cout << "Hallo: (1-u)*(1+u)*res" << std::endl;
3357  res = u;
3358  S2 = Sup(res);
3359  S1 = Inf( (1-u)*(1+u)*res );
3360  res = lx_interval(S1,S2);
3361  }
3362  else
3363  res = (ex<=-exl)? lnp1(u+sqrtp1m1(sqr(u))) : ln(u+sqrt1px2(u));
3364 
3365  if (neg) res = -res;
3366  }
3367 
3368  return res;
3369  } // Asinh_(...)
3370 
3371  lx_interval asinh(const lx_interval &x) throw()
3372  {
3373  int stagsave = stagprec,
3374  stagmax = 39;
3375  if (stagprec>stagmax)
3376  stagprec = stagmax;
3377 
3378  lx_interval res,a;
3379  real r;
3380 
3381  r = expo_RelDiam(li_part(x));
3382  if (r > -107) // If the rel. diam of x is too great
3383  { // the asinh function is calculated at the
3384  // boundary points of the interval x. Thus, the
3385  // inclusion res is the convex hull of these intervals:
3386  res = lx_interval(Inf(x));
3387  res = Asinh_(res);
3388  a = lx_interval(Sup(x));
3389  a = Asinh_(a);
3390  res = lx_interval(Inf(res),Sup(a));
3391  }
3392  else
3393  res = Asinh_(x);
3394  stagprec = stagsave;
3395  res = adjust(res);
3396 
3397  return res;
3398  } // asinh()
3399 
3400 // -------------------------- acosh(...) -------------------------------
3401 
3402  lx_interval acosh(const lx_interval &x) throw()
3403 // Inclusion of acosh(x)
3404  {
3405  int stagsave = stagprec,
3406  stagmax = 39,
3407  exl;
3408  if (stagprec > stagmax)
3409  stagprec = stagmax;
3410  lx_interval res(0.0),x_1;
3411  lx_real S1,S2;
3412  real ex;
3413 
3414  if (Inf(x)<1)
3415  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3416  ("lx_interval acosh(const lx_interval& x)"));
3417  x_1 = x-1;
3418  ex = expo(x_1);
3419  l_interval x_1l(li_part(x_1));
3420  exl = expo_gr(x_1l);
3421 
3422  if (exl>-100000) // x != [0,0]
3423  {
3424  if (ex <= -exl-1600)
3425  {
3426  res = x;
3427  times2pown(res,1); // res = 2x;
3428  res = sqrt(res - 2); // res = sqrt(2x - 2);
3429  S2 = Sup(res);
3430  res = res * (2-x); // Dieser Trick spart Division durch 12 !!
3431  S1 = Inf(res);
3432  res = lx_interval(S1,S2);
3433  }
3434  else
3435  res = (ex<=-exl)? lnp1( x_1 + sqrt(x_1*(2+x_1)) ) :
3436  ln( x+sqrtx2m1(x) );
3437  }
3438  stagprec = stagsave; // Restore the old stagprec value
3439  res = adjust(res);
3440 
3441  return res;
3442  } // acosh(...)
3443 
3444 // ------------------------- acoshp1(...) -----------------------------
3445 
3446  lx_interval Acoshp1_(const lx_interval &x) throw()
3447 // This function is only used for tight intervals x,
3448 // with Inf(x) >= 0;
3449 // Blomquist, 03.05.2008;
3450  {
3451  int exl;
3452  lx_interval res(0.0);
3453  lx_real S1,S2;
3454  real ex;
3455 
3456  ex = expo(x);
3457  l_interval xl(li_part(x));
3458  exl = expo_gr(xl);
3459 
3460  if (exl>-100000) {
3461  if (ex <= -exl-1600)
3462  {
3463  res = x;
3464  times2pown(res,1); // res = 2x;
3465  res = sqrt(res); // res = sqrt(2x);
3466  S2 = Sup(res);
3467  res = res * (1-x);
3468  S1 = Inf(res);
3469  res = lx_interval(S1,S2);
3470  }
3471  else
3472  if (ex <= -exl)
3473  res = lnp1( x + sqrt(x*(2+x)) );
3474  else // res = acosh(1+x);
3475  {
3476  res = 1+x;
3477  res = ln(res + sqrtx2m1(res));
3478  }
3479  }
3480  return res;
3481  } // Acoshp1_(...)
3482 
3483  lx_interval acoshp1(const lx_interval &x) throw()
3484 // Inclusion of acosh(1+x);
3485 // Blomquist, 03.05.2008;
3486  {
3487  int stagsave = stagprec,
3488  stagmax = 39;
3489  if (stagprec>stagmax)
3490  stagprec = stagmax;
3491  l_interval lix(li_part(x));
3492  if (Inf(lix)<0)
3493  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3494  ("lx_interval acoshp1(const lx_interval& x)"));
3495  lx_interval res,a;
3496  real r;
3497 
3498  r = expo_RelDiam(lix);
3499  if (r > -107) // If the rel. diam of x is too great
3500  { // the acoshp1 function is calculated at the
3501  // boundary points of the interval x. Thus, the
3502  // inclusion res is the convex hull of these intervals:
3503  res = lx_interval(Inf(x));
3504  res = Acoshp1_(res);
3505  a = lx_interval(Sup(x));
3506  a = Acoshp1_(a);
3507  res = lx_interval(Inf(res),Sup(a));
3508  }
3509  else
3510  res = Acoshp1_(x);
3511 
3512  stagprec = stagsave;
3513  res = adjust(res);
3514 
3515  return res;
3516  } // acoshp1()
3517 
3518 // ------------------------ atanh(...) ----------------------------------
3519 
3520  lx_interval Atanh_(const lx_interval &x) throw()
3521 // Inclusion of atanh(x) only for sufficiently small
3522 // intervals x. Only for the internal use!
3523 // Blomquist, 03.05.2008;
3524  {
3525  int exl;
3526  lx_interval res(0.0);
3527  real ex(expo(x));
3528  l_interval xl(li_part(x));
3529 
3530  exl = expo_gr(xl);
3531 
3532  if (0<=xl) // Zero included by x
3533  {
3534  res = x/(1-x);
3535  times2pown(res,1);
3536  res = lnp1(res);
3537  }
3538  else // Zero not included by x!
3539  if (ex <= -2 - exl)
3540  {
3541  res = x/(1-x);
3542  times2pown(res,1);
3543  res = lnp1(res);
3544  }
3545  else
3546  res = ln( (1.0+x)/(1.0-x) );
3547  times2pown(res,-1);
3548 
3549  res = adjust(res);
3550 
3551  return res;
3552  } // Atanh_(...)
3553 
3554  lx_interval atanh(const lx_interval &x) throw()
3555  {
3556  int stagsave = stagprec,
3557  stagmax = 39;
3558  if (stagprec>stagmax)
3559  stagprec = stagmax;
3560 
3561  lx_interval res,a;
3562  real r;
3563 
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)"));
3567 
3568  r = expo_RelDiam(li_part(x));
3569  if (r > -107) // If the rel. diam of x is too great
3570  { // the asinh function is calculated at the
3571  // boundary points of the interval x. Thus, the
3572  // inclusion res is the convex hull of these intervals:
3573  res = lx_interval(Inf(x));
3574  res = Atanh_(res);
3575  a = lx_interval(Sup(x));
3576  a = Atanh_(a);
3577  res = lx_interval(Inf(res),Sup(a));
3578  }
3579  else
3580  res = Atanh_(x);
3581 
3582  stagprec = stagsave;
3583  res = adjust(res);
3584 
3585  return res;
3586  } // atanh()
3587 
3588 // ------------------------ atanh1m(...) ---------------------------------
3589 
3590  lx_interval Atanh1m_(const lx_interval &x) throw()
3591 // Inclusion of atanh(1-x); 0<x<2;
3592 // Only for not too wide intervals x;
3593 // For the internal use only!
3594 // Blomquist, 07.05.2008;
3595  {
3596  lx_interval res(0.0);
3597  res = ln(2/x-1);
3598  times2pown(res,-1);
3599 
3600  return res;
3601  } // Atanh1m_(...)
3602 
3603  lx_interval atanh1m(const lx_interval &x) throw()
3604 // Blomquist, 07.05.2008;
3605  {
3606  int stagsave = stagprec,
3607  stagmax = 39;
3608  if (stagprec > stagmax)
3609  stagprec = stagmax;
3610 
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)"));
3614 
3615  lx_interval res,a;
3616  real r;
3617 
3618  r = expo_RelDiam(li_part(x));
3619  if (r > -107) // If the rel. diam of x is too great
3620  { // the acot function is calculated at the
3621  // boundary points of the interval x. Thus, the
3622  // inclusion res is the convex hull of these intervals:
3623  res = lx_interval(Inf(x));
3624  res = Atanh1m_(res);
3625  a = lx_interval(Sup(x));
3626  a = Atanh1m_(a);
3627  res = lx_interval(Inf(a),Sup(res));
3628  }
3629  else
3630  res = Atanh1m_(x);
3631 
3632  stagprec = stagsave;
3633  res = adjust(res);
3634 
3635  return res;
3636  } // atanh1m()
3637 
3638 // ------------------------ atanhm1p(...) ------------------------------
3639 
3640  lx_interval atanhm1p(const lx_interval &x) throw()
3641 // Inclusion of atanh(-1+x) , 0<x<2;
3642  {
3643  int stagsave = stagprec,
3644  stagmax = 39;
3645  if (stagprec > stagmax)
3646  stagprec = stagmax;
3647  lx_interval res;
3648 
3649  res = -atanh1m(x);
3650 
3651  stagprec = stagsave; // Restore the old stagprec value
3652  res = adjust(res);
3653 
3654  return res;
3655  } // atanhm1p
3656 
3657 // ------------------------ acoth(...) ---------------------------------
3658 
3659  lx_interval Acoth_(const lx_interval& x) throw()
3660 // acoth(x), x=[x1,x2], x1>1; Calculating
3661 // inclusions only for not too wide intervals;
3662 // Only for the internal use in acoth(x) !
3663 // Blomquist, 13.05.2008;
3664  {
3665  lx_interval res;
3666 
3667  res = lnp1(2/(x-1));
3668  times2pown(res,-1);
3669 
3670  return res;
3671  } // Acoth_
3672 
3673  lx_interval acoth(const lx_interval &x) throw()
3674 // Blomquist, 13.05.2008;
3675  {
3676  int stagsave = stagprec,
3677  stagmax = 39;
3678  if (stagprec > stagmax) stagprec = stagmax;
3679 
3680  lx_interval res,a,u;
3681  l_interval xl(li_part(x));
3682  bool neg;
3683  real r;
3684 
3685  res = lx_interval(0,l_interval(-1,1));
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)"));
3689  neg = Inf(xl)<0;
3690  if (neg) u = -x;
3691  else u = x; // u = [u1,u2], u1 > 1;
3692 
3693  r = expo_RelDiam(xl);
3694  if (r > -107) // If the rel. diam of x is too great
3695  { // the acoth function is calculated at the
3696  // boundary points of the interval x. Thus, the
3697  // inclusion res is the convex hull of these intervals:
3698  res = lx_interval(Inf(u));
3699  res = Acoth_(res);
3700  a = lx_interval(Sup(u));
3701  a = Acoth_(a);
3702  res = lx_interval(Inf(a),Sup(res));
3703  }
3704  else
3705  res = Acoth_(u);
3706  if (neg) res = -res;
3707 
3708  stagprec = stagsave;
3709  res = adjust(res);
3710 
3711  return res;
3712  } // acoth()
3713 
3714 // ------------------------ acoth(1+x) ---------------------------------
3715 
3716  lx_interval Acothp1_(const lx_interval& x) throw()
3717 // arcoth(1+x), x>0;
3718 // only for not too wide intervals x and
3719 // only for the internal use in acothp1(...)
3720 // Blomquist, 14.05.2008;
3721  {
3722  lx_interval res;
3723 
3724  res = lnp1(2/x);
3725  times2pown(res,-1);
3726 
3727  return res;
3728  } // Acothp1_
3729 
3730  lx_interval acothp1(const lx_interval &x) throw()
3731 // Blomquist, 14.05.2008;
3732  {
3733  int stagsave = stagprec,
3734  stagmax = 39;
3735 
3736  if (stagprec > stagmax)
3737  stagprec = stagmax;
3738 
3739  lx_interval res,a;
3740  l_interval xl(li_part(x));
3741  real r;
3742 
3743  if (Inf(xl) <= 0.0)
3744  cxscthrow(ERROR_LINTERVAL_STD_FKT_OUT_OF_DEF
3745  ("lx_interval acothp1(const lx_interval& x)"));
3746 
3747  r = expo_RelDiam(xl);
3748  if (r > -107) // If the rel. diam of x is too great
3749  { // the acot function is calculated at the
3750  // boundary points of the interval x. Thus, the
3751  // inclusion res is the convex hull of these intervals:
3752  res = lx_interval(Inf(x));
3753  res = Acothp1_(res);
3754  a = lx_interval(Sup(x));
3755  a = Acothp1_(a);
3756  res = lx_interval(Inf(a),Sup(res));
3757  }
3758  else
3759  res = Acothp1_(x);
3760 
3761  stagprec = stagsave;
3762  res = adjust(res);
3763 
3764  return res;
3765  } // acothp1()
3766 
3767 // ------------------------ acothm1m(...) ------------------------------
3768 
3769  lx_interval acothm1m(const lx_interval &x) throw()
3770 // Inclusion of acoth(-1-x) , x>0;
3771  {
3772  int stagsave = stagprec,
3773  stagmax = 39;
3774  if (stagprec > stagmax)
3775  stagprec = stagmax;
3776  lx_interval res;
3777 
3778  res = -acothp1(x);
3779 
3780  stagprec = stagsave; // Restore the old stagprec value
3781  res = adjust(res);
3782 
3783  return res;
3784  } // acothm1m
3785 
3786 // ------------------------ sqrt(x^2+y^2) ------------------------------
3787 
3788  lx_interval Sqrtx2y2_(const lx_interval &x, const lx_interval &y) throw()
3789 // Inclusion of sqrt(x^2+y^2);
3790 // x = [x1,x2], x1>=0; y = [y1,y2], y1>=0; x2>=y2;
3791 // For not too wide intervals x,y;
3792 // Blomquist, 15.05.2008;
3793  {
3794  const int c1=4000,
3795  c2=-100000;
3796  int exxl,exyl;
3797  real exx,exy;
3798  lx_interval res,ax,ay;
3799  lx_real R;
3800  R = Sup(y);
3801  exy = expo(R);
3802  exyl = expo_gr( lr_part(R) );
3803 
3804  R = Inf(x);
3805  exx = expo(R);
3806  exxl = expo_gr( lr_part(R) );
3807 
3808  if (exyl > c2) // y2 > 0;
3809  {
3810  exxl = exxl-exyl-1051; // Without integer-Overflow
3811  if (exy < exx + (exxl-1)) // (exxl-1) for security
3812  res = x * lx_interval(lx_real(1.0),Sup(One_p_lx_interval()));
3813  else
3814  {
3815  res = x;
3816  ax = x; ay = y;
3817  if (exx<-9007199254735000.0)
3818  {
3819  times2pown(ax,c1);
3820  times2pown(ay,c1);
3821  };
3822  res = res * sqrt1px2(ay/ax);
3823  }
3824  }
3825  else // y2 = 0;
3826  res = x;
3827 
3828  return res;
3829  } // Sqrtx2y2_(...)
3830 
3831  lx_interval sqrtx2y2(const lx_interval &x, const lx_interval &y) throw()
3832  {
3833  int stagsave = stagprec,
3834  stagmax = 30,
3835  exyl,exxl;
3836  if (stagprec>stagmax)
3837  stagprec = stagmax;
3838 
3839  const int c1=4000,
3840  c2=-100000;
3841  lx_interval res,ax,ay,u,v;
3842  lx_real R;
3843  real rx,ry;
3844 
3845  ax = abs(x); ay = abs(y);
3846  if ( Sup(ay) > Sup(ax) )
3847  {
3848  res = ax; ax = ay; ay = res;
3849  } // Sup(ax) >= Sup(ay);
3850 
3851  if (0<=ax) // 0 is included by ax
3852  // The inclusion res is calculated as the convex hull
3853  // of the inclusions at the boundary bounds of ax,ay.
3854  {
3855  // Inclusion of the upper bound:
3856  R = Sup(ay);
3857  v = lx_interval(R);
3858  ry = expo(R);
3859  exyl = expo_gr( lr_part(R) );
3860 
3861  R = Sup(ax);
3862  u = lx_interval(R);
3863  rx = expo(R);
3864  exxl = expo_gr( lr_part(R) );
3865 
3866  if (exyl>c2)
3867  {
3868  exxl = exxl-exyl-1051; // Without integer overflow
3869  if (ry < rx + (exxl-1)) // (exxl-1) for security
3870  res = u * lx_interval(lx_real(1.0),Sup(One_p_lx_interval()));
3871  else
3872  {
3873  res = u;
3874  if (rx < -9007199254735000.0)
3875  {
3876  times2pown(u,c1);
3877  times2pown(v,c1);
3878  }
3879  res = res * sqrt1px2(v/u);
3880  }
3881  }
3882  else // v=0;
3883  res = u;
3884  // res is the inclusion of the function value
3885  // at the upper bounds of ax,ay;
3886  // Remember: Inf(ax)=0, so Inf(ay) is the lower bound
3887  // of the function value at the lower bounds of ax,ay;
3888  // Thus, the inclusion of sqrt(ax^2 + ay^2) is given by:
3889  res = lx_interval(Inf(ay),Sup(res));
3890  }
3891  else // Inf(ax)>0:
3892  {
3893  rx = expo_RelDiam(li_part(ax));
3894  ry = expo_RelDiam(li_part(ay));
3895  if (rx > -107 || ry > -107) // If the rel. diam of ax or ay
3896  { // is too great the sqrtx2y2 function is calculated at
3897  // the boundary points of the intervals ax, ay. Thus, the
3898  // inclusion res is the convex hull of these intervals:
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));
3904  u = Sqrtx2y2_(u,v);
3905  res = lx_interval(Inf(res),Sup(u));
3906  }
3907  else
3908  res = Sqrtx2y2_(ax,ay);
3909  }
3910 
3911  stagprec = stagsave;
3912  res = adjust(res);
3913  return res;
3914  } // sqrtx2y2
3915 
3916 // ---------------------- ln(sqrt(x^2+y^2)) ----------------------------
3917 
3918  lx_interval Ln_sqrtx2y2_(const lx_interval &x, const lx_interval &y) throw()
3919 // Inclusion of ln(sqrt(x^2+y^2));
3920 // Blomquist, 19.05.2008;
3921  {
3922  lx_interval res,ax,ay;
3923  lx_real Rx,Ry;
3924 
3925  ax = abs(x); ay = abs(y);
3926  Rx = Sup(ax); Ry = Sup(ay);
3927  if (Ry>Rx)
3928  {
3929  Rx = Ry; // Rx ist maximaler Wert
3930  res = ay; ay = ax; ax = res; // ax ist maximaler Wert
3931  }
3932 
3933  if (Rx>100) res = ln( sqrtx2y2(ax,ay) );
3934  else
3935  if (Rx<0.25)
3936  res = ln( sqrtx2y2(ax,ay) );
3937  else
3938  {
3939  // Calculating: 0.5*ln(x*x + y*y)
3940  // = 0.5*ln(1 + (x*x + y*y - 1))
3941  // = 0.5*ln(1 + ((x-1)*(x+1) + y*y))
3942  if (ay==0.0)
3943  res = ln(ax); // Without Overflow!
3944  else
3945  {
3946  res = lnp1((ax-1)*(ax+1) + ay*ay);
3947  times2pown(res,-1);
3948  }
3949  }
3950 
3951  return res;
3952  } // Ln_sqrtx2y2_(...)
3953 
3954  lx_interval ln_sqrtx2y2(const lx_interval &x, const lx_interval &y) throw()
3955  {
3956  int stagsave = stagprec,
3957  stagmax = 30;
3958  if (stagprec>stagmax) stagprec = stagmax;
3959 
3960  lx_interval res,ax,ay,u,v;
3961  real rx,ry;
3962 
3963  ax = abs(x); ay = abs(y);
3964  if ( Sup(ay) > Sup(ax) )
3965  {
3966  res = ax; ax = ay; ay = res;
3967  } // Sup(ax) >= Sup(ay);
3968 
3969  rx = expo_RelDiam(li_part(ax));
3970  ry = expo_RelDiam(li_part(ay));
3971  if (rx > -107 || ry > -107) // If the rel. diam of ax or ay
3972  { // is too great the ln_sqrtx2y2 function is calculated at
3973  // the boundary points of the intervals ax, ay. Thus, the
3974  // inclusion res is the convex hull of these intervals:
3975  u = lx_interval(Inf(ax));
3976  v = lx_interval(Inf(ay));
3977  res = Ln_sqrtx2y2_(u,v);
3978 
3979  u = lx_interval(Sup(ax));
3980  v = lx_interval(Sup(ay));
3981  u = Ln_sqrtx2y2_(u,v);
3982 
3983  res = lx_interval(Inf(res),Sup(u));
3984  }
3985  else
3986  res = Ln_sqrtx2y2_(ax,ay);
3987 
3988  stagprec = stagsave;
3989  res = adjust(res);
3990 
3991  return res;
3992  } // ln_sqrtx2y2
3993 
3994 // -------------------------- n-th root --------------------------------
3995 
3996  lx_interval Sqrt_(const lx_interval& x, int n) throw()
3997  { // Inclusion of the n-th root, based on the pow(...) function
3998  // n>=2; For not too wide intervals x;
3999  // and for the internal use in sqrt(x,n) only!
4000  // Blomquist, 20.05.2008;
4001  lx_interval res;
4002  lx_real Sx;
4003 
4004  if (eq_zero(Inf(x)))
4005  {
4006  Sx = Sup(x);
4007  if (gr_zero(Sx))
4008  {
4009  res = pow(lx_interval(Sx),1/lx_interval(n));
4010  res = lx_interval(lx_real(0),Sup(res));
4011  }
4012  else res = 0.0;
4013  }
4014  else
4015  res = pow(x,1/lx_interval(n));
4016 
4017  return res;
4018  } // Sqrt_(...)
4019 
4020  lx_interval sqrt(const lx_interval &x, int n) throw()
4021  {
4022  int stagsave = stagprec,
4023  stagmax = 39,
4024  k(n);
4025  if (stagprec>stagmax) stagprec = stagmax;
4026 
4027  lx_interval res,a;
4028  real r;
4029 
4030  if (k<2) k=2;
4031 
4032  r = expo_RelDiam(li_part(x));
4033  if (r > -107) // If the rel. diam of x is too great
4034  { // the sqrt(x,n) function is calculated at the
4035  // boundary points of the interval x. Thus, the
4036  // inclusion res is the convex hull of these intervals:
4037  res = lx_interval(Inf(x));
4038  res = Sqrt_(res,k);
4039  a = lx_interval(Sup(x));
4040  a = Sqrt_(a,k);
4041  res = lx_interval(Inf(res),Sup(a));
4042  }
4043  else
4044  res = Sqrt_(x,k);
4045 
4046  stagprec = stagsave;
4047  res = adjust(res);
4048 
4049  return res;
4050  } // sqrt()
4051 
4052 
4053 // ---------------- Interval constants in high accuracy --------------------
4054 
4055  static real CXSC_Pi[40]; // CXSC_Pi[0], ... ,CXSC_Pi[39]
4056  static bool CXSC_Pi_initialized = false;
4057 
4058  lx_interval Pi_lx_interval() throw()
4059 // Inclusion of Pi, Blomquist, 15.06.2007;
4060  {
4061  l_interval y;
4062  int stagsave = stagprec,
4063  stagmax = 39; // alt
4064  if (!CXSC_Pi_initialized)
4065  {
4066  std::string str;
4067  std::cout << SaveOpt;
4068  std::cout << Hex;
4069  str = "+1921FB54442D18e7FC";
4070  str >> CXSC_Pi[0];
4071  str = "+11A62633145C07e7C6";
4072  str >> CXSC_Pi[1];
4073  str = "-1F1976B7ED8FBCe78E";
4074  str >> CXSC_Pi[2];
4075  str = "+14CF98E804177De758";
4076  str >> CXSC_Pi[3];
4077  str = "+131D89CD9128A5e722";
4078  str >> CXSC_Pi[4];
4079  str = "+10F31C6809BBDFe6E8";
4080  str >> CXSC_Pi[5];
4081  str = "+1519B3CD3A431Be6B1";
4082  str >> CXSC_Pi[6];
4083  str = "+18158536F92F8Ae67A";
4084  str >> CXSC_Pi[7];
4085  str = "+1BA7F09AB6B6A9e642";
4086  str >> CXSC_Pi[8];
4087  str = "-1EDD0DBD2544CFe60A";
4088  str >> CXSC_Pi[9];
4089  str = "+179FB1BD1310BAe5D3";
4090  str >> CXSC_Pi[10];
4091  str = "+1A637ED6B0BFF6e59D";
4092  str >> CXSC_Pi[11];
4093  str = "-1A485FCA40908Ee566";
4094  str >> CXSC_Pi[12];
4095  str = "-1E501295D98169e52F";
4096  str >> CXSC_Pi[13];
4097  str = "-1160DBEE83B4E0e4F9";
4098  str >> CXSC_Pi[14];
4099  str = "-19B6D799AE131Ce4C1";
4100  str >> CXSC_Pi[15];
4101  str = "+16CF70801F2E28e48B";
4102  str >> CXSC_Pi[16];
4103  str = "+163BF0598DA483e455";
4104  str >> CXSC_Pi[17];
4105  str = "+1871574E69A459e41F";
4106  str >> CXSC_Pi[18];
4107  str = "-15C0B6CC281F27e3E3";
4108  str >> CXSC_Pi[19];
4109  str = "+15D23DCA3AD962e3AD";
4110  str >> CXSC_Pi[20];
4111  str = "-1CE8654EFBD56Ae376";
4112  str >> CXSC_Pi[21];
4113  str = "-1184AB5BE23DA6e33F";
4114  str >> CXSC_Pi[22];
4115  str = "+166D670C354E4Be309";
4116  str >> CXSC_Pi[23];
4117  str = "-10D9FEC3A2E4FEe2D3";
4118  str >> CXSC_Pi[24];
4119  str = "+1943042F86520Ce29C";
4120  str >> CXSC_Pi[25];
4121  str = "-1B9D1C931C41C6e265";
4122  str >> CXSC_Pi[26];
4123  str = "-188D3E7F179FC6e22D";
4124  str >> CXSC_Pi[27];
4125  str = "-1361F1744FE176e1F7";
4126  str >> CXSC_Pi[28];
4127  str = "+1F6B8ABBE0DE99e1C0";
4128  str >> CXSC_Pi[29];
4129  str = "-169B10EA1A04B5e18A";
4130  str >> CXSC_Pi[30];
4131  str = "-14FD1CF8CD56D0e154";
4132  str >> CXSC_Pi[31];
4133  str = "-18AB54A8D7516Fe11E";
4134  str >> CXSC_Pi[32];
4135  str = "+186263E8144056e0E7";
4136  str >> CXSC_Pi[33];
4137  str = "-1AE34AEAAA77A5e0B0";
4138  str >> CXSC_Pi[34];
4139  str = "+16998B8682283De07A";
4140  str >> CXSC_Pi[35];
4141  str = "+19D42A90D5EF8Ee042";
4142  str >> CXSC_Pi[36];
4143  str = "+174C9D9F70A08Be00C";
4144  str >> CXSC_Pi[37];
4145  str = "+100000000000DBe000";
4146  str >> CXSC_Pi[38];
4147  str = "+100000000000DCe000";
4148  str >> CXSC_Pi[39];
4149 
4150  CXSC_Pi_initialized = true;
4151  std::cout << RestoreOpt;
4152  }
4153  stagprec = stagmax;
4154  y = adjust(l_interval(0));
4155 
4156  for (int i=0; i<=stagmax; i++)
4157  y[i+1] = CXSC_Pi[i];
4158 
4159  stagprec = stagsave;
4160  y = adjust(y);
4161 
4162  return lx_interval(-1020,y);
4163  } // Pi
4164 
4165 
4166  static real CXSC_Ln2[40]; // CXSC_Ln2[0], ... ,CXSC_Ln2[39]
4167  static bool CXSC_Ln2_initialized = false;
4168 
4169  lx_interval Ln2_lx_interval() throw()
4170 // Inclusion of ln(2), Blomquist, 15.06.2007;
4171  {
4172  l_interval y;
4173  int stagsave = stagprec,
4174  stagmax = 39;
4175  if (!CXSC_Ln2_initialized)
4176  {
4177  std::string str;
4178  std::cout << SaveOpt;
4179  std::cout << Hex;
4180  str = "+162E42FEFA39EFe7FC";
4181  str >> CXSC_Ln2[0];
4182  str = "+1ABC9E3B39803Fe7C5";
4183  str >> CXSC_Ln2[1];
4184  str = "+17B57A079A1934e78E";
4185  str >> CXSC_Ln2[2];
4186  str = "-1ACE93A4EBE5D1e758";
4187  str >> CXSC_Ln2[3];
4188  str = "-123A2A82EA0C24e722";
4189  str >> CXSC_Ln2[4];
4190  str = "+1D881B7AEB2615e6EB";
4191  str >> CXSC_Ln2[5];
4192  str = "+19552FB4AFA1B1e6B5";
4193  str >> CXSC_Ln2[6];
4194  str = "+1DA5D5C6B82704e67C";
4195  str >> CXSC_Ln2[7];
4196  str = "+14427573B29117e645";
4197  str >> CXSC_Ln2[8];
4198  str = "-191F6B05A4D7A7e60F";
4199  str >> CXSC_Ln2[9];
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];
4260 
4261  CXSC_Ln2_initialized = true;
4262  std::cout << RestoreOpt;
4263  }
4264  stagprec = stagmax;
4265  y = adjust(l_interval(0));
4266 
4267  for (int i=0; i<=stagmax; i++)
4268  y[i+1] = CXSC_Ln2[i];
4269 
4270  stagprec = stagsave;
4271  y = adjust(y);
4272 
4273  return lx_interval(-1022,y);
4274  } // ln(2)
4275 
4276  static real CXSC_Ln10[40]; // CXSC_Ln10[0], ... ,CXSC_Ln10[39]
4277  static bool CXSC_Ln10_initialized = false;
4278 
4279  lx_interval Ln10_lx_interval() throw()
4280 // Inclusion of ln(10), Blomquist, 15.06.2007;
4281  {
4282  l_interval y;
4283  int stagsave = stagprec,
4284  stagmax = 39;
4285  if (!CXSC_Ln10_initialized)
4286  {
4287  std::string str;
4288  std::cout << SaveOpt;
4289  std::cout << Hex;
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];
4370 
4371  CXSC_Ln10_initialized = true;
4372  std::cout << RestoreOpt;
4373  }
4374  stagprec = stagmax;
4375  y = adjust(l_interval(0));
4376 
4377  for (int i=0; i<=stagmax; i++)
4378  y[i+1] = CXSC_Ln10[i];
4379 
4380  stagprec = stagsave;
4381  y = adjust(y);
4382 
4383  return lx_interval(-1021,y);
4384  } // ln(10)
4385 
4386  static real CXSC_Pir[40]; // CXSC_Pir[0], ... ,CXSC_Pir[39]
4387  static bool CXSC_Pir_initialized = false;
4388 
4389  lx_interval Pir_lx_interval() throw()
4390 // Inclusion of 1/Pi, Blomquist, 15.06.2007;
4391  {
4392  l_interval y;
4393  int stagsave = stagprec,
4394  stagmax = 39;
4395  if (!CXSC_Pir_initialized)
4396  {
4397  std::string str;
4398  std::cout << SaveOpt;
4399  std::cout << Hex;
4400  str = "+145F306DC9C883e7FC";
4401  str >> CXSC_Pir[0];
4402  str = "-16B01EC5417056e7C6";
4403  str >> CXSC_Pir[1];
4404  str = "-16447E493AD4CEe790";
4405  str >> CXSC_Pir[2];
4406  str = "+1E21C820FF28B2e75A";
4407  str >> CXSC_Pir[3];
4408  str = "-1508510EA79237e723";
4409  str >> CXSC_Pir[4];
4410  str = "+1B8E909374B802e6EB";
4411  str >> CXSC_Pir[5];
4412  str = "-1B6D115F62E6DEe6B5";
4413  str >> CXSC_Pir[6];
4414  str = "-180F10A71A76B3e67E";
4415  str >> CXSC_Pir[7];
4416  str = "+1CFBA208D7D4BBe647";
4417  str >> CXSC_Pir[8];
4418  str = "-12EDEC598E3F65e60F";
4419  str >> CXSC_Pir[9];
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];
4480 
4481  CXSC_Pir_initialized = true;
4482  std::cout << RestoreOpt;
4483  }
4484  stagprec = stagmax;
4485  y = adjust(l_interval(0));
4486 
4487  for (int i=0; i<=stagmax; i++)
4488  y[i+1] = CXSC_Pir[i];
4489 
4490  stagprec = stagsave;
4491  y = adjust(y);
4492 
4493  return lx_interval(-1023,y);
4494  } // 1/Pi
4495 
4496  static real CXSC_SqrtPi[40]; // CXSC_SqrtPi[0], ... ,CXSC_SqrtPi[39]
4497  static bool CXSC_SqrtPi_initialized = false;
4498 
4499  lx_interval SqrtPi_lx_interval() throw()
4500 // Inclusion of sqrt(Pi), Blomquist, 15.06.2007;
4501  {
4502  l_interval y;
4503  int stagsave = stagprec,
4504  stagmax = 39;
4505  if (!CXSC_SqrtPi_initialized)
4506  {
4507  std::string str;
4508  std::cout << SaveOpt;
4509  std::cout << Hex;
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];
4590 
4591  CXSC_SqrtPi_initialized = true;
4592  std::cout << RestoreOpt;
4593  }
4594  stagprec = stagmax;
4595  y = adjust(l_interval(0));
4596 
4597  for (int i=0; i<=stagmax; i++)
4598  y[i+1] = CXSC_SqrtPi[i];
4599 
4600  stagprec = stagsave;
4601  y = adjust(y);
4602 
4603  return lx_interval(-1021,y);
4604  } // sqrt(Pi)
4605 
4606  static real CXSC_Sqrt2Pi[40]; // CXSC_Sqrt2Pi[0], ... ,CXSC_Sqrt2Pi[39]
4607  static bool CXSC_Sqrt2Pi_initialized = false;
4608 
4609  lx_interval Sqrt2Pi_lx_interval() throw()
4610 // Inclusion of sqrt(2*Pi), Blomquist, 15.06.2007;
4611  {
4612  l_interval y;
4613  int stagsave = stagprec,
4614  stagmax = 39;
4615  if (!CXSC_Sqrt2Pi_initialized)
4616  {
4617  std::string str;
4618  std::cout << SaveOpt;
4619  std::cout << Hex;
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];
4700 
4701 
4702  CXSC_Sqrt2Pi_initialized = true;
4703  std::cout << RestoreOpt;
4704  }
4705  stagprec = stagmax;
4706  y = adjust(l_interval(0));
4707 
4708  for (int i=0; i<=stagmax; i++)
4709  y[i+1] = CXSC_Sqrt2Pi[i];
4710 
4711  stagprec = stagsave;
4712  y = adjust(y);
4713 
4714  return lx_interval(-1021,y);
4715  } // sqrt(2*Pi)
4716 
4717  static real CXSC_Sqrt2[40]; // CXSC_Sqrt2[0], ... ,CXSC_Sqrt2[39]
4718  static bool CXSC_Sqrt2_initialized = false;
4719 
4720  lx_interval Sqrt2_lx_interval() throw()
4721 // Inclusion of sqrt(2), Blomquist, 15.06.2007;
4722  {
4723  l_interval y;
4724  int stagsave = stagprec,
4725  stagmax = 39;
4726  if (!CXSC_Sqrt2_initialized)
4727  {
4728  std::string str;
4729  std::cout << SaveOpt;
4730  std::cout << Hex;
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];
4811 
4812  CXSC_Sqrt2_initialized = true;
4813  std::cout << RestoreOpt;
4814  }
4815  stagprec = stagmax;
4816  y = adjust(l_interval(0));
4817 
4818  for (int i=0; i<=stagmax; i++)
4819  y[i+1] = CXSC_Sqrt2[i];
4820 
4821  stagprec = stagsave;
4822  y = adjust(y);
4823 
4824  return lx_interval(-1021,y);
4825  } // sqrt(2)
4826 
4827  static real CXSC_Sqrt3[40]; // CXSC_Sqrt3[0], ... ,CXSC_Sqrt3[39]
4828  static bool CXSC_Sqrt3_initialized = false;
4829 
4830  lx_interval Sqrt3_lx_interval() throw()
4831 // Inclusion of sqrt(3), Blomquist, 15.06.2007;
4832  {
4833  l_interval y;
4834  int stagsave = stagprec,
4835  stagmax = 39;
4836  if (!CXSC_Sqrt3_initialized)
4837  {
4838  std::string str;
4839  std::cout << SaveOpt;
4840  std::cout << Hex;
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];
4921 
4922  CXSC_Sqrt3_initialized = true;
4923  std::cout << RestoreOpt;
4924  }
4925  stagprec = stagmax;
4926  y = adjust(l_interval(0));
4927 
4928  for (int i=0; i<=stagmax; i++)
4929  y[i+1] = CXSC_Sqrt3[i];
4930 
4931  stagprec = stagsave;
4932  y = adjust(y);
4933 
4934  return lx_interval(-1021,y);
4935  } // sqrt(3)
4936 
4937  static real CXSC_Ln2r[40]; // CXSC_Ln2r[0], ... ,CXSC_Ln2r[39]
4938  static bool CXSC_Ln2r_initialized = false;
4939 
4940  lx_interval Ln2r_lx_interval() throw()
4941 // Inclusion of 1/ln(2), Blomquist, 15.06.2007;
4942  {
4943  l_interval y;
4944  int stagsave = stagprec,
4945  stagmax = 39;
4946  if (!CXSC_Ln2r_initialized)
4947  {
4948  std::string str;
4949  std::cout << SaveOpt;
4950  std::cout << Hex;
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];
5031 
5032  CXSC_Ln2r_initialized = true;
5033  std::cout << RestoreOpt;
5034  }
5035  stagprec = stagmax;
5036  y = adjust(l_interval(0));
5037 
5038  for (int i=0; i<=stagmax; i++)
5039  y[i+1] = CXSC_Ln2r[i];
5040 
5041  stagprec = stagsave;
5042  y = adjust(y);
5043 
5044  return lx_interval(-1021,y);
5045  } // 1/ln(2)
5046 
5047  static real CXSC_Pid3[40]; // CXSC_Pid3[0], ... ,CXSC_Pid3[39]
5048  static bool CXSC_Pid3_initialized = false;
5049 
5050  lx_interval Pid3_lx_interval() throw()
5051 // Inclusion of Pi/3, Blomquist, 15.06.2007;
5052  {
5053  l_interval y;
5054  int stagsave = stagprec,
5055  stagmax = 39;
5056  if (!CXSC_Pid3_initialized)
5057  {
5058  std::string str;
5059  std::cout << SaveOpt;
5060  std::cout << Hex;
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];
5141 
5142  CXSC_Pid3_initialized = true;
5143  std::cout << RestoreOpt;
5144  }
5145  stagprec = stagmax;
5146  y = adjust(l_interval(0));
5147 
5148  for (int i=0; i<=stagmax; i++)
5149  y[i+1] = CXSC_Pid3[i];
5150 
5151  stagprec = stagsave;
5152  y = adjust(y);
5153 
5154  return lx_interval(-1022,y);
5155  } // Pi/3
5156 
5157  static real CXSC_SqrtPir[40]; // CXSC_SqrtPir[0], ... ,CXSC_SqrtPir[39]
5158  static bool CXSC_SqrtPir_initialized = false;
5159 
5160  lx_interval SqrtPir_lx_interval() throw()
5161 // Inclusion of 1/sqrt(Pi), Blomquist, 15.06.2007;
5162  {
5163  l_interval y;
5164  int stagsave = stagprec,
5165  stagmax = 39;
5166  if (!CXSC_SqrtPir_initialized)
5167  {
5168  std::string str;
5169  std::cout << SaveOpt;
5170  std::cout << Hex;
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];
5251 
5252  CXSC_SqrtPir_initialized = true;
5253  std::cout << RestoreOpt;
5254  }
5255  stagprec = stagmax;
5256  y = adjust(l_interval(0));
5257 
5258  for (int i=0; i<=stagmax; i++)
5259  y[i+1] = CXSC_SqrtPir[i];
5260 
5261  stagprec = stagsave;
5262  y = adjust(y);
5263 
5264  return lx_interval(-1023,y);
5265  } // 1/sqrt(Pi)
5266 
5267  static real CXSC_Sqrt2Pir[40]; // CXSC_Sqrt2Pir[0], ... ,CXSC_Sqrt2Pir[39]
5268  static bool CXSC_Sqrt2Pir_initialized = false;
5269 
5270  lx_interval Sqrt2Pir_lx_interval() throw()
5271 // Inclusion of 1/sqrt(2*Pi), Blomquist, 15.06.2007;
5272  {
5273  l_interval y;
5274  int stagsave = stagprec,
5275  stagmax = 39;
5276  if (!CXSC_Sqrt2Pir_initialized)
5277  {
5278  std::string str;
5279  std::cout << SaveOpt;
5280  std::cout << Hex;
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];
5361 
5362  CXSC_Sqrt2Pir_initialized = true;
5363  std::cout << RestoreOpt;
5364  }
5365  stagprec = stagmax;
5366  y = adjust(l_interval(0));
5367 
5368  for (int i=0; i<=stagmax; i++)
5369  y[i+1] = CXSC_Sqrt2Pir[i];
5370 
5371  stagprec = stagsave;
5372  y = adjust(y);
5373 
5374  return lx_interval(-1023,y);
5375  } // 1/sqrt(2*Pi)
5376 
5377  static real CXSC_LnPi[40]; // CXSC_LnPi[0], ... ,CXSC_LnPi[39]
5378  static bool CXSC_LnPi_initialized = false;
5379 
5380  lx_interval LnPi_lx_interval() throw()
5381 // Inclusion of ln(Pi), Blomquist, 15.06.2007;
5382  {
5383  l_interval y;
5384  int stagsave = stagprec,
5385  stagmax = 39;
5386  if (!CXSC_LnPi_initialized)
5387  {
5388  std::string str;
5389  std::cout << SaveOpt;
5390  std::cout << Hex;
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];
5471 
5472  CXSC_LnPi_initialized = true;
5473  std::cout << RestoreOpt;
5474  }
5475  stagprec = stagmax;
5476  y = adjust(l_interval(0));
5477 
5478  for (int i=0; i<=stagmax; i++)
5479  y[i+1] = CXSC_LnPi[i];
5480 
5481  stagprec = stagsave;
5482  y = adjust(y);
5483 
5484  return lx_interval(-1022,y);
5485  } // ln(Pi)
5486 
5487  static real CXSC_Ln2Pi[40]; // CXSC_Ln2Pi[0], ... ,CXSC_Ln2Pi[39]
5488  static bool CXSC_Ln2Pi_initialized = false;
5489 
5490  lx_interval Ln2Pi_lx_interval() throw()
5491 // Inclusion of ln(2*Pi), Blomquist, 15.06.2007;
5492  {
5493  l_interval y;
5494  int stagsave = stagprec,
5495  stagmax = 39;
5496  if (!CXSC_Ln2Pi_initialized)
5497  {
5498  std::string str;
5499  std::cout << SaveOpt;
5500  std::cout << Hex;
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];
5581 
5582  CXSC_Ln2Pi_initialized = true;
5583  std::cout << RestoreOpt;
5584  }
5585  stagprec = stagmax;
5586  y = adjust(l_interval(0));
5587 
5588  for (int i=0; i<=stagmax; i++)
5589  y[i+1] = CXSC_Ln2Pi[i];
5590 
5591  stagprec = stagsave;
5592  y = adjust(y);
5593 
5594  return lx_interval(-1021,y);
5595  } // ln(2*Pi)
5596 
5597  static real CXSC_E[40]; // CXSC_E[0], ... ,CXSC_E[39]
5598  static bool CXSC_E_initialized = false;
5599 
5600  lx_interval E_lx_interval() throw()
5601 // Inclusion of e, Blomquist, 15.06.2007;
5602  {
5603  l_interval y;
5604  int stagsave = stagprec,
5605  stagmax = 39;
5606  if (!CXSC_E_initialized)
5607  {
5608  std::string str;
5609  std::cout << SaveOpt;
5610  std::cout << Hex;
5611  str = "+15BF0A8B145769e7FD";
5612  str >> CXSC_E[0];
5613  str = "+14D57EE2B1013Ae7C7";
5614  str >> CXSC_E[1];
5615  str = "-1618713A31D3E2e78F";
5616  str >> CXSC_E[2];
5617  str = "+1C5A6D2B53C26De759";
5618  str >> CXSC_E[3];
5619  str = "-1F75CDE60219B6e723";
5620  str >> CXSC_E[4];
5621  str = "-188C76D93041A1e6EC";
5622  str >> CXSC_E[5];
5623  str = "+12FE363630C75Ee6B6";
5624  str >> CXSC_E[6];
5625  str = "-1C25F937F544EEe680";
5626  str >> CXSC_E[7];
5627  str = "-1E852C20E12A2Ae64A";
5628  str >> CXSC_E[8];
5629  str = "-14D4F6DE605705e60F";
5630  str >> CXSC_E[9];
5631  str = "-1F3225EF539355e5D5";
5632  str >> CXSC_E[10];
5633  str = "-16109728625547e59F";
5634  str >> CXSC_E[11];
5635  str = "-194301506D94CFe569";
5636  str >> CXSC_E[12];
5637  str = "-1879C78F8CBA44e533";
5638  str >> CXSC_E[13];
5639  str = "-1D5976250C1018e4FA";
5640  str >> CXSC_E[14];
5641  str = "+1C877C56284DABe4C4";
5642  str >> CXSC_E[15];
5643  str = "+1E73530ACCA4F5e48E";
5644  str >> CXSC_E[16];
5645  str = "-1F161A150FD53Ae458";
5646  str >> CXSC_E[17];
5647  str = "+159927DB0E8845e41F";
5648  str >> CXSC_E[18];
5649  str = "+12976591C7F773e3E9";
5650  str >> CXSC_E[19];
5651  str = "-1525489F280B98e3B2";
5652  str >> CXSC_E[20];
5653  str = "+1D4F42A3DE394Ee37A";
5654  str >> CXSC_E[21];
5655  str = "-16A3522431391Be341";
5656  str >> CXSC_E[22];
5657  str = "+1D8C8583D3E477e30B";
5658  str >> CXSC_E[23];
5659  str = "+14DAE13C05F9C4e2D1";
5660  str >> CXSC_E[24];
5661  str = "-19040E899FE5FEe29B";
5662  str >> CXSC_E[25];
5663  str = "+19A50685EC322Ee265";
5664  str >> CXSC_E[26];
5665  str = "+17F4E74C2C1FFCe22F";
5666  str >> CXSC_E[27];
5667  str = "+1C9E2465DDE503e1F9";
5668  str >> CXSC_E[28];
5669  str = "+1E1FF1D8DA637De1BF";
5670  str >> CXSC_E[29];
5671  str = "+1AE6776BF9785Ee189";
5672  str >> CXSC_E[30];
5673  str = "-1EEFFD1D38873Ee153";
5674  str >> CXSC_E[31];
5675  str = "-105D2F89A72197e11D";
5676  str >> CXSC_E[32];
5677  str = "+11360D977FD443e0E7";
5678  str >> CXSC_E[33];
5679  str = "+168470C23F9FBAe0B1";
5680  str >> CXSC_E[34];
5681  str = "-10E552624D737Ee07B";
5682  str >> CXSC_E[35];
5683  str = "-148879616420CCe045";
5684  str >> CXSC_E[36];
5685  str = "-1FEE3CF25C81B1e00F";
5686  str >> CXSC_E[37];
5687  str = "-10000000001233e000";
5688  str >> CXSC_E[38];
5689  str = "-10000000001232e000";
5690  str >> CXSC_E[39];
5691 
5692  CXSC_E_initialized = true;
5693  std::cout << RestoreOpt;
5694  }
5695  stagprec = stagmax;
5696  y = adjust(l_interval(0));
5697 
5698  for (int i=0; i<=stagmax; i++)
5699  y[i+1] = CXSC_E[i];
5700 
5701  stagprec = stagsave;
5702  y = adjust(y);
5703 
5704  return lx_interval(-1021,y);
5705  } // e
5706 
5707  static real CXSC_EpPi[40]; // CXSC_EpPi[0], ... ,CXSC_EpPi[39]
5708  static bool CXSC_EpPi_initialized = false;
5709 
5710  lx_interval EpPi_lx_interval() throw()
5711 // Inclusion of e^Pi, Blomquist, 15.06.2007;
5712  {
5713  l_interval y;
5714  int stagsave = stagprec,
5715  stagmax = 39;
5716  if (!CXSC_EpPi_initialized)
5717  {
5718  std::string str;
5719  std::cout << SaveOpt;
5720  std::cout << Hex;
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];
5801 
5802  CXSC_EpPi_initialized = true;
5803  std::cout << RestoreOpt;
5804  }
5805  stagprec = stagmax;
5806  y = adjust(l_interval(0));
5807 
5808  for (int i=0; i<=stagmax; i++)
5809  y[i+1] = CXSC_EpPi[i];
5810 
5811  stagprec = stagsave;
5812  y = adjust(y);
5813 
5814  return lx_interval(-1018,y);
5815  } // e^Pi
5816 
5817  static real CXSC_EulerGamma[40]; // CXSC_EulerGamma[0],...,CXSC_EulerGamma[39]
5818  static bool CXSC_EulerGamma_initialized = false;
5819 
5820  lx_interval EulerGamma_lx_interval() throw()
5821 // Inclusion of EulerGamma, Blomquist, 15.06.2007;
5822  {
5823  l_interval y;
5824  int stagsave = stagprec,
5825  stagmax = 39;
5826  if (!CXSC_EulerGamma_initialized)
5827  {
5828  std::string str;
5829  std::cout << SaveOpt;
5830  std::cout << Hex;
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];
5911 
5912  CXSC_EulerGamma_initialized = true;
5913  std::cout << RestoreOpt;
5914  }
5915  stagprec = stagmax;
5916  y = adjust(l_interval(0));
5917 
5918  for (int i=0; i<=stagmax; i++)
5919  y[i+1] = CXSC_EulerGamma[i];
5920 
5921  stagprec = stagsave;
5922  y = adjust(y);
5923 
5924  return lx_interval(-1023,y);
5925  } // EulerGamma
5926 
5927  static real CXSC_Catalan[40]; // CXSC_Catalan[0],...,CXSC_Catalan[39]
5928  static bool CXSC_Catalan_initialized = false;
5929 
5930  lx_interval Catalan_lx_interval() throw()
5931 // Inclusion of Catalan, Blomquist, 15.06.2007;
5932  {
5933  l_interval y;
5934  int stagsave = stagprec,
5935  stagmax = 39;
5936  if (!CXSC_Catalan_initialized)
5937  {
5938  std::string str;
5939  std::cout << SaveOpt;
5940  std::cout << Hex;
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];
6021 
6022  CXSC_Catalan_initialized = true;
6023  std::cout << RestoreOpt;
6024  }
6025  stagprec = stagmax;
6026  y = adjust(l_interval(0));
6027 
6028  for (int i=0; i<=stagmax; i++)
6029  y[i+1] = CXSC_Catalan[i];
6030 
6031  stagprec = stagsave;
6032  y = adjust(y);
6033 
6034  return lx_interval(-1022,y);
6035  } // Catalan
6036 
6037  static real CXSC_sqrt5[40]; // CXSC_sqrt5[0],...,CXSC_sqrt5[39]
6038  static bool CXSC_sqrt5_initialized = false;
6039 
6040  lx_interval sqrt5_lx_interval() throw()
6041 // Inclusion of sqrt(5), Blomquist, 15.06.2007;
6042  {
6043  l_interval y;
6044  int stagsave = stagprec,
6045  stagmax = 39;
6046  if (!CXSC_sqrt5_initialized)
6047  {
6048  std::string str;
6049  std::cout << SaveOpt;
6050  std::cout << Hex;
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];
6131 
6132  CXSC_sqrt5_initialized = true;
6133  std::cout << RestoreOpt;
6134  }
6135  stagprec = stagmax;
6136  y = adjust(l_interval(0));
6137 
6138  for (int i=0; i<=stagmax; i++)
6139  y[i+1] = CXSC_sqrt5[i];
6140 
6141  stagprec = stagsave;
6142  y = adjust(y);
6143 
6144  return lx_interval(-1021,y);
6145  } // sqrt(5)
6146 
6147  static real CXSC_sqrt7[40]; // CXSC_sqrt7[0],...,CXSC_sqrt7[39]
6148  static bool CXSC_sqrt7_initialized = false;
6149 
6150  lx_interval sqrt7_lx_interval() throw()
6151 // Inclusion of sqrt(7), Blomquist, 15.06.2007;
6152  {
6153  l_interval y;
6154  int stagsave = stagprec,
6155  stagmax = 39;
6156  if (!CXSC_sqrt7_initialized)
6157  {
6158  std::string str;
6159  std::cout << SaveOpt;
6160  std::cout << Hex;
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];
6241 
6242  CXSC_sqrt7_initialized = true;
6243  std::cout << RestoreOpt;
6244  }
6245  stagprec = stagmax;
6246  y = adjust(l_interval(0));
6247 
6248  for (int i=0; i<=stagmax; i++)
6249  y[i+1] = CXSC_sqrt7[i];
6250 
6251  stagprec = stagsave;
6252  y = adjust(y);
6253 
6254  return lx_interval(-1021,y);
6255  } // sqrt(7)
6256 
6257  static real CXSC_One_m[3]; // CXSC_One_m[0], ... ,CXSC_One_m[2]
6258  static bool CXSC_One_m_initialized = false;
6259 
6260  lx_interval One_m_lx_interval() throw()
6261 // Inclusion of 2^(-1023)*(2^(+1023) - 2^(-1074)) = 1-2^(-2097),
6262 // Blomquist, 26.07.2007;
6263  {
6264  l_interval y;
6265  int stagsave = stagprec,
6266  stagmax = 2;
6267 
6268  if (!CXSC_One_m_initialized)
6269  {
6270  std::string str;
6271  std::cout << SaveOpt;
6272  std::cout << Hex;
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;
6281  }
6282  stagprec = stagmax;
6283  y = adjust(l_interval(0));
6284 
6285  for (int i=0; i<=stagmax; i++)
6286  y[i+1] = CXSC_One_m[i];
6287 
6288  stagprec = stagsave;
6289  y = adjust(y);
6290 
6291  return lx_interval(-1023,y);
6292  } // One_m_lx_interval()
6293 
6294  static real CXSC_One_p[3]; // CXSC_One_p[0], ... ,CXSC_One_p[2]
6295  static bool CXSC_One_p_initialized = false;
6296 
6297  lx_interval One_p_lx_interval() throw()
6298 // Inclusion of 2^(-1023)*(2^(+1023) + 2^(-1074)) = 1+2^(-2097),
6299 // Blomquist, 27.07.2007;
6300  {
6301  l_interval y;
6302  int stagsave = stagprec,
6303  stagmax = 2;
6304 
6305  if (!CXSC_One_p_initialized)
6306  {
6307  std::string str;
6308  std::cout << SaveOpt;
6309  std::cout << Hex;
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;
6318  }
6319  stagprec = stagmax;
6320  y = adjust(l_interval(0));
6321 
6322  for (int i=0; i<=stagmax; i++)
6323  y[i+1] = CXSC_One_p[i];
6324 
6325  stagprec = stagsave;
6326  y = adjust(y);
6327 
6328  return lx_interval(-1023,y);
6329  } // One_p_lx_interval()
6330 
6331  static real CXSC_Ln10r[40]; // CXSC_Ln10r[0], ... ,CXSC_Ln10r[39]
6332  static bool CXSC_Ln10r_initialized = false;
6333 
6334  lx_interval Ln10r_lx_interval() throw()
6335 // Inclusion of 1/ln(10), Blomquist, 27.11.2008;
6336  {
6337  l_interval y;
6338  int stagsave = stagprec,
6339  stagmax = 39;
6340  if (!CXSC_Ln10r_initialized)
6341  {
6342  std::string str;
6343  std::cout << SaveOpt;
6344  std::cout << Hex;
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];
6425 
6426  CXSC_Ln10r_initialized = true;
6427  std::cout << RestoreOpt;
6428  }
6429  stagprec = stagmax;
6430  y = adjust(l_interval(0));
6431 
6432  for (int i=0; i<=stagmax; i++)
6433  y[i+1] = CXSC_Ln10r[i];
6434 
6435  stagprec = stagsave;
6436  y = adjust(y);
6437 
6438  return lx_interval(-1023,y);
6439  } // 1/ln(10)
6440 
6441 // **************************************************************************
6442 
6443  static real CXSC_Pid4[40]; // CXSC_Pid4[0], ... ,CXSC_Pid4[39]
6444  static bool CXSC_Pid4_initialized = false;
6445 
6446  lx_interval Pid4_lx_interval() throw()
6447 // Inclusion of 1/ln(10), Blomquist, 27.11.2008;
6448  {
6449  l_interval y;
6450  int stagsave = stagprec,
6451  stagmax = 39;
6452  if (!CXSC_Pid4_initialized)
6453  {
6454  std::string str;
6455  std::cout << SaveOpt;
6456  std::cout << Hex;
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];
6537 
6538  CXSC_Pid4_initialized = true;
6539  std::cout << RestoreOpt;
6540  }
6541  stagprec = stagmax;
6542  y = adjust(l_interval(0));
6543 
6544  for (int i=0; i<=stagmax; i++)
6545  y[i+1] = CXSC_Pid4[i];
6546 
6547  stagprec = stagsave;
6548  y = adjust(y);
6549 
6550  return lx_interval(-1022,y);
6551  } // pi/4
6552 
6553 // *************************************************************************
6554 
6555  static real CXSC_Pid2[40]; // CXSC_Pid2[0], ... ,CXSC_Pid2[39]
6556  static bool CXSC_Pid2_initialized = false;
6557 
6558  lx_interval Pid2_lx_interval() throw()
6559 // Inclusion of 1/ln(10), Blomquist, 27.11.2008;
6560  {
6561  l_interval y;
6562  int stagsave = stagprec,
6563  stagmax = 39;
6564  if (!CXSC_Pid2_initialized)
6565  {
6566  std::string str;
6567  std::cout << SaveOpt;
6568  std::cout << Hex;
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];
6649 
6650  CXSC_Pid2_initialized = true;
6651  std::cout << RestoreOpt;
6652  }
6653  stagprec = stagmax;
6654  y = adjust(l_interval(0));
6655 
6656  for (int i=0; i<=stagmax; i++)
6657  y[i+1] = CXSC_Pid2[i];
6658 
6659  stagprec = stagsave;
6660  y = adjust(y);
6661 
6662  return lx_interval(-1021,y);
6663  } // pi/2
6664 
6665 // **************************************************************************
6666 
6667  static real CXSC_Pi2[40]; // CXSC_Pi2[0], ... ,CXSC_Pi2[39]
6668  static bool CXSC_Pi2_initialized = false;
6669 
6670  lx_interval Pi2_lx_interval() throw()
6671 // Inclusion of 2*pi, Blomquist, 27.11.2008;
6672  {
6673  l_interval y;
6674  int stagsave = stagprec,
6675  stagmax = 39; // alt
6676  if (!CXSC_Pi2_initialized)
6677  {
6678  std::string str;
6679  std::cout << SaveOpt;
6680  std::cout << Hex;
6681  str = "+1921FB54442D18e7FC";
6682  str >> CXSC_Pi2[0];
6683  str = "+11A62633145C07e7C6";
6684  str >> CXSC_Pi2[1];
6685  str = "-1F1976B7ED8FBCe78E";
6686  str >> CXSC_Pi2[2];
6687  str = "+14CF98E804177De758";
6688  str >> CXSC_Pi2[3];
6689  str = "+131D89CD9128A5e722";
6690  str >> CXSC_Pi2[4];
6691  str = "+10F31C6809BBDFe6E8";
6692  str >> CXSC_Pi2[5];
6693  str = "+1519B3CD3A431Be6B1";
6694  str >> CXSC_Pi2[6];
6695  str = "+18158536F92F8Ae67A";
6696  str >> CXSC_Pi2[7];
6697  str = "+1BA7F09AB6B6A9e642";
6698  str >> CXSC_Pi2[8];
6699  str = "-1EDD0DBD2544CFe60A";
6700  str >> CXSC_Pi2[9];
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];
6761 
6762  CXSC_Pi2_initialized = true;
6763  std::cout << RestoreOpt;
6764  }
6765  stagprec = stagmax;
6766  y = adjust(l_interval(0));
6767 
6768  for (int i=0; i<=stagmax; i++)
6769  y[i+1] = CXSC_Pi2[i];
6770 
6771  stagprec = stagsave;
6772  y = adjust(y);
6773 
6774  return lx_interval(-1019,y);
6775  } // 2pi
6776 
6777 // **************************************************************************
6778 
6779  static real CXSC_Pi2r[40]; // CXSC_Pi2r[0], ... ,CXSC_Pi2r[39]
6780  static bool CXSC_Pi2r_initialized = false;
6781 
6782  lx_interval Pi2r_lx_interval() throw()
6783 // Inclusion of 1/Pi, Blomquist, 15.06.2007;
6784  {
6785  l_interval y;
6786  int stagsave = stagprec,
6787  stagmax = 39;
6788  if (!CXSC_Pi2r_initialized)
6789  {
6790  std::string str;
6791  std::cout << SaveOpt;
6792  std::cout << Hex;
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];
6873 
6874  CXSC_Pi2r_initialized = true;
6875  std::cout << RestoreOpt;
6876  }
6877  stagprec = stagmax;
6878  y = adjust(l_interval(0));
6879 
6880  for (int i=0; i<=stagmax; i++)
6881  y[i+1] = CXSC_Pi2r[i];
6882 
6883  stagprec = stagsave;
6884  y = adjust(y);
6885 
6886  return lx_interval(-1024,y);
6887  } // 1/(2*pi)
6888 
6889 // **************************************************************************
6890 
6891  static real CXSC_Pip2[40]; // CXSC_Pip2[0], ... ,CXSC_Pip2[39]
6892  static bool CXSC_Pip2_initialized = false;
6893 
6894  lx_interval Pip2_lx_interval() throw()
6895 // Inclusion of 1/Pi, Blomquist, 15.06.2007;
6896  {
6897  l_interval y;
6898  int stagsave = stagprec,
6899  stagmax = 39;
6900  if (!CXSC_Pip2_initialized)
6901  {
6902  std::string str;
6903  std::cout << SaveOpt;
6904  std::cout << Hex;
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];
6985 
6986  CXSC_Pip2_initialized = true;
6987  std::cout << RestoreOpt;
6988  }
6989  stagprec = stagmax;
6990  y = adjust(l_interval(0));
6991 
6992  for (int i=0; i<=stagmax; i++)
6993  y[i+1] = CXSC_Pip2[i];
6994 
6995  stagprec = stagsave;
6996  y = adjust(y);
6997 
6998  return lx_interval(-1019,y);
6999  } // pi^2
7000 
7001 // **************************************************************************
7002 
7003  static real CXSC_Sqrt2r[40]; // CXSC_Sqrt2r[0], ... ,CXSC_Sqrt2r[39]
7004  static bool CXSC_Sqrt2r_initialized = false;
7005 
7006  lx_interval Sqrt2r_lx_interval() throw()
7007 // Inclusion of sqrt(2), Blomquist, 27.11.2008;
7008  {
7009  l_interval y;
7010  int stagsave = stagprec,
7011  stagmax = 39;
7012  if (!CXSC_Sqrt2r_initialized)
7013  {
7014  std::string str;
7015  std::cout << SaveOpt;
7016  std::cout << Hex;
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];
7097 
7098  CXSC_Sqrt2r_initialized = true;
7099  std::cout << RestoreOpt;
7100  }
7101  stagprec = stagmax;
7102  y = adjust(l_interval(0));
7103 
7104  for (int i=0; i<=stagmax; i++)
7105  y[i+1] = CXSC_Sqrt2r[i];
7106 
7107  stagprec = stagsave;
7108  y = adjust(y);
7109 
7110  return lx_interval(-1022,y);
7111  } // 1/sqrt(2)
7112 
7113 // ************************************************************************
7114 
7115  static real CXSC_Sqrt3d2[40]; // CXSC_Sqrt3d2[0], ... ,CXSC_Sqrt3d2[39]
7116  static bool CXSC_Sqrt3d2_initialized = false;
7117 
7118  lx_interval Sqrt3d2_lx_interval() throw()
7119 // Inclusion of sqrt(3), Blomquist, 15.06.2007;
7120  {
7121  l_interval y;
7122  int stagsave = stagprec,
7123  stagmax = 39;
7124  if (!CXSC_Sqrt3d2_initialized)
7125  {
7126  std::string str;
7127  std::cout << SaveOpt;
7128  std::cout << Hex;
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];
7209 
7210  CXSC_Sqrt3d2_initialized = true;
7211  std::cout << RestoreOpt;
7212  }
7213  stagprec = stagmax;
7214  y = adjust(l_interval(0));
7215 
7216  for (int i=0; i<=stagmax; i++)
7217  y[i+1] = CXSC_Sqrt3d2[i];
7218 
7219  stagprec = stagsave;
7220  y = adjust(y);
7221 
7222  return lx_interval(-1022,y);
7223  } // sqrt(3)/2
7224 
7225 // **********************************************************************
7226 
7227  static real CXSC_Sqrt3r[40]; // CXSC_Sqrt3r[0], ... ,CXSC_Sqrt3r[39]
7228  static bool CXSC_Sqrt3r_initialized = false;
7229 
7230  lx_interval Sqrt3r_lx_interval() throw()
7231 // Inclusion of 1/sqrt(3), Blomquist, 27.11.2008;
7232  {
7233  l_interval y;
7234  int stagsave = stagprec,
7235  stagmax = 39;
7236  if (!CXSC_Sqrt3r_initialized)
7237  {
7238  std::string str;
7239  std::cout << SaveOpt;
7240  std::cout << Hex;
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];
7321 
7322  CXSC_Sqrt3r_initialized = true;
7323  std::cout << RestoreOpt;
7324  }
7325  stagprec = stagmax;
7326  y = adjust(l_interval(0));
7327 
7328  for (int i=0; i<=stagmax; i++)
7329  y[i+1] = CXSC_Sqrt3r[i];
7330 
7331  stagprec = stagsave;
7332  y = adjust(y);
7333 
7334  return lx_interval(-1022,y);
7335  } // 1/sqrt(3)
7336 
7337 // **********************************************************************
7338 
7339  static real CXSC_Er[40]; // CXSC_Er[0], ... ,CXSC_Er[39]
7340  static bool CXSC_Er_initialized = false;
7341 
7342  lx_interval Er_lx_interval() throw()
7343 // Inclusion of 1/sqrt(3), Blomquist, 27.11.2008;
7344  {
7345  l_interval y;
7346  int stagsave = stagprec,
7347  stagmax = 39;
7348  if (!CXSC_Er_initialized)
7349  {
7350  std::string str;
7351  std::cout << SaveOpt;
7352  std::cout << Hex;
7353  str = "+178B56362CEF38e7FC";
7354  str >> CXSC_Er[0];
7355  str = "-1CA8A4270FADF5e7C5";
7356  str >> CXSC_Er[1];
7357  str = "-1837912B3FD2AAe78F";
7358  str >> CXSC_Er[2];
7359  str = "-152711999FB68Ce759";
7360  str >> CXSC_Er[3];
7361  str = "-17AD7C1289274Ee723";
7362  str >> CXSC_Er[4];
7363  str = "+17E8E56842B705e6E5";
7364  str >> CXSC_Er[5];
7365  str = "-1D24CB13796C2De6AF";
7366  str >> CXSC_Er[6];
7367  str = "-1456AABDA5C8F2e678";
7368  str >> CXSC_Er[7];
7369  str = "+1229F03C6276DDe642";
7370  str >> CXSC_Er[8];
7371  str = "-1569CFC4F53109e60C";
7372  str >> CXSC_Er[9];
7373  str = "-155B63C9B68091e5D4";
7374  str >> CXSC_Er[10];
7375  str = "+1580CF14DC087Ce59E";
7376  str >> CXSC_Er[11];
7377  str = "+1F9FF222313669e567";
7378  str >> CXSC_Er[12];
7379  str = "+15BC9CB1A22487e531";
7380  str >> CXSC_Er[13];
7381  str = "-1857E415C89B13e4FA";
7382  str >> CXSC_Er[14];
7383  str = "+13DF75706E3643e4C4";
7384  str >> CXSC_Er[15];
7385  str = "+13BDF5B7646234e48C";
7386  str >> CXSC_Er[16];
7387  str = "+1C956A5A3BE55De456";
7388  str >> CXSC_Er[17];
7389  str = "-167243FE9CD95Ee41F";
7390  str >> CXSC_Er[18];
7391  str = "+1798666D9D76F9e3E9";
7392  str >> CXSC_Er[19];
7393  str = "-195BC96299ED95e3B3";
7394  str >> CXSC_Er[20];
7395  str = "-1962287D82F280e37D";
7396  str >> CXSC_Er[21];
7397  str = "+1C3CF6DDC027D8e347";
7398  str >> CXSC_Er[22];
7399  str = "-182A3C09F5C0B7e310";
7400  str >> CXSC_Er[23];
7401  str = "+181C26FE7F6AB1e2DA";
7402  str >> CXSC_Er[24];
7403  str = "+19F6D7E4825294e2A4";
7404  str >> CXSC_Er[25];
7405  str = "+1BBC423BEA892Fe26D";
7406  str >> CXSC_Er[26];
7407  str = "+1342C7A3A14AB4e237";
7408  str >> CXSC_Er[27];
7409  str = "+12A70DFB042173e201";
7410  str >> CXSC_Er[28];
7411  str = "-10325653502352e1CB";
7412  str >> CXSC_Er[29];
7413  str = "-10AD4492DE41FFe191";
7414  str >> CXSC_Er[30];
7415  str = "-1E4529AB93CDA1e156";
7416  str >> CXSC_Er[31];
7417  str = "+1128833F39DF0Ae11E";
7418  str >> CXSC_Er[32];
7419  str = "-1E7EDF8F9B8A50e0E8";
7420  str >> CXSC_Er[33];
7421  str = "+1A42CBDB5BB8D0e0B0";
7422  str >> CXSC_Er[34];
7423  str = "+1973F3BD8250A1e07A";
7424  str >> CXSC_Er[35];
7425  str = "+116AF9EF0E6C71e040";
7426  str >> CXSC_Er[36];
7427  str = "-1786993285AA7Ae00A";
7428  str >> CXSC_Er[37];
7429  str = "-1000000000007De000";
7430  str >> CXSC_Er[38];
7431  str = "-1000000000007Ce000";
7432  str >> CXSC_Er[39];
7433 
7434  CXSC_Er_initialized = true;
7435  std::cout << RestoreOpt;
7436  }
7437  stagprec = stagmax;
7438  y = adjust(l_interval(0));
7439 
7440  for (int i=0; i<=stagmax; i++)
7441  y[i+1] = CXSC_Er[i];
7442 
7443  stagprec = stagsave;
7444  y = adjust(y);
7445 
7446  return lx_interval(-1023,y);
7447  } // 1/e
7448 
7449 // **********************************************************************
7450 
7451  static real CXSC_Ep2[40]; // CXSC_Ep2[0], ... ,CXSC_Ep2[39]
7452  static bool CXSC_Ep2_initialized = false;
7453 
7454  lx_interval Ep2_lx_interval() throw()
7455 // Inclusion of e^2, Blomquist, 27.11.2008;
7456  {
7457  l_interval y;
7458  int stagsave = stagprec,
7459  stagmax = 39;
7460  if (!CXSC_Ep2_initialized)
7461  {
7462  std::string str;
7463  std::cout << SaveOpt;
7464  std::cout << Hex;
7465  str = "+1D8E64B8D4DDAEe7FC";
7466  str >> CXSC_Ep2[0];
7467  str = "-19E62E22EFCA4Ce7C5";
7468  str >> CXSC_Ep2[1];
7469  str = "+1577508F5CF5EDe78F";
7470  str >> CXSC_Ep2[2];
7471  str = "-186EF0294C2511e759";
7472  str >> CXSC_Ep2[3];
7473  str = "+177D109F148782e722";
7474  str >> CXSC_Ep2[4];
7475  str = "+166BBC354AB700e6EB";
7476  str >> CXSC_Ep2[5];
7477  str = "-1273AEC0115969e6B5";
7478  str >> CXSC_Ep2[6];
7479  str = "-1C5AE00D3BEEF1e67F";
7480  str >> CXSC_Ep2[7];
7481  str = "+15ACA3FDC9595Fe647";
7482  str >> CXSC_Ep2[8];
7483  str = "-113FCDFE2B1F0Ce610";
7484  str >> CXSC_Ep2[9];
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];
7545 
7546  CXSC_Ep2_initialized = true;
7547  std::cout << RestoreOpt;
7548  }
7549  stagprec = stagmax;
7550  y = adjust(l_interval(0));
7551 
7552  for (int i=0; i<=stagmax; i++)
7553  y[i+1] = CXSC_Ep2[i];
7554 
7555  stagprec = stagsave;
7556  y = adjust(y);
7557 
7558  return lx_interval(-1019,y);
7559  } // e^2
7560 
7561 // **********************************************************************
7562 
7563  static real CXSC_Ep2r[40]; // CXSC_Ep2r[0], ... ,CXSC_Ep2r[39]
7564  static bool CXSC_Ep2r_initialized = false;
7565 
7566  lx_interval Ep2r_lx_interval() throw()
7567 // Inclusion of 1/e^2, Blomquist, 27.11.2008;
7568  {
7569  l_interval y;
7570  int stagsave = stagprec,
7571  stagmax = 39;
7572  if (!CXSC_Ep2r_initialized)
7573  {
7574  std::string str;
7575  std::cout << SaveOpt;
7576  std::cout << Hex;
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];
7657 
7658  CXSC_Ep2r_initialized = true;
7659  std::cout << RestoreOpt;
7660  }
7661  stagprec = stagmax;
7662  y = adjust(l_interval(0));
7663 
7664  for (int i=0; i<=stagmax; i++)
7665  y[i+1] = CXSC_Ep2r[i];
7666 
7667  stagprec = stagsave;
7668  y = adjust(y);
7669 
7670  return lx_interval(-1025,y);
7671  } // 1/e^2
7672 
7673 // **********************************************************************
7674 
7675  static real CXSC_Ep2Pi[40]; // CXSC_Ep2Pi[0], ... ,CXSC_Ep2Pi[39]
7676  static bool CXSC_Ep2Pi_initialized = false;
7677 
7678  lx_interval Ep2Pi_lx_interval() throw()
7679 // Inclusion of e^(2pi), Blomquist, 27.11.2008;
7680  {
7681  l_interval y;
7682  int stagsave = stagprec,
7683  stagmax = 39;
7684  if (!CXSC_Ep2Pi_initialized)
7685  {
7686  std::string str;
7687  std::cout << SaveOpt;
7688  std::cout << Hex;
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];
7769 
7770  CXSC_Ep2Pi_initialized = true;
7771  std::cout << RestoreOpt;
7772  }
7773  stagprec = stagmax;
7774  y = adjust(l_interval(0));
7775 
7776  for (int i=0; i<=stagmax; i++)
7777  y[i+1] = CXSC_Ep2Pi[i];
7778 
7779  stagprec = stagsave;
7780  y = adjust(y);
7781 
7782  return lx_interval(-1013,y);
7783  } // e^(2pi)
7784 
7785 // **********************************************************************
7786 
7787  static real CXSC_EpPid2[40]; // CXSC_EpPid2[0], ... ,CXSC_EpPid2[39]
7788  static bool CXSC_EpPid2_initialized = false;
7789 
7790  lx_interval EpPid2_lx_interval() throw()
7791 // Inclusion of e^(pi/2), Blomquist, 27.11.2008;
7792  {
7793  l_interval y;
7794  int stagsave = stagprec,
7795  stagmax = 39;
7796  if (!CXSC_EpPid2_initialized)
7797  {
7798  std::string str;
7799  std::cout << SaveOpt;
7800  std::cout << Hex;
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];
7881 
7882  CXSC_EpPid2_initialized = true;
7883  std::cout << RestoreOpt;
7884  }
7885  stagprec = stagmax;
7886  y = adjust(l_interval(0));
7887 
7888  for (int i=0; i<=stagmax; i++)
7889  y[i+1] = CXSC_EpPid2[i];
7890 
7891  stagprec = stagsave;
7892  y = adjust(y);
7893 
7894  return lx_interval(-1020,y);
7895  } // e^(pi/2)
7896 
7897 // **********************************************************************
7898 
7899  static real CXSC_EpPid4[40]; // CXSC_EpPid4[0], ... ,CXSC_EpPid4[39]
7900  static bool CXSC_EpPid4_initialized = false;
7901 
7902  lx_interval EpPid4_lx_interval() throw()
7903 // Inclusion of e^(pi/4), Blomquist, 27.11.2008;
7904  {
7905  l_interval y;
7906  int stagsave = stagprec,
7907  stagmax = 39;
7908  if (!CXSC_EpPid4_initialized)
7909  {
7910  std::string str;
7911  std::cout << SaveOpt;
7912  std::cout << Hex;
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];
7993 
7994  CXSC_EpPid4_initialized = true;
7995  std::cout << RestoreOpt;
7996  }
7997  stagprec = stagmax;
7998  y = adjust(l_interval(0));
7999 
8000  for (int i=0; i<=stagmax; i++)
8001  y[i+1] = CXSC_EpPid4[i];
8002 
8003  stagprec = stagsave;
8004  y = adjust(y);
8005 
8006  return lx_interval(-1021,y);
8007  } // e^(pi/4)
8008 
8009 
8010 // ------------------------------------------------------------------------------
8011 // ---------------- lx_real constants in high accuracy --------------------
8012 // ------------------------------------------------------------------------------
8013 
8014  lx_real Pi_lx_real() throw()
8015  { return mid(Pi_lx_interval()); }
8016  lx_real Pip2_lx_real() throw()
8017  { return mid(Pip2_lx_interval()); }
8018  lx_real Pi2r_lx_real() throw()
8019  { return mid(Pi2r_lx_interval()); }
8020  lx_real Pi2_lx_real() throw()
8021  { return mid(Pi2_lx_interval()); }
8022  lx_real Pid4_lx_real() throw()
8023  { return mid(Pid4_lx_interval()); }
8024  lx_real Pid2_lx_real() throw()
8025  { return mid(Pid2_lx_interval()); }
8026  lx_real Ln2_lx_real() throw()
8027  { return mid(Ln2_lx_interval()); }
8028  lx_real Ln10_lx_real() throw()
8029  { return mid(Ln10_lx_interval()); }
8030  lx_real Ln10r_lx_real() throw()
8031  { return mid(Ln10r_lx_interval()); }
8032  lx_real Pir_lx_real() throw()
8033  { return mid(Pir_lx_interval()); }
8034  lx_real SqrtPi_lx_real() throw()
8035  { return mid(SqrtPi_lx_interval()); }
8036  lx_real Sqrt2Pi_lx_real() throw()
8037  { return mid(Sqrt2Pi_lx_interval()); }
8038  lx_real Sqrt2_lx_real() throw()
8039  { return mid(Sqrt2_lx_interval()); }
8040  lx_real Sqrt2r_lx_real() throw()
8041  { return mid(Sqrt2r_lx_interval()); }
8042  lx_real Sqrt3_lx_real() throw()
8043  { return mid(Sqrt3_lx_interval()); }
8044  lx_real Sqrt3r_lx_real() throw()
8045  { return mid(Sqrt3r_lx_interval()); }
8046  lx_real Sqrt3d2_lx_real() throw()
8047  { return mid(Sqrt3d2_lx_interval()); }
8048  lx_real Ln2r_lx_real() throw()
8049  { return mid(Ln2r_lx_interval()); }
8050  lx_real Pid3_lx_real() throw()
8051  { return mid(Pid3_lx_interval()); }
8052  lx_real SqrtPir_lx_real() throw()
8053  { return mid(SqrtPir_lx_interval()); }
8054  lx_real Sqrt2Pir_lx_real() throw()
8055  { return mid(Sqrt2Pir_lx_interval()); }
8056  lx_real LnPi_lx_real() throw()
8057  { return mid(LnPi_lx_interval()); }
8058  lx_real Ln2Pi_lx_real() throw()
8059  { return mid(Ln2Pi_lx_interval()); }
8060  lx_real E_lx_real() throw()
8061  { return mid(E_lx_interval()); }
8062  lx_real Ep2r_lx_real() throw()
8063  { return mid(Ep2r_lx_interval()); }
8064  lx_real Ep2_lx_real() throw()
8065  { return mid(Ep2_lx_interval()); }
8066  lx_real Er_lx_real() throw()
8067  { return mid(Er_lx_interval()); }
8068  lx_real EpPi_lx_real() throw()
8069  { return mid(EpPi_lx_interval()); }
8070  lx_real EpPid2_lx_real() throw()
8071  { return mid(EpPid2_lx_interval()); }
8072  lx_real EpPid4_lx_real() throw()
8073  { return mid(EpPid4_lx_interval()); }
8074  lx_real Ep2Pi_lx_real() throw()
8075  { return mid(Ep2Pi_lx_interval()); }
8076  lx_real EulerGamma_lx_real() throw()
8077  { return mid(EulerGamma_lx_interval()); }
8078  lx_real Catalan_lx_real() throw()
8079  { return mid(Catalan_lx_interval()); }
8080  lx_real sqrt5_lx_real() throw()
8081  { return mid(sqrt5_lx_interval()); }
8082  lx_real sqrt7_lx_real() throw()
8083  { return mid(sqrt7_lx_interval()); }
8084  lx_real One_m_lx_real() throw()
8085  { return mid(One_m_lx_interval()); }
8086  lx_real One_p_lx_real() throw()
8087  { return mid(One_p_lx_interval()); }
8088 
8089 // --------------------------------------------------------------------------
8090 // -------Elementary functions related to type lx_real ----------------------
8091 // --------------------------------------------------------------------------
8092 
8093  lx_real sqrt(const lx_real& x) throw()
8094  { return mid(sqrt(lx_interval(x))); }
8095  lx_real sqr(const lx_real& x) throw()
8096  { return mid(sqr(lx_interval(x))); }
8097  lx_real ln(const lx_real& x) throw()
8098  { return mid(ln(lx_interval(x))); }
8099  lx_real log2(const lx_real& x) throw()
8100  { return mid(log2(lx_interval(x))); }
8101  lx_real log10(const lx_real& x) throw()
8102  { return mid(log10(lx_interval(x))); }
8103  lx_real lnp1(const lx_real& x) throw()
8104  { return mid(lnp1(lx_interval(x))); }
8105  lx_real exp(const lx_real& x) throw()
8106  { return mid(exp(lx_interval(x))); }
8107  lx_real exp2(const lx_real& x) throw()
8108  { return mid(exp2(lx_interval(x))); }
8109  lx_real exp10(const lx_real& x) throw()
8110  { return mid(exp10(lx_interval(x))); }
8111  lx_real expm1(const lx_real& x) throw()
8112  { return mid(expm1(lx_interval(x))); }
8113  lx_real power(const lx_real& x, const real& r) throw()
8114  { return mid(power(lx_interval(x),r)); }
8115  lx_real pow(const lx_real& x, const lx_real& y) throw()
8116  { return mid(pow(lx_interval(x),lx_interval(y))); }
8117  lx_real xp1_pow_y(const lx_real& x, const lx_real& y) throw()
8118  { return mid(xp1_pow_y(lx_interval(x),lx_interval(y))); }
8119  lx_real sin(const lx_real& x) throw()
8120  { return mid(sin(lx_interval(x))); }
8121  lx_real sin_n(const lx_real& x, const real& n) throw()
8122  { return mid(sin_n(lx_interval(x),n)); }
8123  lx_real cos(const lx_real& x) throw()
8124  { return mid(cos(lx_interval(x))); }
8125  lx_real cos_n(const lx_real& x, const real& n) throw()
8126  { return mid(cos_n(lx_interval(x),n)); }
8127  lx_real tan(const lx_real& x) throw()
8128  { return mid(tan(lx_interval(x))); }
8129  lx_real cot(const lx_real& x) throw()
8130  { return mid(cot(lx_interval(x))); }
8131  lx_real sqrt1px2(const lx_real& x) throw()
8132  { return mid(sqrt1px2(lx_interval(x))); }
8133  lx_real atan(const lx_real& x) throw()
8134  { return mid(atan(lx_interval(x))); }
8135  lx_real sqrt1mx2(const lx_real& x) throw()
8136  { return mid(sqrt1mx2(lx_interval(x))); }
8137  lx_real sqrtx2m1(const lx_real& x) throw()
8138  { return mid(sqrtx2m1(lx_interval(x))); }
8139  lx_real asin(const lx_real& x) throw()
8140  { return mid(asin(lx_interval(x))); }
8141  lx_real acos(const lx_real& x) throw()
8142  { return mid(acos(lx_interval(x))); }
8143  lx_real acot(const lx_real& x) throw()
8144  { return mid(acot(lx_interval(x))); }
8145  lx_real sinh(const lx_real& x) throw()
8146  { return mid(sinh(lx_interval(x))); }
8147  lx_real cosh(const lx_real& x) throw()
8148  { return mid(cosh(lx_interval(x))); }
8149  lx_real tanh(const lx_real& x) throw()
8150  { return mid(tanh(lx_interval(x))); }
8151  lx_real coth(const lx_real& x) throw()
8152  { return mid(coth(lx_interval(x))); }
8153  lx_real sqrtp1m1(const lx_real& x) throw()
8154  { return mid(sqrtp1m1(lx_interval(x))); }
8155  lx_real asinh(const lx_real& x) throw()
8156  { return mid(asinh(lx_interval(x))); }
8157  lx_real acosh(const lx_real& x) throw()
8158  { return mid(acosh(lx_interval(x))); }
8159  lx_real acoshp1(const lx_real& x) throw()
8160  { return mid(acoshp1(lx_interval(x))); }
8161  lx_real atanh(const lx_real& x) throw()
8162  { return mid(atanh(lx_interval(x))); }
8163  lx_real atanh1m(const lx_real& x) throw()
8164  { return mid(atanh1m(lx_interval(x))); }
8165  lx_real atanhm1p(const lx_real& x) throw()
8166  { return mid(atanhm1p(lx_interval(x))); }
8167  lx_real acoth(const lx_real& x) throw()
8168  { return mid(acoth(lx_interval(x))); }
8169  lx_real acothp1(const lx_real& x) throw()
8170  { return mid(acothp1(lx_interval(x))); }
8171  lx_real acothm1m(const lx_real& x) throw()
8172  { return mid(acothm1m(lx_interval(x))); }
8173  lx_real sqrtx2y2(const lx_real& x, const lx_real& y) throw()
8174  { return mid(sqrtx2y2(lx_interval(x),lx_interval(y))); }
8175  lx_real ln_sqrtx2y2(const lx_real& x, const lx_real& y) throw()
8176  { return mid(ln_sqrtx2y2(lx_interval(x),lx_interval(y))); }
8177  lx_real sqrt(const lx_real& x, int n) throw()
8178  { return mid(sqrt(lx_interval(x),n)); }
8179 
8180 } // namespace cxsc
lx_interval Sqrt3_lx_interval()
Enclosure-Interval for .
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
cinterval sqrtx2m1(const cinterval &z)
Calculates .
Definition: cimath.cpp:1109
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:71
lx_interval One_m_lx_interval()
Enclosure-Interval for .
int expo_sm(const l_interval &x)
Definition: l_interval.inl:539
l_interval point_max(void)
Returns a point interval with maximum exponent 1020.
cinterval sqrt1px2(const cinterval &z)
Calculates .
Definition: cimath.cpp:1071
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
lx_real lower_bnd(const lx_real &x)
Returns a rather great lower bound of x.
lx_interval Pid4_lx_interval()
Enclosure-Interval for .
cinterval log2(const cinterval &z)
Calculates .
Definition: cimath.cpp:898
lx_interval Pi2_lx_interval()
Enclosure-Interval for .
lx_real EpPid4_lx_real()
lx_real approximation for
interval sqrtx2y2(const interval &x, const interval &y)
Calculates .
Definition: imath.cpp:80
lx_interval SqrtPi_lx_interval()
Enclosure-Interval for .
cinterval ln(const cinterval &z)
Calculates .
Definition: cimath.cpp:851
lx_real EpPid2_lx_real()
lx_real approximation for
cinterval sin(const cinterval &z)
Calculates .
Definition: cimath.cpp:215
lx_real EpPi_lx_real()
lx_real approximation for
lx_interval SqrtPir_lx_interval()
Enclosure-Interval for .
cinterval cot(const cinterval &z)
Calculates .
Definition: cimath.cpp:538
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
interval ln_sqrtx2y2(const interval &x, const interval &y)
Calculates .
Definition: imath.cpp:581
cinterval acot(const cinterval &z)
Calculates .
Definition: cimath.cpp:3130
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
lx_real E_lx_real()
lx_real approximation for
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
The Scalar Type interval.
Definition: interval.hpp:54
lx_interval Er_lx_interval()
Enclosure-Interval for .
cinterval atan(const cinterval &z)
Calculates .
Definition: cimath.cpp:2938
cinterval acos(const cinterval &z)
Calculates .
Definition: cimath.cpp:2553
lx_real Pid2_lx_real()
lx_real approximation for
cinterval sqr(const cinterval &z)
Calculates .
Definition: cimath.cpp:3342
lx_interval sqrt7_lx_interval()
Enclosure-Interval for .
lx_interval Ln2Pi_lx_interval()
Enclosure-Interval for .
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition: interval.cpp:293
lx_real One_p_lx_real()
lx_real approximation for
lx_interval Catalan_lx_interval()
Enclosure-Interval for .
lx_real sqrt5_lx_real()
lx_real approximation for
lx_interval LnPi_lx_interval()
Enclosure-Interval for .
l_real & operator=(const l_real &)
Implementation of standard assigning operator.
Definition: l_real.cpp:274
cinterval expm1(const cinterval &z)
Calculates .
Definition: cimath.cpp:177
lx_interval cos_n(const lx_interval &x, const real &n)
Calculates .
lx_real Sqrt2_lx_real()
lx_real approximation for
lx_interval Pip2_lx_interval()
Enclosure-Interval for .
lx_real Sqrt3d2_lx_real()
lx_real approximation for
real add_real(const real &a, const real &b)
Returns a,b must be integers with .
Definition: lx_real.inl:75
const real Pi2_real
Constant for rounded to the nearest machine number.
Definition: real.cpp:76
lx_interval One_p_lx_interval()
Enclosure-Interval for .
cinterval tanh(const cinterval &z)
Calculates .
Definition: cimath.cpp:565
cinterval asinh(const cinterval &z)
Calculates .
Definition: cimath.cpp:2718
lx_interval Sqrt2Pi_lx_interval()
Enclosure-Interval for .
cinterval log10(const cinterval &z)
Calculates .
Definition: cimath.cpp:903
lx_real EulerGamma_lx_real()
lx_real approximation for
lx_interval Pir_lx_interval()
Enclosure-Interval for .
lx_interval Pid2_lx_interval()
Enclosure-Interval for .
lx_interval Ep2Pi_lx_interval()
Enclosure-Interval for .
cinterval sqrt1mx2(const cinterval &z)
Calculates .
Definition: cimath.cpp:1140
const real MaxReal
Greatest representable floating-point number.
Definition: real.cpp:65
interval acoshp1(const interval &x)
Calculates .
Definition: imath.cpp:617
lx_interval EpPi_lx_interval()
Enclosure-Interval for .
lx_real SqrtPi_lx_real()
lx_real approximation for
lx_interval Pi2r_lx_interval()
Enclosure-Interval for .
cinterval lnp1(const cinterval &z)
Calculates .
Definition: cimath.cpp:867
lx_real Er_lx_real()
lx_real approximation for
lx_real Catalan_lx_real()
lx_real approximation for
l_interval & operator=(const real &a)
Implementation of standard assigning operator.
Definition: l_interval.inl:89
lx_real Ln2Pi_lx_real()
lx_real approximation for
lx_interval Sqrt3d2_lx_interval()
Enclosure-Interval for .
lx_interval E_lx_interval()
Enclosure-Interval for .
lx_interval Ep2r_lx_interval()
Enclosure-Interval for .
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
lx_interval Ln2_lx_interval()
Enclosure-Interval for .
lx_interval Pi_lx_interval()
Enclosure-Interval for .
lx_real Pid3_lx_real()
lx_real approximation for
real sub_real(const real &a, const real &b)
Returns a,b must be integers with .
Definition: lx_real.inl:84
lx_real upper_bnd(const lx_real &x)
Returns a rather small upper bound of x.
lx_real Pip2_lx_real()
lx_real approximation for
lx_interval Sqrt2_lx_interval()
Enclosure-Interval for .
cinterval sqrt(const cinterval &z)
Calculates .
Definition: cimath.cpp:1007
lx_real Sqrt2Pi_lx_real()
lx_real approximation for
lx_interval Sqrt2Pir_lx_interval()
Enclosure-Interval for .
lx_interval atanh1m(const lx_interval &x)
Calculates .
lx_real sqrt7_lx_real()
lx_real approximation for
lx_interval sin_n(const lx_interval &x, const real &n)
Calculates .
interval & operator=(const real &a)
Implementation of standard assigning operator.
Definition: interval.inl:52
lx_interval Pid3_lx_interval()
Enclosure-Interval for .
cinterval cos(const cinterval &z)
Calculates .
Definition: cimath.cpp:207
lx_real LnPi_lx_real()
lx_real approximation for
lx_interval Ln2r_lx_interval()
Enclosure-Interval for .
l_interval point_any(int n)
Returns a point interval with exponent n.
cinterval atanh(const cinterval &z)
Calculates .
Definition: cimath.cpp:3317
lx_interval atanhm1p(const lx_interval &x)
Calculates .
lx_real Sqrt3_lx_real()
lx_real approximation for
lx_interval Ep2_lx_interval()
Enclosure-Interval for .
lx_interval Sqrt3r_lx_interval()
Enclosure-Interval for .
cinterval exp10(const cinterval &z)
Calculates .
Definition: cimath.cpp:172
lx_interval EulerGamma_lx_interval()
Enclosure-Interval for .
lx_interval EpPid4_lx_interval()
Enclosure-Interval for .
void times2pown(cinterval &x, int n)
Fast multiplication of reference parameter [z] with .
Definition: cimath.cpp:2059
cinterval sqrtp1m1(const cinterval &z)
Calculates .
Definition: cimath.cpp:1054
lx_real Pi2_lx_real()
lx_real approximation for
cinterval exp(const cinterval &z)
Calculates .
Definition: cimath.cpp:159
lx_interval acothp1(const lx_interval &x)
Calculates .
const real MinReal
Smallest normalized representable floating-point number.
Definition: real.cpp:62
lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y)
Calculates .
lx_real Ln2_lx_real()
lx_real approximation for
cinterval cosh(const cinterval &z)
Calculates .
Definition: cimath.cpp:223
lx_real Pir_lx_real()
lx_real approximation for
lx_real Ln2r_lx_real()
lx_real approximation for
int expo_gr(const l_interval &x)
Definition: l_interval.inl:522
l_interval wide_any(int n)
Returns a wide interval with exponent n, .
cinterval tan(const cinterval &z)
Calculates .
Definition: cimath.cpp:393
const real minreal
Smallest positive denormalized representable floating-point number.
Definition: real.cpp:63
lx_interval EpPid2_lx_interval()
Enclosure-Interval for .
cinterval sinh(const cinterval &z)
Calculates .
Definition: cimath.cpp:231
lx_interval Ln10_lx_interval()
Enclosure-Interval for .
lx_real Sqrt2Pir_lx_real()
lx_real approximation for
lx_interval acothm1m(const lx_interval &x)
Calculates .
cinterval exp2(const cinterval &z)
Calculates .
Definition: cimath.cpp:167
lx_real Ep2_lx_real()
lx_real approximation for
lx_real Ep2r_lx_real()
lx_real approximation for
lx_real Ep2Pi_lx_real()
lx_real approximation for
cinterval asin(const cinterval &z)
Calculates .
Definition: cimath.cpp:2311
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
l_interval wide_max(void)
Returns a wide interval with maximum exponent 1020.
cinterval acoth(const cinterval &z)
Calculates .
Definition: cimath.cpp:3330
lx_real Ln10r_lx_real()
lx_real approximation for
lx_real Sqrt2r_lx_real()
lx_real approximation for
lx_real SqrtPir_lx_real()
lx_real approximation for
cinterval coth(const cinterval &z)
Calculates .
Definition: cimath.cpp:578
lx_real Sqrt3r_lx_real()
lx_real approximation for
lx_interval Sqrt2r_lx_interval()
Enclosure-Interval for .
cinterval pow(const cinterval &z, const interval &p)
Calculates .
Definition: cimath.cpp:2074
The Scalar Type real.
Definition: real.hpp:113
lx_real One_m_lx_real()
lx_real approximation for
lx_interval Ln10r_lx_interval()
Enclosure-Interval for .
cinterval power(const cinterval &z, int n)
Calculates .
Definition: cimath.cpp:1941
lx_real Pid4_lx_real()
lx_real approximation for
l_interval Pi2_l_interval()
Enclosure-Interval for .
Definition: l_imath.cpp:1569
bool Is_Integer(const real &x)
Returns 1 if x is an integer value and if .
Definition: lx_real.inl:63
lx_real Ln10_lx_real()
lx_real approximation for
lx_real Pi_lx_real()
lx_real approximation for
lx_interval expo2zero(const lx_interval &a)
b = expo2zero(a) returns with
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cinterval acosh(const cinterval &z)
Calculates .
Definition: cimath.cpp:2732
lx_real Pi2r_lx_real()
lx_real approximation for
lx_interval sqrt5_lx_interval()
Enclosure-Interval for .