{-|
    Module      :  Data.Number.ER.Real
    Description :  overview of AERN-Real
    Copyright   :  (c) Michal Konecny
    License     :  BSD3

    Maintainer  :  mik@konecny.aow.cz
    Stability   :  experimental
    Portability :  non-portable (requires fenv.h)

    This module bundles some of the most important functionality
    of the AERN-Real package.  It is intended to be imported *qualified*.

    AERN-Real provides
    datatypes and abstractions for approximating exact real numbers
    and a basic arithmetic over such approximations.  The approach is
    inspired to some degree by Mueller's iRRAM and Lambov's RealLib
    (both are C++ libraries for exact real arithmetic).
    
    Abstractions are provided via 4 type classes:
     
     * 'B.ERRealBase': abstracts floating point numbers
        (not exported here, used only internally)
     
     * 'ERApprox': abstracts neighbourhoods of real numbers
     
     * 'ERIntApprox': abstracts neighbourhoods of real numbers that are known to be intervals

     * 'ERApproxElementary': abstracts real number approximations that support elementary operations

    For ERRealBase we give several implementations.  The default is 
    an arbitrary precision floating point type that uses Double
    for lower precisions and an Integer-based simulation for higher
    precisions.  Rational numbers can be used as one of the alternatives.
    Augustsson's Data.Number.BigFloat can be easily wrapped as an instance
    of ERRealBase except that it uses a different method to control precision.
    
    ERIntApprox is implemented via outwards-rounded arbitrary precision interval arithmetic.  
    Any instance of ERRealBase can be used for the endpoints of the intervals.
    
    ERApproxElementary is implemented generically for any implementation
    of ERIntApprox.  This way some of the most common elementary operations are provided, 
    notably: sqrt, exp, log, sin, cos, atan.  These operations converge 
    to an arbitrary precision and also work well over larger intervals without
    excessive wrapping.
    
    There is also some support for generic Taylor series, interval Newton method
    and simple numerical integration.
    
-}
module Data.Number.ER.Real 
(
    module Data.Number.ER.Real.Approx,
    module Data.Number.ER.Real.Approx.Elementary,
    module Data.Number.ER.Real.DefaultRepr,
    module Data.Number.ER.Real.Approx.Sequence,
    module Data.Number.ER.Real.Arithmetic.Taylor,
    module Data.Number.ER.Real.Arithmetic.Newton,
    module Data.Number.ER.Real.Arithmetic.Integration,
    module Data.Number.ER.BasicTypes
)
where

import Data.Number.ER.Real.DefaultRepr
import Data.Number.ER.BasicTypes
import qualified Data.Number.ER.Real.Base as B
import Data.Number.ER.Real.Approx
import Data.Number.ER.Real.Approx.Elementary
import Data.Number.ER.Real.Approx.Sequence
import Data.Number.ER.Real.Arithmetic.Taylor
import Data.Number.ER.Real.Arithmetic.Newton
import Data.Number.ER.Real.Arithmetic.Integration