184 research outputs found
A Modified Staggered Correction Arithmetic with Enhanced Accuracy and Very Wide Exponent Range
A so called staggered precision arithmetic is a special kind of
a multiple precision arithmetic based on the underlying
floating point data format (typically IEEE double format)
and fast floating point operations as well as exact dot product computations.
Due to floating point limitations it is not an arbitrary precision arithmetic.
However, it typically allows computations using several hundred mantissa digits.
A set of new modified staggered arithmetics for real and
complex data as well as for real interval and
complex interval data with very wide exponent range is presented.
Some applications show
the increased accuracy of computed results compared to ordinary staggered
interval computations. The very wide exponent range of the new arithmetic
operations allows computations far beyond the IEEE data formats.
The new arithmetics would be extremly fast, if an exact dot product was
available in hardware (the fused accumulate and add instruction is only
one step in this direction)
Computer-Assisted Proofs and Symbolic Computations
We discuss some main points of computer-assisted proofs based
on reliable numerical computations. Such so-called self-validating numerical
methods in combination with exact symbolic manipulations result in very
powerful mathematical software tools. These tools allow proving mathematical
statements (existence of a fixed point, of a solution of an ODE, of
a zero of a continuous function, of a global minimum within a given range,
etc.) using a digital computer. To validate the assertions of the underlying
theorems fast finite precision arithmetic is used. The results are absolutely
rigorous.
To demonstrate the power of reliable symbolic-numeric computations we
investigate in some details the verification of very long periodic orbits of
chaotic dynamical systems. The verification is done directly in Maple, e.g.
using the Maple Power Tool intpakX or, more efficiently, using the C++
class library C-XSC.* This work is partially supported by DFG: KR1612/7-1
A Note on Solving Problem 7 of the SIAM 100-Digit Challenge Using C-XSC
C-XSC is a powerful C++ class library which simplifies the development
of selfverifying numerical software. But C-XSC is not only a development tool, it also provides a lot of predefined highly accurate routines to compute reliable bounds for the solution to standard numerical problems.
In this note we discuss the usage of a reliable linear system solver to compute the solution of problem 7 of the SIAM 100-digit challenge. To get the result we have to solve a 20 000 × 20 000 system of linear equations using interval computations. To perform this task we run our software on the advanced Linux cluster engine ALiCEnext located at the University of Wuppertal and on the high performance computer HP XC6000 at the computing center of the University of Karlsruhe.
The main purpose of this note is to demonstrate the power/weakness of our approach to solve linear interval systems with a large dense system matrix using C-XSC and to get feedback from other research groups all over the world concerned with the topic described. We are very much interested to see comparisons concerning different methods/algorithms, timings, memory consumptions, and different hardware/software
environments. It should be easy to adapt our main routine (see Section 3 below) to other programming languages, and different computing environments. Changing just one variable allows the generation of arbitrary large system matrices making it easy to do sound (reproducible and comparable) timings and to check for the largest possible system size that can be handled successfully by a specific package/environment
On the Interoperability between Interval Software
The increased appreciation of interval analysis as a powerful tool for controlling round-off errors and modelling
with uncertain data leads to a growing number of diverse interval software. Beside in some other aspects,
the available interval software differs with respect to the environment in which it operates and the provided
functionality. Some specific software tools are built on the top of other more general interval software but
there is no single environment supporting all (or most) of the available interval methods. On another side,
most recent interval applications require a combination of diverse methods. It is difficult for the end-users
to combine and manage the diversity of interval software tools, packages, and research codes, even the latter
being accessible. Two recent initiatives: [1], directed toward developing of a comprehensive full-featured library
of validated routines, and [3] intending to provide a general service framework for validated computing in
heterogeneous environment, reflect the realized necessity for an integration of the available methods and
software tools.
It is commonly understood that quality comprehensive libraries are not compiled by a single person or small
group of people over a short time [1]. Therefore, in this work we present an alternative approach based on
interval software interoperability.
While the simplest form of interoperability is the exchange of data files, we will focus on the ability to run
a particular routine executable in one environment from within another software environment, and vice-versa,
via communication protocols. We discuss the motivation, advantages and some problems that may appear in
providing interoperability between the existing interval software.
Since the general-purpose environments for scientific/technical computing like Matlab, Mathematica, Maple, etc.
have several features not attributable to the compiled languages from one side and on another side most problem
solving tools are developed in some compiled language for efficiency reasons, it is interesting to study
the possibilities for interoperability between these two kinds of interval supporting environments.
More specifically, we base our presentation on the interoperability between Mathematica [5] and external
C-XSC programs [2] via MathLink communication protocol [4]. First, we discuss the portability and reliability
of interval arithmetic in Mathematica. Then, we present MathLink technology for building external
MathLink-compatible programs. On the example of a C-XSC function for solving parametric linear systems,
called from within a Mathematica session, we demonstrate some advantages of interval software interoperability.
Namely, expanded functionality for both environments, exchanging data without using intermediate files and
without any conversion but under dynamics and interactivity in the communication, symbolic manipulation interfaces
for the compiled language software that often make access to the external functionality from within Mathematica
more convenient even than from its own native environment. Once established, MathLink connection to external
interval libraries or problem-solving software opens up an array on new possibilities for the latter.
References:
[1] G. Corliss, R. B. Kearfott, N. Nedialkov, S. Smith: Towards an Interval Subroutine Library,
Workshop on Reliable Engineering Computing, Svannah, Georgia, USA, Feb. 22-24, 2006.
[2] W. Hofschuster: C-XSC: Highlights and new developments. In: Numerical Validation in Current Hardware
Architectures. Number 08021 Dagstuhl Seminar, Internationales Begegnungs- und Forschungszentrum f"ur
Informatik, Schloss Dagstuhl, Germany, 2008.
[3] W. Luther, W. Kramer: Accurate Grid Computing, 12th GAMM-IMACS Int. Symposium on Scientific Computing,
Computer Arithmetic and Validated Numerics (SCAN 2006), Duisburg, Sept. 26-29, 2006.
[4] Ch. Miyaji, P. Abbot eds.: Mathlink: Network Programming with Mathematica, Cambridge Univ. Press, Cambridge, 2001.
[5] Wolfram Research Inc.: Mathematica, Version 5.2, Champaign, IL, 2005
On turning waves for the inhomogeneous Muskat problem: a computer-assisted proof
We exhibit a family of graphs that develop turning singularities (i.e. their
Lipschitz seminorm blows up and they cease to be a graph, passing from the
stable to the unstable regime) for the inhomogeneous, two-phase Muskat problem
where the permeability is given by a nonnegative step function. We study the
influence of different choices of the permeability and different boundary
conditions (both at infinity and considering finite/infinite depth) in the
development or prevention of singularities for short time. In the general case
(inhomogeneous, confined) we prove a bifurcation diagram concerning the
appearance or not of singularities when the depth of the medium and the
permeabilities change. The proofs are carried out using a combination of
classical analysis techniques and computer-assisted verification.Comment: 30 pages, 6 figure
Testing interval arithmetic libraries, including their IEEE-1788 compliance
International audienceAs developers of libraries implementing interval arithmetic, we faced the same difficulties when it came to testing our libraries. What must be tested? How can we devise relevant test cases for unit testing? How can we ensure a high (and possibly 100%) test coverage? In this paper we list the different aspects that, in our opinion, must be tested, giving indications on the choice of test cases. Then we examine how several interval arithmetic libraries actually perform tests. Next, we introduce two frameworks developed specifically to gather test cases and to incorporate easily new libraries in order to test them, namely JInterval and ITF1788. Not every important aspects of our libraries fit in these frameworks and we list extra tests that we deem important, but not easy, to perform
Applications of interval analysis to selected topics in statistical computing
In interval analysis, an interval is treated not only as a set of numbers, but as a number in and of itself. The development of interval analysis is closely connected to the development of electronic digital computers. Conventional electronic computation is typically performed using a fixed-precision, floating-point processor. This approach is a finite approximation to calculations with real numbers of infinite precision. The finite approximation leads to errors of various types. While the fundamental operations of addition, subtraction, multiplication and division are typically accurate to one-half unit-last-place in floating-point computations, the effect of cumulative error in repeated calculations is usually unknown and too-frequently ignored. Using interval analysis, an interval is constructed which (after each computation) is guaranteed to contain the true value. By seeking ways to keep the interval narrow, it is possible to obtain results which are of guaranteed accuracy;This dissertation uses interval analysis in topics of statistical computing. Two major topics are addressed: bounding computational errors and global optimization;For bounding computational errors, series are used which yield a bound on the truncation error which results from a finite series approximation to an infinite series. By evaluating the series with intervals to bound rounding errors and by using the bound on the truncation error, an interval is obtained which is guaranteed to contain the true value. For some series, interval numerical quadrature rules are also employed. These ideas are applied to the computation of tail probabilities and critical points of several statistical distributions such as Bivariate Chi-Square and Bivariate F distributions;As regards to global optimization, the EM algorithm is one tool frequently used for optimization in Statistics and Probability; The EM algorithm is fairly flexible and is able to handle missing data. However, as with most optimization algorithms, there is no guarantee of finding a global optimum. Interval analysis can be used to compute an enclosure of the range of a function over a specified domain. By enclosing the range of the gradient of the loglikelihood, those parts of the parameter space where the gradient is nonzero can be eliminated as not containing stationary points. An algorithm proceeds by repeatedly bisecting an initial region into smaller regions which are evaluated for the possibility of the gradient being nonzero. Upon termination, all stationary points of the loglikelihood are contained in the remaining regions
A survey of PASCAL-XSC and a language reference supplement on dynamic and flexible arrays
Ein PASCAL-XSC-Ueberblick und eine Sprachbeschreibungs-Ergaenzung
zu dynamischen und flexiblen Feldern
-----------------------------------------------------------------
PASCAL-XSC ist eine universelle Programmiersprache, die ausserdem speziell
die Implementierung von hochentwickelten numerischen Algorithmen
unterstuetzt. Das PASCAL-XSC System hat den Vorteil der Portabilitaet auf
verschiedenen Plattformen (Personal Computer, Workstations, Grossrechner
und Supercomputer) durch einen portablen Compiler, der nach ANSI-C
uebersetzt.
Mittels der mathematischen Module von PASCAL-XSC koennen numerische
Algorithmen, die hochgenaue und automatisch verifizierte Ergebnisse
liefern, sehr leicht programmiert werden. PASCAL-XSC vereinfacht das
Design von Programmmen in den Ingenieurwissenschaften und im
wissenschaftlichen Rechnen durch modulare Programmstruktur,
benutzerdefinierte Operatoren, Ueberladen von Funktionen, Prozeduren
und Operatoren, Funktionen und Operatoren mit allgemeinem Ergebnistyp
und dynamische Felder. Arithmetische Standard Module fuer zusaetzliche
numerische Datentypen (inclusive Operatoren und Standardfunktions
von hoher Genauigkeit) und die exakte Ausdrucksauswertungn stellen die
wichtigsten numerischen Tools dar.
In PASCAL--XSC geschriebene Programme sind leicht lesbar, da alle
Operationen, auch die in hoeheren mathematischen Raeumen, als Operatoren
realisiert sind und in der ueblichen mathematischen Notation verwendet
werden konnen.
In aktuellen Compiler-Versionen von PASCAL-XSC wurde das Konzept der
dynamischen Felder betr?chtlich erweitert. Ein Benutzer kann nun
dynamische Felder mehrfach und mit unterschiedlicher Groesse zur Laufzeit
seines Programmes allokieren. Dar?berhinaus koennen dynamische Felder
auch als Komponenten anderer PASCAL Strukturen wie Records und statische
Felder vereinbart werden.
A Survey of PASCAL-XSC and a Language Reference Supplement
on Dynamic and Flexible Arrays
----------------------------------------------------------
PASCAL-XSC is a general purpose programming language which provides
special support for the implementation of sophisticated numerical
algorithms. The new PASCAL-XSC system has the advantage of being
portable across many platforms and is available for personal computers,
workstations, mainframes and supercomputers by means of a portable
compiler which translates to ANSI-C language.
By using the mathematical modules of PASCAL-XSC, numerical algorithms
which deliver highly accurate and automatically verified results can be
programmed easily. PASCAL-XSC simplifies the design of programs in
engineering and scientific computation by modular program structure,
user-defined operators, overloading of functions, procedures, and
operators, functions and operators with arbitrary result type and
dynamic arrays. Arithmetic standard modules for additional numerical
data types including operators and standard functions of high accuracy
and the exact evaluation of expressions provide the main numerical
tools.
Programs written in PASCAL-XSC are easily readable since all operations,
even those in the higher mathematical spaces, have been realized as
operators and can be used in conventional mathematical notation.
In current compiler versions of PASCAL-XSC, the concept of dynamic
arrays has been significantly extended. A user is now able to allocate
a dynamic array variable several times and with different size during
the execution of his or her program. Moreover, dynamic arrays may now
be declared as components of other PASCAL structures such as records
or static arrays
- …