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
35namespace cxsc {
36
37// ----------------------------------------------------------------------
38// ------------ Functions related to type lx_interval: ------------------
39// ----------------------------------------------------------------------
40
41lx_interval::lx_interval(const real& n, const string &s) noexcept
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
113void 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
130void 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
148l_interval & l_interval::operator = (const lx_interval &a) noexcept
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
167interval & interval::operator = (const lx_interval &a) noexcept
168{
169 l_interval al;
170 interval z;
171 al = a;
172 z = al;
173 return (*this) = z;
174}
175
176l_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
216lx_interval expo2zero(const lx_interval &a)
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
239lx_interval::lx_interval(const lx_real& a, const lx_real& b) noexcept
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
292lx_interval operator + (const lx_interval &a, const lx_interval &b) noexcept
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
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
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
372lx_interval operator * (const lx_interval &a, const lx_interval &b) noexcept
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
499lx_interval operator / (const lx_interval &a, const lx_interval &b)
500
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
609std::string & operator >> (std::string &s, lx_interval &a) noexcept
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
631void operator >> (const std::string &s, lx_interval &a) noexcept
632{
633// Writes strings s to variable a of type lx_interval;
634 std::string r(s);
635 r >> a;
636}
637
638void operator >> (const char *s, lx_interval &a) noexcept
639{
640 std::string r(s);
641 r >> a;
642}
643
644bool 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
653std::istream & operator >> (std::istream &s, lx_interval &a) noexcept
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
698void 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
755std::ostream& operator << (std::ostream& s,const lx_interval& a) noexcept
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
777std::string & operator << (std::string &s, const lx_interval &a) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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
986bool operator == (const lx_real &a, const lx_real &b) noexcept
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
1017bool operator > (const lx_real &a, const lx_real &b) noexcept
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
1065void scale_up(lx_real &a) noexcept
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
1083void scale_down(lx_real &a) noexcept
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
1102lx_real upper_bnd(const lx_real& x) noexcept
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
1145lx_real lower_bnd(const lx_real& x) noexcept
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
1187lx_real operator + (const lx_real &a, const lx_real &b) noexcept
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
1237lx_real operator * (const lx_real& a, const lx_real& b) noexcept
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
1341lx_real operator / (const lx_real &a, const lx_real &b)
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
1403l_real & l_real::operator = (const lx_real& a) noexcept
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
1419real & real::operator = (const lx_real& a) noexcept
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
1433real 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
1465lx_interval sqrt(const lx_interval &a) noexcept
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
1507lx_interval sqr(const lx_interval &x) noexcept
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
1535lx_interval Lnp1(const lx_interval &x) noexcept
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
1584lx_interval Ln_(const lx_interval &x) noexcept
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
1630lx_interval ln(const lx_interval &x) noexcept
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
1662lx_interval log2(const lx_interval &x) noexcept
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
1676lx_interval log10(const lx_interval &x) noexcept
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
1690lx_interval Lnp1_(const lx_interval &x) noexcept
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
1700lx_interval lnp1(const lx_interval &x) noexcept
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
1737lx_interval Power_(const lx_interval &x, const real &n) noexcept
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
1784lx_interval power(const lx_interval &x, const real &n) noexcept
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
1820int 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
1846lx_interval Exp_(const lx_interval &x) noexcept
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
1899lx_interval exp(const lx_interval &x) noexcept
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
1934lx_interval exp2(const lx_interval &x) noexcept
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
1950lx_interval exp10(const lx_interval &x) noexcept
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
1966lx_interval pow(const lx_interval &x, const lx_interval &e) noexcept
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
2007lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y) noexcept
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
2034int 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
2058lx_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
2090lx_interval EXPm1(const lx_interval &x) noexcept
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
2111lx_interval expm1(const lx_interval &x) noexcept
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
2145real pot3_n[20] = {3.0, 9.0, 27.0, 81.0, 243.0, 729.0, 2187.0, 6561.0,
2146 19683.0, 59049.0, 177147.0, 531441.0, 1594323.0, 4782969.0,
2147 14348907.0, 43046721.0, 129140163.0, 387420489.0,
2148 1162261467.0, 3486784401.0 };
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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) noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
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() noexcept
8015 { return mid(Pi_lx_interval()); }
8016 lx_real Pip2_lx_real() noexcept
8017 { return mid(Pip2_lx_interval()); }
8018 lx_real Pi2r_lx_real() noexcept
8019 { return mid(Pi2r_lx_interval()); }
8020 lx_real Pi2_lx_real() noexcept
8021 { return mid(Pi2_lx_interval()); }
8022 lx_real Pid4_lx_real() noexcept
8023 { return mid(Pid4_lx_interval()); }
8024 lx_real Pid2_lx_real() noexcept
8025 { return mid(Pid2_lx_interval()); }
8026 lx_real Ln2_lx_real() noexcept
8027 { return mid(Ln2_lx_interval()); }
8028 lx_real Ln10_lx_real() noexcept
8029 { return mid(Ln10_lx_interval()); }
8030 lx_real Ln10r_lx_real() noexcept
8031 { return mid(Ln10r_lx_interval()); }
8032 lx_real Pir_lx_real() noexcept
8033 { return mid(Pir_lx_interval()); }
8034 lx_real SqrtPi_lx_real() noexcept
8035 { return mid(SqrtPi_lx_interval()); }
8036 lx_real Sqrt2Pi_lx_real() noexcept
8037 { return mid(Sqrt2Pi_lx_interval()); }
8038 lx_real Sqrt2_lx_real() noexcept
8039 { return mid(Sqrt2_lx_interval()); }
8040 lx_real Sqrt2r_lx_real() noexcept
8041 { return mid(Sqrt2r_lx_interval()); }
8042 lx_real Sqrt3_lx_real() noexcept
8043 { return mid(Sqrt3_lx_interval()); }
8044 lx_real Sqrt3r_lx_real() noexcept
8045 { return mid(Sqrt3r_lx_interval()); }
8046 lx_real Sqrt3d2_lx_real() noexcept
8047 { return mid(Sqrt3d2_lx_interval()); }
8048 lx_real Ln2r_lx_real() noexcept
8049 { return mid(Ln2r_lx_interval()); }
8050 lx_real Pid3_lx_real() noexcept
8051 { return mid(Pid3_lx_interval()); }
8052 lx_real SqrtPir_lx_real() noexcept
8053 { return mid(SqrtPir_lx_interval()); }
8054 lx_real Sqrt2Pir_lx_real() noexcept
8055 { return mid(Sqrt2Pir_lx_interval()); }
8056 lx_real LnPi_lx_real() noexcept
8057 { return mid(LnPi_lx_interval()); }
8058 lx_real Ln2Pi_lx_real() noexcept
8059 { return mid(Ln2Pi_lx_interval()); }
8060 lx_real E_lx_real() noexcept
8061 { return mid(E_lx_interval()); }
8062 lx_real Ep2r_lx_real() noexcept
8063 { return mid(Ep2r_lx_interval()); }
8064 lx_real Ep2_lx_real() noexcept
8065 { return mid(Ep2_lx_interval()); }
8066 lx_real Er_lx_real() noexcept
8067 { return mid(Er_lx_interval()); }
8068 lx_real EpPi_lx_real() noexcept
8069 { return mid(EpPi_lx_interval()); }
8070 lx_real EpPid2_lx_real() noexcept
8071 { return mid(EpPid2_lx_interval()); }
8072 lx_real EpPid4_lx_real() noexcept
8073 { return mid(EpPid4_lx_interval()); }
8074 lx_real Ep2Pi_lx_real() noexcept
8075 { return mid(Ep2Pi_lx_interval()); }
8076 lx_real EulerGamma_lx_real() noexcept
8077 { return mid(EulerGamma_lx_interval()); }
8078 lx_real Catalan_lx_real() noexcept
8079 { return mid(Catalan_lx_interval()); }
8080 lx_real sqrt5_lx_real() noexcept
8081 { return mid(sqrt5_lx_interval()); }
8082 lx_real sqrt7_lx_real() noexcept
8083 { return mid(sqrt7_lx_interval()); }
8084 lx_real One_m_lx_real() noexcept
8085 { return mid(One_m_lx_interval()); }
8086 lx_real One_p_lx_real() noexcept
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) noexcept
8094 { return mid(sqrt(lx_interval(x))); }
8095 lx_real sqr(const lx_real& x) noexcept
8096 { return mid(sqr(lx_interval(x))); }
8097 lx_real ln(const lx_real& x) noexcept
8098 { return mid(ln(lx_interval(x))); }
8099 lx_real log2(const lx_real& x) noexcept
8100 { return mid(log2(lx_interval(x))); }
8101 lx_real log10(const lx_real& x) noexcept
8102 { return mid(log10(lx_interval(x))); }
8103 lx_real lnp1(const lx_real& x) noexcept
8104 { return mid(lnp1(lx_interval(x))); }
8105 lx_real exp(const lx_real& x) noexcept
8106 { return mid(exp(lx_interval(x))); }
8107 lx_real exp2(const lx_real& x) noexcept
8108 { return mid(exp2(lx_interval(x))); }
8109 lx_real exp10(const lx_real& x) noexcept
8110 { return mid(exp10(lx_interval(x))); }
8111 lx_real expm1(const lx_real& x) noexcept
8112 { return mid(expm1(lx_interval(x))); }
8113 lx_real power(const lx_real& x, const real& r) noexcept
8114 { return mid(power(lx_interval(x),r)); }
8115 lx_real pow(const lx_real& x, const lx_real& y) noexcept
8116 { return mid(pow(lx_interval(x),lx_interval(y))); }
8117 lx_real xp1_pow_y(const lx_real& x, const lx_real& y) noexcept
8118 { return mid(xp1_pow_y(lx_interval(x),lx_interval(y))); }
8119 lx_real sin(const lx_real& x) noexcept
8120 { return mid(sin(lx_interval(x))); }
8121 lx_real sin_n(const lx_real& x, const real& n) noexcept
8122 { return mid(sin_n(lx_interval(x),n)); }
8123 lx_real cos(const lx_real& x) noexcept
8124 { return mid(cos(lx_interval(x))); }
8125 lx_real cos_n(const lx_real& x, const real& n) noexcept
8126 { return mid(cos_n(lx_interval(x),n)); }
8127 lx_real tan(const lx_real& x) noexcept
8128 { return mid(tan(lx_interval(x))); }
8129 lx_real cot(const lx_real& x) noexcept
8130 { return mid(cot(lx_interval(x))); }
8131 lx_real sqrt1px2(const lx_real& x) noexcept
8132 { return mid(sqrt1px2(lx_interval(x))); }
8133 lx_real atan(const lx_real& x) noexcept
8134 { return mid(atan(lx_interval(x))); }
8135 lx_real sqrt1mx2(const lx_real& x) noexcept
8136 { return mid(sqrt1mx2(lx_interval(x))); }
8137 lx_real sqrtx2m1(const lx_real& x) noexcept
8138 { return mid(sqrtx2m1(lx_interval(x))); }
8139 lx_real asin(const lx_real& x) noexcept
8140 { return mid(asin(lx_interval(x))); }
8141 lx_real acos(const lx_real& x) noexcept
8142 { return mid(acos(lx_interval(x))); }
8143 lx_real acot(const lx_real& x) noexcept
8144 { return mid(acot(lx_interval(x))); }
8145 lx_real sinh(const lx_real& x) noexcept
8146 { return mid(sinh(lx_interval(x))); }
8147 lx_real cosh(const lx_real& x) noexcept
8148 { return mid(cosh(lx_interval(x))); }
8149 lx_real tanh(const lx_real& x) noexcept
8150 { return mid(tanh(lx_interval(x))); }
8151 lx_real coth(const lx_real& x) noexcept
8152 { return mid(coth(lx_interval(x))); }
8153 lx_real sqrtp1m1(const lx_real& x) noexcept
8154 { return mid(sqrtp1m1(lx_interval(x))); }
8155 lx_real asinh(const lx_real& x) noexcept
8156 { return mid(asinh(lx_interval(x))); }
8157 lx_real acosh(const lx_real& x) noexcept
8158 { return mid(acosh(lx_interval(x))); }
8159 lx_real acoshp1(const lx_real& x) noexcept
8160 { return mid(acoshp1(lx_interval(x))); }
8161 lx_real atanh(const lx_real& x) noexcept
8162 { return mid(atanh(lx_interval(x))); }
8163 lx_real atanh1m(const lx_real& x) noexcept
8164 { return mid(atanh1m(lx_interval(x))); }
8165 lx_real atanhm1p(const lx_real& x) noexcept
8166 { return mid(atanhm1p(lx_interval(x))); }
8167 lx_real acoth(const lx_real& x) noexcept
8168 { return mid(acoth(lx_interval(x))); }
8169 lx_real acothp1(const lx_real& x) noexcept
8170 { return mid(acothp1(lx_interval(x))); }
8171 lx_real acothm1m(const lx_real& x) noexcept
8172 { return mid(acothm1m(lx_interval(x))); }
8173 lx_real sqrtx2y2(const lx_real& x, const lx_real& y) noexcept
8174 { return mid(sqrtx2y2(lx_interval(x),lx_interval(y))); }
8175 lx_real ln_sqrtx2y2(const lx_real& x, const lx_real& y) noexcept
8176 { return mid(ln_sqrtx2y2(lx_interval(x),lx_interval(y))); }
8177 lx_real sqrt(const lx_real& x, int n) noexcept
8178 { return mid(sqrt(lx_interval(x),n)); }
8179
8180} // namespace cxsc
The Scalar Type interval.
Definition interval.hpp:55
interval & operator=(const real &a)
Implementation of standard assigning operator.
Definition interval.inl:52
The Multiple-Precision Data Type l_interval.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
The Scalar Type real.
Definition real.hpp:114
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
lx_interval Sqrt2Pi_lx_interval() noexcept
Enclosure-Interval for .
l_interval wide_max(void)
Returns a wide interval with maximum exponent 1020.
lx_interval Er_lx_interval() noexcept
Enclosure-Interval for .
cinterval sqrtp1m1(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:1054
lx_interval Catalan_lx_interval() noexcept
Enclosure-Interval for .
cinterval exp2(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:167
cinterval sqrt1mx2(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:1140
lx_real LnPi_lx_real() noexcept
lx_real approximation for
const real MinReal
Smallest normalized representable floating-point number.
Definition real.cpp:62
cinterval asinh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:2718
lx_interval SqrtPi_lx_interval() noexcept
Enclosure-Interval for .
l_interval point_max(void)
Returns a point interval with maximum exponent 1020.
lx_real One_m_lx_real() noexcept
lx_real approximation for
lx_real Er_lx_real() noexcept
lx_real approximation for
cinterval coth(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:578
lx_real Sqrt3r_lx_real() noexcept
lx_real approximation for
lx_real SqrtPir_lx_real() noexcept
lx_real approximation for
l_interval Pi2_l_interval() noexcept
Enclosure-Interval for .
Definition l_imath.cpp:1569
lx_interval expo2zero(const lx_interval &a)
b = expo2zero(a) returns with
lx_real E_lx_real() noexcept
lx_real approximation for
cinterval log2(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:898
lx_real EulerGamma_lx_real() noexcept
lx_real approximation for
lx_interval Sqrt2r_lx_interval() noexcept
Enclosure-Interval for .
cinterval power(const cinterval &z, int n) noexcept
Calculates .
Definition cimath.cpp:1941
cinterval log10(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:903
lx_interval Ln10r_lx_interval() noexcept
Enclosure-Interval for .
const real MaxReal
Greatest representable floating-point number.
Definition real.cpp:65
lx_interval EpPid4_lx_interval() noexcept
Enclosure-Interval for .
lx_real Ln2r_lx_real() noexcept
lx_real approximation for
lx_interval cos_n(const lx_interval &x, const real &n) noexcept
Calculates .
lx_interval Pir_lx_interval() noexcept
Enclosure-Interval for .
lx_real sqrt5_lx_real() noexcept
lx_real approximation for
cinterval ln(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:851
lx_real One_p_lx_real() noexcept
lx_real approximation for
lx_interval E_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Pi2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval acothp1(const lx_interval &x) noexcept
Calculates .
lx_interval Sqrt2_lx_interval() noexcept
Enclosure-Interval for .
bool Is_Integer(const real &x)
Returns 1 if x is an integer value and if .
Definition lx_real.inl:63
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
int expo_gr(const l_interval &x)
lx_interval Sqrt3_lx_interval() noexcept
Enclosure-Interval for .
lx_real Sqrt3d2_lx_real() noexcept
lx_real approximation for
lx_interval Ln2_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Sqrt2Pir_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Pid4_lx_interval() noexcept
Enclosure-Interval for .
lx_interval sqrt7_lx_interval() noexcept
Enclosure-Interval for .
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
lx_interval LnPi_lx_interval() noexcept
Enclosure-Interval for .
const real minreal
Smallest positive denormalized representable floating-point number.
Definition real.cpp:63
lx_interval Ln2Pi_lx_interval() noexcept
Enclosure-Interval for .
lx_real EpPid2_lx_real() noexcept
lx_real approximation for
lx_real Sqrt2Pir_lx_real() noexcept
lx_real approximation for
cinterval pow(const cinterval &z, const interval &p) noexcept
Calculates .
Definition cimath.cpp:2074
lx_real EpPi_lx_real() noexcept
lx_real approximation for
lx_interval EpPi_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Sqrt3d2_lx_interval() noexcept
Enclosure-Interval for .
lx_real upper_bnd(const lx_real &x) noexcept
Returns a rather small upper bound of x.
lx_interval Ln10_lx_interval() noexcept
Enclosure-Interval for .
lx_interval EpPid2_lx_interval() noexcept
Enclosure-Interval for .
cinterval sinh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:231
lx_interval atanh1m(const lx_interval &x) noexcept
Calculates .
lx_real Pi2_lx_real() noexcept
lx_real approximation for
cinterval asin(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:2311
interval acoshp1(const interval &x)
Calculates .
Definition imath.cpp:617
lx_real Pi2r_lx_real() noexcept
lx_real approximation for
cinterval tan(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:393
lx_real Ln2_lx_real() noexcept
lx_real approximation for
lx_interval sqrt5_lx_interval() noexcept
Enclosure-Interval for .
cinterval exp10(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:172
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
lx_real Sqrt2Pi_lx_real() noexcept
lx_real approximation for
lx_interval Sqrt3r_lx_interval() noexcept
Enclosure-Interval for .
lx_real Pir_lx_real() noexcept
lx_real approximation for
lx_real Pid2_lx_real() noexcept
lx_real approximation for
lx_real Pid3_lx_real() noexcept
lx_real approximation for
lx_real Pid4_lx_real() noexcept
lx_real approximation for
lx_real Ln10r_lx_real() noexcept
lx_real approximation for
cinterval acos(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:2553
cinterval sqrtx2m1(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:1109
cinterval acosh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:2732
lx_real Ln10_lx_real() noexcept
lx_real approximation for
lx_interval sin_n(const lx_interval &x, const real &n) noexcept
Calculates .
l_interval wide_any(int n)
Returns a wide interval with exponent n, .
lx_interval Ep2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval SqrtPir_lx_interval() noexcept
Enclosure-Interval for .
cinterval cosh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:223
lx_real Sqrt2r_lx_real() noexcept
lx_real approximation for
cinterval cos(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:207
real add_real(const real &a, const real &b) noexcept
Returns a,b must be integers with .
Definition lx_real.inl:75
lx_interval Ln2r_lx_interval() noexcept
Enclosure-Interval for .
lx_interval Ep2_lx_interval() noexcept
Enclosure-Interval for .
lx_interval One_p_lx_interval() noexcept
Enclosure-Interval for .
lx_real Catalan_lx_real() noexcept
lx_real approximation for
lx_real Sqrt2_lx_real() noexcept
lx_real approximation for
lx_real Ep2_lx_real() noexcept
lx_real approximation for
cinterval sqrt1px2(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:1071
lx_real lower_bnd(const lx_real &x) noexcept
Returns a rather great lower bound of x.
cinterval exp(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:159
lx_real Ep2Pi_lx_real() noexcept
lx_real approximation for
real sub_real(const real &a, const real &b) noexcept
Returns a,b must be integers with .
Definition lx_real.inl:84
lx_interval Pi_lx_interval() noexcept
Enclosure-Interval for .
cinterval tanh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:565
interval ln_sqrtx2y2(const interval &x, const interval &y) noexcept
Calculates .
Definition imath.cpp:581
const real Pi2_real
Constant for rounded to the nearest machine number.
Definition real.cpp:76
lx_interval Pid2_lx_interval() noexcept
Enclosure-Interval for .
lx_real Pip2_lx_real() noexcept
lx_real approximation for
cinterval expm1(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:177
cinterval cot(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:538
lx_interval Ep2Pi_lx_interval() noexcept
Enclosure-Interval for .
lx_real SqrtPi_lx_real() noexcept
lx_real approximation for
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cinterval sqrt(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:1007
cinterval acot(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:3130
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
Definition cimath.cpp:2059
lx_interval Pid3_lx_interval() noexcept
Enclosure-Interval for .
cinterval sqr(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:3342
lx_interval atanhm1p(const lx_interval &x) noexcept
Calculates .
lx_real EpPid4_lx_real() noexcept
lx_real approximation for
cinterval lnp1(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:867
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
cinterval atan(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:2938
cinterval atanh(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:3317
lx_interval acothm1m(const lx_interval &x) noexcept
Calculates .
l_interval point_any(int n)
Returns a point interval with exponent n.
lx_real Sqrt3_lx_real() noexcept
lx_real approximation for
cinterval acoth(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:3330
lx_interval Pi2_lx_interval() noexcept
Enclosure-Interval for .
interval sqrtx2y2(const interval &x, const interval &y) noexcept
Calculates .
Definition imath.cpp:80
lx_real Pi_lx_real() noexcept
lx_real approximation for
lx_interval One_m_lx_interval() noexcept
Enclosure-Interval for .
lx_real Ln2Pi_lx_real() noexcept
lx_real approximation for
int expo_sm(const l_interval &x)
lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y) noexcept
Calculates .
lx_interval Pip2_lx_interval() noexcept
Enclosure-Interval for .
cinterval sin(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:215
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
lx_real Ep2r_lx_real() noexcept
lx_real approximation for
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition interval.cpp:293
lx_interval EulerGamma_lx_interval() noexcept
Enclosure-Interval for .
lx_real sqrt7_lx_real() noexcept
lx_real approximation for