edit the overview

doc/source/overview.rst

@@ -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
+attached to each variable. This allows computing rigorously with
-over the real numbers, while avoiding the overhead of
+real and complex numbers.
-traditional (inf-sup) interval arithmetic at high precision,
+
-and eliminating much of the need for time-consuming
+With plain floating-point arithmetic, the user must do an error analysis
-and bug-prone manual error analysis associated with
+to guarantee that results are correct. Manual error analysis is time-consuming
-standard floating-point arithmetic. (See for example [Hoe2009]_.)
+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
+Arb differs from earlier implementations in technical aspects of the
-and computation of transcendental functions needed for
+implementation, which makes certain computations more efficient.
-number theory. Arb also differs in some technical aspects of
+It also provides a more comprehensive low-level interface, giving
-the implementation.
+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.
+  represented as pairs of real balls.
-
-* Functions for fast high-precision evaluation of various
-  mathematical constants and special functions, implemented using
-  ball arithmetic with rigorous error bounds.
 
 * 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.
+for the underlying integer arithmetic and various utility functions.
-The code conventions borrow from FLINT, and the project might get
-merged back into FLINT when the code stabilizes in the future.
 Arb also uses `MPFR <http://mpfr.org/>`_ for testing purposes
-and for evaluation of some functions.
+and internally to evaluate some functions.