Jump to navigation Jump to search
455 bytes removed ,  14:18, 14 January 2015
Removed dependency to fenv package
The [ interval package] provides data types and fundamental operations for real valued interval arithmetic based on the common floating-point format “binary64” a. k. a. double-precision. It aims to be standard compliant with the (upcoming) [ IEEE 1788] and therefore implements the ''set-based'' interval arithmetic flavor. '''Interval arithmetic''' produces mathematically proven numerical results.
Warning: The package has not yet been released. If you want to experience the development version, you may (1) install the (currently deprecated) [ fenv package], (2) download a [ snapshot version of the interval package], (32) install the [ development library of MPFR] for your system, (43) execute <code>make install</code> in the <code>src/</code> subfolder, (5) navigate to the <code>inst/</code> subfolder and run octave.
== Motivation ==
''Why is the interval package slow?''
All arithmetic interval operations are simulated in high-level octave language using C99 floating-point routines or multi-precision floating-point routines, which is a lot slower than hardware implementations []. Building interval arithmetic operations from floating-point routines is easy for simple monotonic functions, e. g., addition and subtraction, but is complex for others, e. g., [ interval power function], atan2, or [[#Reverse_arithmetic_operations|reverse functions]]. For some interval operations it is not even possible to rely on floating-point routines, since not all required routines are available in C99 or BLAS. For example, for some tightly rounded results of vector and matrix operations the interval package has to simulate a [ Kulisch accumulator], which introduces a computational overhead of factor 10. However, the Kulisch accumulator could be implemented in hardware and then outperform floating-point routines.
Great algorithms and optimizations exist for matrix arithmetic in GNU octave. Good interval versions of these still have to be found and implemented.
Some basic operations are provided by the C library on common platforms with directed rounding and correctly rounded result: plus, minus, division, multiplication and square root. All other GNU Octave arithmetic functions are not guaranteed to produce accurate results, because they are based on C99 floating-point routines []. Their results depend on hardware, system libraries and compilation options.
The interval package handles all arithmetic functions with the help of the [ GNU MPFR library]. With MPFR it is possible to compute system-independent, valid and tight enclosures of the correct results.
== Quick start introduction ==
octave:1> sin (infsup (0.5))
ans ⊂ [.47942553860420294, .4794255386042030747942553860420301]
octave:2> pow (infsup (2), infsup (3, 4))
ans = [8, 16]
octave:3> atan2 (infsup (1), infsup (1))
ans ⊂ [.7853981633974487853981633974482, .78539816339744877853981633974484]
=== Reverse arithmetic operations ===
In the following example, we compute the constraints for base and exponent of the power function <code>pow</code> as shown in the figure.
octave:1> x = powrev1 (infsup ("[1.1, 1.45]"), infsup (2, 3))
x ⊂ [1.61289796351536446128979635153646, 2.71485472656579237148547265657915]
octave:2> y = powrev2 (infsup ("[2.14, 2.5]"), infsup (2, 3))
y ⊂ [.75647079736602977564707973660299, 1.44401139784032934440113978403284]
=== Numerical operations ===
Above mentioned operations can also be applied element-wise to interval vectors and matrices. Many operations use [ vectorization techniques].
In addition, there are matrix operations on interval matrices. These operations comprise: tight dot product, fast dot product, tight matrix multiplication, fast matrix multiplication, tight vector sums, matrix inversion, matrix powers, and solving linear systems. As a result of missing hardware / low-level library support and missing optimizations, these operations are quite slow compared to familiar operations in floating-point arithmetic.
octave:1> A = infsup ([1, 2, 3; 4, 0, 0; 0, 0, 1]); A (2, 3) = "[0, 6]"


Navigation menu