hiro/arb
1
0
Fork 0
mirror of https://github.com/vale981/arb synced 2025-03-06 01:41:39 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

edit the overview

Browse source
This commit is contained in:
Fredrik Johansson 2016-02-28 19:19:05 +01:00
parent 20627c2f2e
commit 2b701dd92f
1 changed files with 33 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
doc/source/overview.rst
View file

@ -5,22 +5,35 @@ Feature overview
Ball arithmetic, also known as mid-rad interval arithmetic, is an
extension of floating-point arithmetic in which an error bound is
attached to each variable. This allows doing rigorous computations
over the real numbers, while avoiding the overhead of
traditional (inf-sup) interval arithmetic at high precision,
and eliminating much of the need for time-consuming
and bug-prone manual error analysis associated with
standard floating-point arithmetic. (See for example [Hoe2009]_.)
attached to each variable. This allows computing rigorously with
real and complex numbers.
With plain floating-point arithmetic, the user must do an error analysis
to guarantee that results are correct. Manual error analysis is time-consuming
and bug-prone. Ball arithmetic effectively makes error analysis
automatic.
In traditional (inf-sup) interval arithmetic, both endpoints of an interval
`[a,b]` are full-precision numbers, which makes interval arithmetic
twice as expensive as floating-point arithmetic.
In ball arithmetic, only the midpoint *m* of an interval `[m \pm r]`
is a full-precision number, and a few bits suffice for the radius *r*.
At high precision, ball arithmetic is therefore not more expensive than
plain floating-point arithmetic.
Joris van der Hoeven's paper [Hoe2009]_ is a good introduction to the subject.
Other implementations of ball arithmetic include
`iRRAM <http://irram.uni-trier.de/>`_ and
`Mathemagix <http://www.mathemagix.org/www/mmdoc/doc/html/main/index.en.html>`_.
In contrast to those systems, Arb is more focused on low-level arithmetic
and computation of transcendental functions needed for
number theory. Arb also differs in some technical aspects of
the implementation.
Arb differs from earlier implementations in technical aspects of the
implementation, which makes certain computations more efficient.
It also provides a more comprehensive low-level interface, giving
the user full access to the internals. Finally, it implements a wider
range of transcendental functions, covering a large portion of the
special functions in standard reference works such as [NIST2012]_.
Arb 2.x contains:
Arb contains:
* A module (:ref:`arf <arf>`) for correctly rounded arbitrary-precision
floating-point arithmetic. Arb's floating-point numbers have a few special
@ -35,11 +48,7 @@ Arb 2.x contains:
implemented as an *arf* midpoint and a *mag* radius.
* A module (:ref:`acb <acb>`) for complex numbers in rectangular form,
represented as pairs real balls.
* Functions for fast high-precision evaluation of various
mathematical constants and special functions, implemented using
ball arithmetic with rigorous error bounds.
represented as pairs of real balls.
* Modules (:ref:`arb_poly <arb-poly>`, :ref:`acb_poly <acb-poly>`)
for polynomials or power series over the real and complex numbers,
@ -52,22 +61,21 @@ Arb 2.x contains:
implemented using balls as coefficients.
At the moment, only rudimentary linear algebra operations are provided.
* Functions for high-precision evaluation of various
mathematical constants and special functions, implemented using
ball arithmetic with rigorous error bounds.
Arb 1.x used a different set of numerical base types (*fmpr*, *fmprb*
and *fmpcb*). These types had a slightly simpler internal representation,
but generally had worse performance. Almost all methods for the Arb 1.x types
but generally had worse performance. All methods for the Arb 1.x types
have now been ported to faster equivalents for the Arb 2.x types.
The last version to include both the Arb 1.x and Arb 2.x types and methods
was Arb 2.2. As of Arb 2.3, only a small set of *fmpr*
was Arb 2.2. As of Arb 2.9, only a small set of *fmpr*
methods are left for fallback and testing purposes.
Planned features include more transcendental functions and more extensive
polynomial and matrix functionality, as well as further optimizations.
Arb uses `GMP <http://mpir.org>`_ / `MPIR <http://mpir.org>`_ and
`FLINT <http://flintlib.org/>`_
for the underlying integer arithmetic and other functions.
The code conventions borrow from FLINT, and the project might get
merged back into FLINT when the code stabilizes in the future.
for the underlying integer arithmetic and various utility functions.
Arb also uses `MPFR <http://mpfr.org/>`_ for testing purposes
and for evaluation of some functions.
and internally to evaluate some functions.