C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
lx_interval.hpp
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.hpp,v 1.10 2014/01/30 17:23:47 cxsc Exp $ */
25 
26 
27 /*
28 ** F. Blomquist, University of Wuppertal, 19.09.2007;
29 */
30 
31 /*
32 ** Implementation of the classes
33 **
34 ** lx_interval with all tools and elementary functions for real
35 ** point and interval aruments
36 **
37 */
38 
39 #ifndef _CXSC_LX_INTERVAL_HPP_INCLUDED
40 #define _CXSC_LX_INTERVAL_HPP_INCLUDED
41 
42 #include <l_imath.hpp>
43 #include <lx_real.hpp>
44 #include <sstream>
45 #include <cmath>
46 #include <iostream>
47 
48 namespace cxsc {
49 
50 class lx_interval {
51 
52 private:
53  // ------------- Data Elements -------------------------------------------
54  real ex;
55  l_interval li;
56  // The mathematical value of an object of type lx_interval is
57  // interpreted as: 2^(ex) * li;
58 
59 public:
60  // ------------- Constructors --------------------------------------------
61 
63  lx_interval(void) throw() {}
64 
66  lx_interval(const real& n, const l_interval& a) throw()
67  {
68  if ( !(Is_Integer(n)) )
69  cxscthrow(REAL_NOT_ALLOWED("lx_interval(const real&, const l_interval&)"));
70  else
71  {
72  ex = n; li = a;
73  }
74  }
75 
77  lx_interval(const real& n, const l_real& a) throw()
78  {
79  if ( !(Is_Integer(n)) )
80  cxscthrow(REAL_NOT_ALLOWED("lx_interval(const real& n, const l_real& a)"));
81  else
82  {
83  ex = n; li = a;
84  }
85  }
86 
88  lx_interval(const real& n, const interval& a) throw()
89  {
90  if ( !(Is_Integer(n)) )
91  cxscthrow(REAL_NOT_ALLOWED("lx_interval(const real&, const interval&)"));
92  else
93  {
94  ex = n; li = a;
95  }
96  }
97 
99  explicit lx_interval(const real& n, const real& a) throw()
100  {
101  if ( !(Is_Integer(n)) )
102  cxscthrow(REAL_NOT_ALLOWED("lx_interval(const real&, const real&)"));
103  else
104  {
105  ex = n; li = a;
106  }
107  }
109  explicit lx_interval(const l_interval& a) throw() : ex(0), li(a) { }
111  explicit lx_interval(const l_real& a) throw() : ex(0), li(a) { }
113  lx_interval(const l_real& a, const l_real& b) throw() : ex(0),li(a,b) { }
115  explicit lx_interval(const interval& a) throw() : ex(0), li(a) { }
117  explicit lx_interval(const real& a) throw() : ex(0), li(a) { }
119  lx_interval(const lx_real&, const lx_real&) throw();
121  explicit lx_interval(const lx_real& a)
122  throw() : ex(expo(a)), li(lr_part(a)) { }
124  lx_interval(const real&, const string&) throw();
125 
126  // ------------- Assignments ---------------------------------------------
127 
129  inline lx_interval & operator = (const lx_interval & a) throw();
131  inline lx_interval & operator = (const l_interval & a) throw();
133  inline lx_interval & operator = (const l_real & a) throw();
135  inline lx_interval & operator = (const real & a) throw();
137  inline lx_interval & operator = (const interval & a) throw();
139  inline lx_interval & operator = (const lx_real & a) throw();
140 
141  // l_interval & operator = (const lx_interval &a) throw(); declared
142  // in l_interval.hpp and implemented in lx_interval.cpp;
143 
144  // interval & operator = (const lx_interval &a) throw(); declared
145  // in interval.hpp and implemented in lx_interval.cpp;
146 
147  // ------------- Functions -----------------------------------------------
148 
150  friend inline int StagPrec(const lx_interval&) throw();
152  friend inline real expo(const lx_interval&) throw();
154  friend inline l_interval li_part(const lx_interval&) throw();
156  friend void scale_down(lx_interval &a);
158  friend void scale_up (lx_interval &a);
159 
161  friend inline lx_interval adjust(const lx_interval &) throw();
163  friend inline lx_interval abs(const lx_interval &) throw();
165  friend inline bool point_intv(const lx_interval &);
167  friend inline bool operator ! (const lx_interval &) throw();
169  friend inline bool IsEmpty(const lx_interval &) throw();
171  friend inline void times2pown(lx_interval &, const real &) throw();
173  friend inline lx_interval Blow(const lx_interval &) throw();
175  friend inline void times2pown_neg(lx_interval &, const real&) throw();
177  friend inline lx_real RelDiam( const lx_interval &);
179  friend inline lx_real diam(const lx_interval &) throw();
181  friend inline lx_real mid(const lx_interval &) throw();
183  friend inline lx_real Inf(const lx_interval &) throw();
185  friend inline lx_real Sup(const lx_interval &) throw();
186 
187  // ---------------- Monadic arithmetic operator ---------------------
188 
190  friend inline lx_interval operator-(const lx_interval & a) throw();
191 
192 
193  // ----------------------- Output -----------------------------------
194 
196  friend std::ostream& operator << (std::ostream&, const lx_interval&)
197  throw();
198 
200  friend std::string & operator << (std::string&, const lx_interval&)
201  throw();
202 
203 }; // end of class lx_interval
204 
205 
206 // -------------------------------------------------------------------
207 // Declaration of friend functions outside the class lx_interval
208 // -------------------------------------------------------------------
209 
210 inline int StagPrec(const lx_interval &a) throw();
211 inline real expo(const lx_interval &a) throw();
212 inline l_interval li_part(const lx_interval &a) throw();
213 
214  void scale_down(lx_interval &);
215  void scale_up (lx_interval &);
216 inline bool point_intv(const lx_interval &);
217 inline bool IsEmpty(const lx_interval &) throw();
218 inline void times2pown(lx_interval &, const real &) throw();
219 inline lx_interval Blow(const lx_interval &) throw();
220 inline void times2pown_neg(lx_interval &, const real&) throw();
221 inline lx_real RelDiam(const lx_interval &);
222 inline lx_real Inf(const lx_interval &) throw();
223 inline lx_real Sup(const lx_interval &) throw();
224 inline lx_interval abs(const lx_interval &) throw();
225 inline lx_interval adjust(const lx_interval &) throw();
226 inline lx_real diam(const lx_interval &) throw();
227 inline lx_real mid(const lx_interval &) throw();
228 
229 // ------------------------ Input --------------------------------------
230 
232  std::string & operator >> (std::string &s, lx_interval &a) throw();
234  void operator >> (const std::string &s, lx_interval &a) throw();
236  void operator >> (const char *s, lx_interval&) throw();
237 
239  std::istream & operator >> (std::istream&, lx_interval&) throw();
240 
241 // ------------------------ Output --------------------------------------
242 
243 std::ostream& operator << (std::ostream& s,const lx_interval& a) throw();
244 // A value a of type lx_interval is written to the
245 // output channel as decimal number in the form:
246 // { exponent p to base 10, interval mantissa m } = 10^p * m;
247 
248 std::string & operator << (std::string &s,const lx_interval& a) throw();
249 // The value of a variable a of type lx_interval is copied to a string s.
250 // s has the form: {2**(ex), li} = 2^ex * li;
251 
252 
253 // -------------------------------------------------------------------
254 // ------- Function declarations outside the class lx_interval --------
255 // -------------------------------------------------------------------
256 
257 void Bin2Dec(const lx_interval& a, real& p, l_interval& m);
258 
260 lx_interval expo2zero(const lx_interval &) throw(OVERFLOW_ERROR);
262 inline int Disjoint(const lx_interval &, const lx_interval &);
264 inline int in (const lx_interval&, const lx_interval&);
266 inline int in (const l_interval&, const lx_interval&);
268 inline int in (const interval&, const lx_interval&);
269 
271 inline int in (const lx_real&, const lx_interval&);
273 inline int in (const l_real&, const lx_interval&);
275 inline int in (const real&, const lx_interval&);
276 
278 inline lx_interval Blow( const lx_interval&, const real& );
280 inline lx_real AbsMin (const lx_interval&);
282 inline lx_real AbsMax (const lx_interval&);
283 
284 // -----------------------------------------------------------------------
285 // ------------- set comparisons -----------------------------------------
286 // -----------------------------------------------------------------------
287 
288 // ---- lx_interval--lx_interval
289 
291 inline bool operator < (const lx_interval&, const lx_interval&) throw();
293 inline bool operator <= (const lx_interval&, const lx_interval&) throw();
295 inline bool operator > (const lx_interval&, const lx_interval&) throw();
297 inline bool operator >= (const lx_interval&, const lx_interval&) throw();
298 
299 // ---- lx_interval--l_interval
300 
302 inline bool operator < (const lx_interval&, const l_interval&) throw();
304 inline bool operator <= (const lx_interval&, const l_interval&) throw();
306 inline bool operator < (const l_interval&, const lx_interval&) throw();
308 inline bool operator <= (const l_interval&, const lx_interval&) throw();
310 inline bool operator > (const lx_interval&, const l_interval&) throw();
311 inline bool operator >= (const lx_interval&, const l_interval&) throw();
313 inline bool operator > (const l_interval&, const lx_interval&) throw();
315 inline bool operator >= (const l_interval&, const lx_interval&) throw();
316 
317 // ---- lx_interval--interval
318 
320 inline bool operator < (const lx_interval&, const interval&) throw();
322 inline bool operator <= (const lx_interval&, const interval&) throw();
324 inline bool operator < (const interval&, const lx_interval&) throw();
326 inline bool operator <= (const interval&, const lx_interval&) throw();
328 inline bool operator > (const lx_interval&, const interval&) throw();
330 inline bool operator >= (const lx_interval&, const interval&) throw();
332 inline bool operator > (const interval&, const lx_interval&) throw();
334 inline bool operator >= (const interval&, const lx_interval&) throw();
335 
336 // ---- lx_interval--real
337 
339 inline bool operator < (const real &, const lx_interval &) throw();
341 inline bool operator <= (const real &, const lx_interval &) throw();
343 inline bool operator > (const lx_interval &, const real &) throw();
345 inline bool operator >= (const lx_interval &, const real &) throw();
346 
347 // ---- lx_interval--l_real
348 
350 inline bool operator < (const l_real &, const lx_interval &) throw();
352 inline bool operator <= (const l_real &, const lx_interval &) throw();
354 inline bool operator > (const lx_interval &, const l_real &) throw();
356 inline bool operator >= (const lx_interval &, const l_real &) throw();
357 
358 // ---- lx_interval--lx_real
359 
361 inline bool operator < (const lx_real &, const lx_interval &) throw();
363 inline bool operator <= (const lx_real &, const lx_interval &) throw();
365 inline bool operator > (const lx_interval &, const lx_real &) throw();
367 inline bool operator >= (const lx_interval &, const lx_real &) throw();
368 
369 
370 // -------------------------- comparisons --------------------------------
371 
373 inline bool operator ! (const lx_interval &) throw();
374 
376 inline bool operator == (const lx_interval &, const lx_interval &) throw();
378 inline bool operator == (const lx_interval &, const l_interval &) throw();
380 inline bool operator == (const l_interval &, const lx_interval &) throw();
382 inline bool operator == (const lx_interval &, const interval &) throw();
384 inline bool operator == (const interval &, const lx_interval &) throw();
386 inline bool operator == (const lx_interval &, const real &) throw();
388 inline bool operator == (const real &, const lx_interval &) throw();
390 inline bool operator == (const lx_interval &, const l_real &) throw();
392 inline bool operator == (const l_real &, const lx_interval &) throw();
394 inline bool operator == (const lx_interval &, const lx_real &) throw();
396 inline bool operator == (const lx_real &, const lx_interval &) throw();
397 
399 inline bool operator != (const lx_interval &, const lx_interval &) throw();
401 inline bool operator != (const lx_interval &, const l_interval &) throw();
403 inline bool operator != (const l_interval &, const lx_interval &) throw();
405 inline bool operator != (const lx_interval &, const interval &) throw();
407 inline bool operator != (const interval &, const lx_interval &) throw();
409 inline bool operator != (const lx_interval &, const real &) throw();
411 inline bool operator != (const real &, const lx_interval &) throw();
413 inline bool operator != (const lx_interval &, const l_real &) throw();
415 inline bool operator != (const l_real &, const lx_interval &) throw();
417 inline bool operator != (const lx_interval &, const lx_real &) throw();
419 inline bool operator != (const lx_real &, const lx_interval &) throw();
420 
422 inline lx_interval operator+(const lx_interval &) throw();
424 inline lx_interval operator-(const lx_interval &) throw();
425 
427 lx_interval operator + (const lx_interval &, const lx_interval &) throw();
428 
430 inline lx_interval operator + (const lx_interval &, const l_interval &)
431  throw();
433 inline lx_interval operator + (const l_interval &, const lx_interval &)
434  throw();
436 inline lx_interval operator + (const lx_interval &, const l_real &)
437  throw();
439 inline lx_interval operator + (const l_real &, const lx_interval &)
440  throw();
442 inline lx_interval operator + (const lx_interval &, const lx_real &)
443  throw();
445 inline lx_interval operator + (const lx_real &, const lx_interval &)
446  throw();
448 inline lx_interval operator + (const lx_interval &, const real &)
449  throw();
451 inline lx_interval operator + (const real &, const lx_interval &)
452  throw();
454 inline lx_interval operator + (const lx_interval &, const interval &)
455  throw();
457 inline lx_interval operator + (const interval &, const lx_interval &)
458  throw();
459 
461 inline lx_interval & operator +=(lx_interval &, const lx_interval &) throw();
463 inline lx_interval & operator +=(lx_interval &, const l_interval &) throw();
465 inline lx_interval & operator +=(lx_interval &, const l_real &) throw();
467 inline lx_interval & operator +=(lx_interval &, const lx_real &) throw();
469 inline lx_interval & operator +=(lx_interval &, const real &) throw();
471 inline lx_interval & operator +=(lx_interval &, const interval &) throw();
472 
474 inline lx_interval operator - (const lx_interval &, const lx_interval &)
475  throw();
477 inline lx_interval operator - (const lx_interval &, const l_interval &)
478  throw();
480 inline lx_interval operator - (const l_interval &, const lx_interval &)
481  throw();
483 inline lx_interval operator - (const lx_interval &, const l_real &)
484  throw();
486 inline lx_interval operator - (const l_real &, const lx_interval &)
487  throw();
489 inline lx_interval operator - (const lx_interval &, const lx_real &)
490  throw();
492 inline lx_interval operator - (const lx_real &, const lx_interval &)
493  throw();
495 inline lx_interval operator - (const lx_interval &, const real &)
496  throw();
498 inline lx_interval operator - (const real &, const lx_interval &)
499  throw();
501 inline lx_interval operator - (const lx_interval &, const interval &)
502  throw();
504 inline lx_interval operator - (const interval &, const lx_interval &)
505  throw();
506 
508 inline lx_interval & operator -=(lx_interval &, const lx_interval &) throw();
510 inline lx_interval & operator -=(lx_interval &, const l_interval &) throw();
512 inline lx_interval & operator -=(lx_interval &, const l_real &) throw();
514 inline lx_interval & operator -=(lx_interval &, const lx_real &) throw();
516 inline lx_interval & operator -=(lx_interval &, const real &) throw();
518 inline lx_interval & operator -=(lx_interval &, const interval &) throw();
519 
521 lx_interval operator * (const lx_interval &, const lx_interval &)
522  throw();
523 
525 inline lx_interval operator * (const lx_interval &, const l_interval &)
526  throw();
528 inline lx_interval operator * (const l_interval &, const lx_interval &)
529  throw();
531 inline lx_interval operator * (const lx_interval &, const l_real &)
532  throw();
534 inline lx_interval operator * (const l_real &, const lx_interval &)
535  throw();
537 inline lx_interval operator * (const lx_interval &, const lx_real &)
538  throw();
540 inline lx_interval operator * (const lx_real &, const lx_interval &)
541  throw();
543 inline lx_interval operator * (const lx_interval &, const real &)
544  throw();
546 inline lx_interval operator * (const real &, const lx_interval &)
547  throw();
549 inline lx_interval operator * (const lx_interval &, const interval &)
550  throw();
552 inline lx_interval operator * (const interval &, const lx_interval &)
553  throw();
554 
556 inline lx_interval & operator *=(lx_interval &, const lx_interval &) throw();
558 inline lx_interval & operator *=(lx_interval &, const l_interval &) throw();
560 inline lx_interval & operator *=(lx_interval &, const l_real &) throw();
562 inline lx_interval & operator *=(lx_interval &, const lx_real &) throw();
564 inline lx_interval & operator *=(lx_interval &, const real &) throw();
566 inline lx_interval & operator *=(lx_interval &, const interval &) throw();
567 
569 lx_interval operator / (const lx_interval &, const lx_interval &)
570  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
571 
573 inline lx_interval operator / (const lx_interval &, const l_interval &)
574  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
576 inline lx_interval operator / (const l_interval &, const lx_interval &)
577  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
579 inline lx_interval operator / (const lx_interval &, const l_real &)
580  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
582 inline lx_interval operator / (const l_real &, const lx_interval &)
583  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
585 inline lx_interval operator / (const lx_interval &, const real &)
586  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
588 inline lx_interval operator / (const real &, const lx_interval &)
589  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
591 inline lx_interval operator / (const lx_interval &, const interval &)
592  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
594 inline lx_interval operator / (const interval &, const lx_interval &)
595  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
597 inline lx_interval operator / (const lx_interval &, const lx_real &)
598  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
600 inline lx_interval operator / (const lx_real &, const lx_interval &)
601  throw(ERROR_LINTERVAL_DIV_BY_ZERO);
602 
604 inline lx_interval & operator /=(lx_interval &, const lx_interval &) throw();
606 inline lx_interval & operator /=(lx_interval &, const l_interval &) throw();
608 inline lx_interval & operator /=(lx_interval &, const l_real &) throw();
610 inline lx_interval & operator /=(lx_interval &, const lx_real &) throw();
612 inline lx_interval & operator /=(lx_interval &, const real &) throw();
614 inline lx_interval & operator /=(lx_interval &, const interval &) throw();
615 
616 // ----------------------------- Convex hull -------------------------------
617 
619  inline lx_interval operator | (const lx_interval&, const lx_interval&)
620  throw();
622  inline lx_interval operator | (const lx_interval&, const l_interval&)
623  throw();
625  inline lx_interval operator | (const l_interval&, const lx_interval&)
626  throw();
628  inline lx_interval operator | (const lx_interval&, const interval&)
629  throw();
631  inline lx_interval operator | (const interval&, const lx_interval&)
632  throw();
634  inline lx_interval & operator |= (lx_interval&, const lx_interval&)
635  throw();
637  inline lx_interval & operator |= (lx_interval&, const l_interval&)
638  throw();
640  inline lx_interval & operator |= (lx_interval&, const interval&)
641  throw();
643  inline lx_interval operator | (const lx_real&, const lx_interval&)
644  throw();
646  inline lx_interval operator | (const real&, const lx_interval&)
647  throw();
649  inline lx_interval operator | (const lx_interval&, const lx_real&)
650  throw();
652  inline lx_interval operator | (const lx_interval&, const real&)
653  throw();
655  inline lx_interval operator | (const lx_interval&, const l_real&)
656  throw();
658  inline lx_interval operator | (const l_real&, const lx_interval&)
659  throw();
661  inline lx_interval & operator |= (lx_interval&, const real&)
662  throw();
664  inline lx_interval & operator |= (lx_interval&, const l_real&)
665  throw();
667  inline lx_interval & operator |= (lx_interval&, const lx_real&)
668  throw();
670  inline lx_interval operator | (const lx_real&, const lx_real&)
671  throw();
672 
673 // --------------------------- Intersection -----------------------------
674 
676  inline lx_interval operator & (const lx_interval&, const lx_interval&)
677  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
679  inline lx_interval operator & (const lx_interval&, const l_interval&)
680  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
682  inline lx_interval & operator &= (lx_interval&, const l_interval&)
683  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
685  inline lx_interval operator & (const l_interval&, const lx_interval&)
686  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
688  inline lx_interval operator & (const lx_interval&, const interval&)
689  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
691  inline lx_interval & operator &= (lx_interval &a, const interval &b)
692  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
694  inline lx_interval operator & (const interval&, const lx_interval&)
695  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
697  inline lx_interval & operator &= (lx_interval&, const lx_interval&)
698  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
700  inline lx_interval operator & (const lx_interval&, const lx_real&)
701  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
703  inline lx_interval operator & (const lx_interval&, const l_real&)
704  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
706  inline lx_interval operator & (const lx_interval&, const real&)
707  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
709  inline lx_interval operator & (const lx_real&, const lx_interval&)
710  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
712  inline lx_interval operator & (const l_real&, const lx_interval&)
713  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
715  inline lx_interval operator & (const real&, const lx_interval&)
716  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
718  inline lx_interval & operator &= (lx_interval&, const lx_real&)
719  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
721  inline lx_interval & operator &= (lx_interval&, const l_real&)
722  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
724  inline lx_interval & operator &= (lx_interval&, const real&)
725  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
726 
727 // ------------------------- SetInf, SetSup -----------------------------
728 
730 inline lx_interval & SetInf(lx_interval&, const lx_real&)
731  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
733 inline lx_interval & SetInf(lx_interval&, const l_real&)
734  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
736 inline lx_interval & SetInf(lx_interval&, const real&)
737  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
738 
740 inline lx_interval & SetSup(lx_interval&, const lx_real&)
741  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
743 inline lx_interval & SetSup(lx_interval&, const l_real&)
744  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
746 inline lx_interval & SetSup(lx_interval&, const real&)
747  throw(ERROR_LINTERVAL_EMPTY_INTERVAL);
748 
749 // ------------------------- Help Functions: ----------------------------
750 
751 // ----------------- Intervals for test calculations --------------------
752 
754 l_interval point_max(void);
755 // returns a staggered point interval with maximum exponent 1020,
756 // whereby nearly all mantissa bits are set.
757 
759 l_interval point_any(int n);
760 // returns a staggered point interval with exponent n,
761 // whereby nearly all mantissa bits are set.
762 // -1074 <= n <= +1020;
763 
765 l_interval wide_max(void);
766 // returns a staggered interval a with maximum exponent 1020
767 // and diam(a)>0, whereby nearly all mantissa bits are set.
768 
770 l_interval wide_any(int n);
771 // returns a wide staggered interval a with exponent n,
772 // and diam(a)>0, whereby nearly all mantissa bits are set.
773 // -1074 <= n <= +1020;
774 
775 
776 // --------------------------------------------------------------------
777 // ----------------- lx_interval Constants ----------------------------
778 // --------------------------------------------------------------------
779 
781  lx_interval Pi_lx_interval() throw(); // pi
783  lx_interval Pip2_lx_interval() throw(); // pi^2
785  lx_interval Pi2_lx_interval() throw(); // 2*pi
787  lx_interval Pi2r_lx_interval() throw(); // 1/(2*pi)
789  lx_interval Pid4_lx_interval() throw(); // pi/4
791  lx_interval Pid2_lx_interval() throw(); // pi/2
793  lx_interval Ln2_lx_interval() throw(); // ln(2)
795  lx_interval Ln10_lx_interval() throw(); // ln(10)
797  lx_interval Ln10r_lx_interval() throw(); // 1/ln(10)
799  lx_interval Pir_lx_interval() throw(); // 1/pi
801  lx_interval SqrtPi_lx_interval() throw(); // sqrt(pi)
803  lx_interval Sqrt2Pi_lx_interval() throw(); // sqrt(2pi)
805  lx_interval Sqrt2_lx_interval() throw(); // sqrt(2)
807  lx_interval Sqrt2r_lx_interval() throw(); // sqrt(2)
809  lx_interval Sqrt3_lx_interval() throw(); // sqrt(3)
811  lx_interval Sqrt3d2_lx_interval() throw(); // sqrt(3)/2
813  lx_interval Sqrt3r_lx_interval() throw(); // 1/sqrt(3)
815  lx_interval Ln2r_lx_interval() throw(); // 1/ln(2)
817  lx_interval Pid3_lx_interval() throw(); // pi/3
819  lx_interval SqrtPir_lx_interval() throw(); // 1/sqrt(pi)
821  lx_interval Sqrt2Pir_lx_interval() throw(); // 1/sqrt(2pi)
823  lx_interval LnPi_lx_interval() throw(); // ln(pi)
825  lx_interval Ln2Pi_lx_interval() throw(); // ln(2pi)
827  lx_interval E_lx_interval() throw(); // e
829  lx_interval Ep2_lx_interval() throw(); // e^2
831  lx_interval Ep2r_lx_interval() throw(); // 1/e^2
833  lx_interval Er_lx_interval() throw(); // 1/e
835  lx_interval EpPi_lx_interval() throw(); // e^pi
837  lx_interval EpPid2_lx_interval() throw(); // e^(pi/2)
839  lx_interval EpPid4_lx_interval() throw(); // e^(pi/4)
841  lx_interval Ep2Pi_lx_interval() throw(); // e^(2*pi)
843  lx_interval EulerGamma_lx_interval() throw();
845  lx_interval Catalan_lx_interval() throw();
847  lx_interval sqrt5_lx_interval() throw(); // sqrt(5)
849  lx_interval sqrt7_lx_interval() throw(); // sqrt(7)
851  lx_interval One_m_lx_interval() throw();
853  lx_interval One_p_lx_interval() throw();
854 
855 // -------------------------------------------------------------------------
856 // ---------------- lx_interval: elementary functions ----------------------
857 // -------------------------------------------------------------------------
858 
860  lx_interval sqrt(const lx_interval&) throw();
862  lx_interval sqr(const lx_interval&) throw();
864  lx_interval ln(const lx_interval &) throw();
866  lx_interval log2(const lx_interval &) throw();
868  lx_interval log10(const lx_interval &) throw();
870  lx_interval lnp1(const lx_interval &) throw();
872  lx_interval exp(const lx_interval &) throw();
874  lx_interval exp2(const lx_interval &) throw(); // 2^x
876  lx_interval exp10(const lx_interval &) throw(); // 10^x
878  lx_interval expm1(const lx_interval &x) throw();
880  lx_interval power(const lx_interval &, const real &) throw();
882  lx_interval pow(const lx_interval &, const lx_interval &) throw();
884  lx_interval xp1_pow_y(const lx_interval &, const lx_interval &) throw();
886  lx_interval sin(const lx_interval &)throw();
888  lx_interval sin_n(const lx_interval &x, const real& n) throw();
890  lx_interval cos(const lx_interval &) throw();
892  lx_interval cos_n(const lx_interval &x, const real& n) throw();
894  lx_interval tan(const lx_interval &) throw();
896  lx_interval cot(const lx_interval &) throw();
898  lx_interval sqrt1px2(const lx_interval &) throw();
900  lx_interval atan(const lx_interval &) throw();
902  lx_interval sqrt1mx2(const lx_interval &) throw();
904  lx_interval sqrtx2m1(const lx_interval &) throw();
906  lx_interval asin(const lx_interval & ) throw();
908  lx_interval acos(const lx_interval &) throw();
910  lx_interval acot(const lx_interval &) throw();
912  lx_interval sinh(const lx_interval &) throw();
914  lx_interval cosh(const lx_interval &) throw();
916  lx_interval tanh(const lx_interval &) throw();
918  lx_interval coth(const lx_interval &) throw();
920  lx_interval sqrtp1m1(const lx_interval &) throw();
922  lx_interval asinh(const lx_interval &) throw();
924  lx_interval acosh(const lx_interval &) throw();
926  lx_interval acoshp1(const lx_interval &) throw();
928  lx_interval atanh(const lx_interval &) throw();
930  lx_interval atanh1m(const lx_interval &) throw();
932  lx_interval atanhm1p(const lx_interval &) throw();
934  lx_interval acoth(const lx_interval &) throw();
936  lx_interval acothp1(const lx_interval &) throw();
938  lx_interval acothm1m(const lx_interval &) throw();
940  lx_interval sqrtx2y2(const lx_interval &, const lx_interval &) throw();
942  lx_interval ln_sqrtx2y2(const lx_interval &, const lx_interval &) throw();
944  lx_interval sqrt(const lx_interval &, int) throw();
945 
946 } // end namespace cxsc
947 
948 #include "lx_interval.inl"
949 
950 #endif // _CXSC_LX_INTERVAL_HPP_INCLUDED
lx_interval Sqrt3_lx_interval()
Enclosure-Interval for .
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
cinterval sqrtx2m1(const cinterval &z)
Calculates .
Definition: cimath.cpp:1109
lx_interval One_m_lx_interval()
Enclosure-Interval for .
l_interval point_max(void)
Returns a point interval with maximum exponent 1020.
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cinterval sqrt1px2(const cinterval &z)
Calculates .
Definition: cimath.cpp:1071
lx_interval Pid4_lx_interval()
Enclosure-Interval for .
cinterval log2(const cinterval &z)
Calculates .
Definition: cimath.cpp:898
lx_interval Pi2_lx_interval()
Enclosure-Interval for .
interval sqrtx2y2(const interval &x, const interval &y)
Calculates .
Definition: imath.cpp:80
lx_interval SqrtPi_lx_interval()
Enclosure-Interval for .
cinterval ln(const cinterval &z)
Calculates .
Definition: cimath.cpp:851
cinterval sin(const cinterval &z)
Calculates .
Definition: cimath.cpp:215
lx_interval SqrtPir_lx_interval()
Enclosure-Interval for .
cinterval cot(const cinterval &z)
Calculates .
Definition: cimath.cpp:538
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
interval ln_sqrtx2y2(const interval &x, const interval &y)
Calculates .
Definition: imath.cpp:581
cinterval acot(const cinterval &z)
Calculates .
Definition: cimath.cpp:3130
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
lx_interval Er_lx_interval()
Enclosure-Interval for .
cinterval atan(const cinterval &z)
Calculates .
Definition: cimath.cpp:2938
cinterval acos(const cinterval &z)
Calculates .
Definition: cimath.cpp:2553
cinterval sqr(const cinterval &z)
Calculates .
Definition: cimath.cpp:3342
lx_interval sqrt7_lx_interval()
Enclosure-Interval for .
lx_interval Ln2Pi_lx_interval()
Enclosure-Interval for .
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition: interval.cpp:293
lx_interval Catalan_lx_interval()
Enclosure-Interval for .
lx_interval LnPi_lx_interval()
Enclosure-Interval for .
cinterval expm1(const cinterval &z)
Calculates .
Definition: cimath.cpp:177
lx_interval cos_n(const lx_interval &x, const real &n)
Calculates .
real RelDiam(const interval &x)
Computes the relative diameter .
Definition: interval.cpp:316
lx_interval Pip2_lx_interval()
Enclosure-Interval for .
lx_interval One_p_lx_interval()
Enclosure-Interval for .
cinterval tanh(const cinterval &z)
Calculates .
Definition: cimath.cpp:565
cinterval asinh(const cinterval &z)
Calculates .
Definition: cimath.cpp:2718
lx_interval Sqrt2Pi_lx_interval()
Enclosure-Interval for .
cinterval log10(const cinterval &z)
Calculates .
Definition: cimath.cpp:903
lx_interval Pir_lx_interval()
Enclosure-Interval for .
lx_interval Pid2_lx_interval()
Enclosure-Interval for .
lx_interval Ep2Pi_lx_interval()
Enclosure-Interval for .
cinterval sqrt1mx2(const cinterval &z)
Calculates .
Definition: cimath.cpp:1140
interval acoshp1(const interval &x)
Calculates .
Definition: imath.cpp:617
lx_interval EpPi_lx_interval()
Enclosure-Interval for .
lx_interval Pi2r_lx_interval()
Enclosure-Interval for .
cinterval lnp1(const cinterval &z)
Calculates .
Definition: cimath.cpp:867
lx_interval Sqrt3d2_lx_interval()
Enclosure-Interval for .
lx_interval E_lx_interval()
Enclosure-Interval for .
lx_interval Ep2r_lx_interval()
Enclosure-Interval for .
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition: interval.cpp:288
lx_interval Ln2_lx_interval()
Enclosure-Interval for .
lx_interval Pi_lx_interval()
Enclosure-Interval for .
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition: interval.cpp:303
lx_interval Sqrt2_lx_interval()
Enclosure-Interval for .
cinterval sqrt(const cinterval &z)
Calculates .
Definition: cimath.cpp:1007
lx_interval Sqrt2Pir_lx_interval()
Enclosure-Interval for .
lx_interval atanh1m(const lx_interval &x)
Calculates .
lx_interval sin_n(const lx_interval &x, const real &n)
Calculates .
lx_interval Pid3_lx_interval()
Enclosure-Interval for .
cinterval cos(const cinterval &z)
Calculates .
Definition: cimath.cpp:207
lx_interval Ln2r_lx_interval()
Enclosure-Interval for .
l_interval point_any(int n)
Returns a point interval with exponent n.
cinterval atanh(const cinterval &z)
Calculates .
Definition: cimath.cpp:3317
lx_interval atanhm1p(const lx_interval &x)
Calculates .
lx_interval Ep2_lx_interval()
Enclosure-Interval for .
lx_interval Sqrt3r_lx_interval()
Enclosure-Interval for .
cinterval exp10(const cinterval &z)
Calculates .
Definition: cimath.cpp:172
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
lx_interval EulerGamma_lx_interval()
Enclosure-Interval for .
lx_interval EpPid4_lx_interval()
Enclosure-Interval for .
void times2pown(cinterval &x, int n)
Fast multiplication of reference parameter [z] with .
Definition: cimath.cpp:2059
cinterval sqrtp1m1(const cinterval &z)
Calculates .
Definition: cimath.cpp:1054
cinterval exp(const cinterval &z)
Calculates .
Definition: cimath.cpp:159
lx_interval acothp1(const lx_interval &x)
Calculates .
lx_interval xp1_pow_y(const lx_interval &x, const lx_interval &y)
Calculates .
cinterval cosh(const cinterval &z)
Calculates .
Definition: cimath.cpp:223
l_interval wide_any(int n)
Returns a wide interval with exponent n, .
cinterval tan(const cinterval &z)
Calculates .
Definition: cimath.cpp:393
lx_interval EpPid2_lx_interval()
Enclosure-Interval for .
cinterval sinh(const cinterval &z)
Calculates .
Definition: cimath.cpp:231
lx_interval Ln10_lx_interval()
Enclosure-Interval for .
lx_interval acothm1m(const lx_interval &x)
Calculates .
cinterval exp2(const cinterval &z)
Calculates .
Definition: cimath.cpp:167
cinterval asin(const cinterval &z)
Calculates .
Definition: cimath.cpp:2311
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
l_interval wide_max(void)
Returns a wide interval with maximum exponent 1020.
cinterval acoth(const cinterval &z)
Calculates .
Definition: cimath.cpp:3330
cinterval coth(const cinterval &z)
Calculates .
Definition: cimath.cpp:578
lx_interval Sqrt2r_lx_interval()
Enclosure-Interval for .
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cinterval pow(const cinterval &z, const interval &p)
Calculates .
Definition: cimath.cpp:2074
lx_interval Ln10r_lx_interval()
Enclosure-Interval for .
cinterval power(const cinterval &z, int n)
Calculates .
Definition: cimath.cpp:1941
bool Is_Integer(const real &x)
Returns 1 if x is an integer value and if .
Definition: lx_real.inl:63
lx_interval expo2zero(const lx_interval &a)
b = expo2zero(a) returns with
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cinterval acosh(const cinterval &z)
Calculates .
Definition: cimath.cpp:2732
lx_interval sqrt5_lx_interval()
Enclosure-Interval for .