8 files changed, 81 insertions, 88 deletions

diff --git a/lib/Numeric/GSL/Differentiation.hs b/lib/Numeric/GSL/Differentiation.hs
index d2a332c..93c5007 100644
--- a/lib/Numeric/GSL/Differentiation.hs
+++ b/lib/Numeric/GSL/Differentiation.hs
@@ -55,11 +55,11 @@ foreign import ccall safe "gsl-aux.h deriv"
 
 {- | Adaptive central difference algorithm, /gsl_deriv_central/. For example:
 
-> > let deriv = derivCentral 0.01 
-> > deriv sin (pi/4)
->(0.7071067812000676,1.0600063101654055e-10)
-> > cos (pi/4)
->0.7071067811865476 
+>>> let deriv = derivCentral 0.01
+>>> deriv sin (pi/4)
+(0.7071067812000676,1.0600063101654055e-10)
+>>> cos (pi/4)
+0.7071067811865476
 
 -}
 derivCentral :: Double                  -- ^ initial step size
diff --git a/lib/Numeric/GSL/Fitting.hs b/lib/Numeric/GSL/Fitting.hs
index 6343b76..c4f3a91 100644
--- a/lib/Numeric/GSL/Fitting.hs
+++ b/lib/Numeric/GSL/Fitting.hs
@@ -13,7 +13,8 @@ Nonlinear Least-Squares Fitting
 
 The example program in the GSL manual (see examples/fitting.hs):
 
-@dat = [
+@
+dat = [
  ([0.0],([6.0133918608118675],0.1)),
  ([1.0],([5.5153769909966535],0.1)),
  ([2.0],([5.261094606015287],0.1)),
@@ -25,8 +26,9 @@ expModel [a,lambda,b] [t] = [a * exp (-lambda * t) + b]
 expModelDer [a,lambda,b] [t] = [[exp (-lambda * t), -t * a * exp(-lambda*t) , 1]]
 
 (sol,path) = fitModelScaled 1E-4 1E-4 20 (expModel, expModelDer) dat [1,0,0]
+@
 
-\> path
+>>> path
 (6><5)
  [ 1.0,  76.45780563978782, 1.6465931240727802, 1.8147715267618197e-2, 0.6465931240727797
  , 2.0, 37.683816318260355,  2.858760367632973,  8.092094813253975e-2, 1.4479636296208662
@@ -34,10 +36,10 @@ expModelDer [a,lambda,b] [t] = [[exp (-lambda * t), -t * a * exp(-lambda*t) , 1]
  , 4.0,  5.630494933603935,  5.021755718065913,   0.10287787128056883, 1.0338835440862608
  , 5.0,  5.443976278682909,  5.045204331329302,   0.10405523433131504,  1.019416067207375
  , 6.0, 5.4439736648994685,  5.045357818922331,   0.10404905846029407, 1.0192487112786812 ]
-\> sol
+>>> sol
 [(5.045357818922331,6.027976702418132e-2),
 (0.10404905846029407,3.157045047172834e-3),
-(1.0192487112786812,3.782067731353722e-2)]@
+(1.0192487112786812,3.782067731353722e-2)]
 
 -}
 -----------------------------------------------------------------------------
diff --git a/lib/Numeric/GSL/Fourier.hs b/lib/Numeric/GSL/Fourier.hs
index 4ef19b3..86aedd6 100644
--- a/lib/Numeric/GSL/Fourier.hs
+++ b/lib/Numeric/GSL/Fourier.hs
@@ -35,8 +35,8 @@ foreign import ccall unsafe "gsl-aux.h fft" c_fft ::  CInt -> TCVCV
 
 {- | Fast 1D Fourier transform of a 'Vector' @(@'Complex' 'Double'@)@ using /gsl_fft_complex_forward/. It uses the same scaling conventions as GNU Octave.
 
-@> fft ('fromList' [1,2,3,4])
-vector (4) [10.0 :+ 0.0,(-2.0) :+ 2.0,(-2.0) :+ 0.0,(-2.0) :+ (-2.0)]@
+>>> fft (fromList [1,2,3,4])
+fromList [10.0 :+ 0.0,(-2.0) :+ 2.0,(-2.0) :+ 0.0,(-2.0) :+ (-2.0)]
 
 -}
 fft :: Vector (Complex Double) -> Vector (Complex Double)
diff --git a/lib/Numeric/GSL/Integration.hs b/lib/Numeric/GSL/Integration.hs
index 7c1cdb9..5f0a415 100644
--- a/lib/Numeric/GSL/Integration.hs
+++ b/lib/Numeric/GSL/Integration.hs
@@ -35,16 +35,16 @@ eps = 1e-12
 
 {- | conversion of Haskell functions into function pointers that can be used in the C side
 -}
-foreign import ccall safe "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double)) 
+foreign import ccall safe "wrapper" mkfun:: (Double -> Ptr() -> Double) -> IO( FunPtr (Double -> Ptr() -> Double))
 
 --------------------------------------------------------------------
 {- | Numerical integration using /gsl_integration_qags/ (adaptive integration with singularities). For example:
 
-@\> let quad = integrateQAGS 1E-9 1000 
-\> let f a x = x**(-0.5) * log (a*x)
-\> quad (f 1) 0 1
-(-3.999999999999974,4.871658632055187e-13)@
- 
+>>> let quad = integrateQAGS 1E-9 1000
+>>> let f a x = x**(-0.5) * log (a*x)
+>>> quad (f 1) 0 1
+(-3.999999999999974,4.871658632055187e-13)
+
 -}
 
 integrateQAGS :: Double               -- ^ precision (e.g. 1E-9)
@@ -56,7 +56,7 @@ integrateQAGS :: Double               -- ^ precision (e.g. 1E-9)
 integrateQAGS prec n f a b = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\x _ -> f x)
     c_integrate_qags fp a b eps prec (fromIntegral n) r e // check "integrate_qags"
     vr <- peek r
     ve <- peek e
@@ -73,10 +73,10 @@ foreign import ccall safe "integrate_qags" c_integrate_qags
 -----------------------------------------------------------------
 {- | Numerical integration using /gsl_integration_qng/ (useful for fast integration of smooth functions). For example:
 
-@\> let quad = integrateQNG 1E-6 
-\> quad (\\x -> 4\/(1+x*x)) 0 1 
-(3.141592653589793,3.487868498008632e-14)@
- 
+>>> let quad = integrateQNG 1E-6
+>>> quad (\x -> 4/(1+x*x)) 0 1
+(3.141592653589793,3.487868498008632e-14)
+
 -}
 
 integrateQNG :: Double               -- ^ precision (e.g. 1E-9)
@@ -87,7 +87,7 @@ integrateQNG :: Double               -- ^ precision (e.g. 1E-9)
 integrateQNG prec f a b = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\x _ -> f x)
     c_integrate_qng fp a b eps prec r e  // check "integrate_qng"
     vr <- peek r
     ve <- peek e
@@ -102,14 +102,14 @@ foreign import ccall safe "integrate_qng" c_integrate_qng
     -> Double -> Double -> Ptr Double -> Ptr Double -> IO CInt
 
 --------------------------------------------------------------------
-{- | Numerical integration using /gsl_integration_qagi/ (integration over the infinite integral -Inf..Inf using QAGS). 
+{- | Numerical integration using /gsl_integration_qagi/ (integration over the infinite integral -Inf..Inf using QAGS).
 For example:
 
-@\> let quad = integrateQAGI 1E-9 1000 
-\> let f a x = exp(-a * x^2)
-\> quad (f 0.5) 
-(2.5066282746310002,6.229215880648858e-11)@
- 
+>>> let quad = integrateQAGI 1E-9 1000
+>>> let f a x = exp(-a * x^2)
+>>> quad (f 0.5)
+(2.5066282746310002,6.229215880648858e-11)
+
 -}
 
 integrateQAGI :: Double               -- ^ precision (e.g. 1E-9)
@@ -119,7 +119,7 @@ integrateQAGI :: Double               -- ^ precision (e.g. 1E-9)
 integrateQAGI prec n f = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\x _ -> f x)
     c_integrate_qagi fp eps prec (fromIntegral n) r e // check "integrate_qagi"
     vr <- peek r
     ve <- peek e
@@ -134,14 +134,14 @@ foreign import ccall safe "integrate_qagi" c_integrate_qagi
     -> CInt -> Ptr Double -> Ptr Double -> IO CInt
 
 --------------------------------------------------------------------
-{- | Numerical integration using /gsl_integration_qagiu/ (integration over the semi-infinite integral a..Inf). 
+{- | Numerical integration using /gsl_integration_qagiu/ (integration over the semi-infinite integral a..Inf).
 For example:
 
-@\> let quad = integrateQAGIU 1E-9 1000 
-\> let f a x = exp(-a * x^2)
-\> quad (f 0.5) 0
-(1.2533141373155001,3.114607940324429e-11)@
- 
+>>> let quad = integrateQAGIU 1E-9 1000
+>>> let f a x = exp(-a * x^2)
+>>> quad (f 0.5) 0
+(1.2533141373155001,3.114607940324429e-11)
+
 -}
 
 integrateQAGIU :: Double               -- ^ precision (e.g. 1E-9)
@@ -152,7 +152,7 @@ integrateQAGIU :: Double               -- ^ precision (e.g. 1E-9)
 integrateQAGIU prec n f a = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\x _ -> f x)
     c_integrate_qagiu fp a eps prec (fromIntegral n) r e // check "integrate_qagiu"
     vr <- peek r
     ve <- peek e
@@ -167,14 +167,14 @@ foreign import ccall safe "integrate_qagiu" c_integrate_qagiu
     -> Double -> CInt -> Ptr Double -> Ptr Double -> IO CInt
 
 --------------------------------------------------------------------
-{- | Numerical integration using /gsl_integration_qagil/ (integration over the semi-infinite integral -Inf..b). 
+{- | Numerical integration using /gsl_integration_qagil/ (integration over the semi-infinite integral -Inf..b).
 For example:
 
-@\> let quad = integrateQAGIL 1E-9 1000 
-\> let f a x = exp(-a * x^2)
-\> quad (f 0.5) 0 
-(1.2533141373155001,3.114607940324429e-11)@
- 
+>>> let quad = integrateQAGIL 1E-9 1000
+>>> let f a x = exp(-a * x^2)
+>>> quad (f 0.5) 0
+(1.2533141373155001,3.114607940324429e-11)
+
 -}
 
 integrateQAGIL :: Double               -- ^ precision (e.g. 1E-9)
@@ -185,7 +185,7 @@ integrateQAGIL :: Double               -- ^ precision (e.g. 1E-9)
 integrateQAGIL prec n f b = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\x _ -> f x)
     c_integrate_qagil fp b eps prec (fromIntegral n) r e // check "integrate_qagil"
     vr <- peek r
     ve <- peek e
@@ -212,10 +212,10 @@ routines in QUADPACK, yet fails less often for difficult integrands.@
 
 For example:
 
-@\> let quad = integrateCQUAD 1E-12 1000 
-\> let f a x = exp(-a * x^2)
-\> quad (f 0.5) 2 5
-(5.7025405463957006e-2,9.678874441303705e-16,95)@
+>>> let quad = integrateCQUAD 1E-12 1000
+>>> let f a x = exp(-a * x^2)
+>>> quad (f 0.5) 2 5
+(5.7025405463957006e-2,9.678874441303705e-16,95)
 
 Unlike other quadrature methods, integrateCQUAD also returns the
 number of function evaluations required.
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
index 7ccca81..1879dab 100644
--- a/lib/Numeric/GSL/Minimization.hs
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -16,15 +16,15 @@ Minimization of a multidimensional function using some of the algorithms describ
 The example in the GSL manual:
 
 @
-
 f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
 
 main = do
     let (s,p) = minimize NMSimplex2 1E-2 30 [1,1] f [5,7]
     print s
     print p
+@
 
-\> main
+>>> main
 [0.9920430849306288,1.9969168063253182]
  0.000  512.500  1.130  6.500  5.000
  1.000  290.625  1.409  5.250  4.000
@@ -33,7 +33,6 @@ main = do
  ...
 22.000   30.001  0.013  0.992  1.997
 23.000   30.001  0.008  0.992  1.997
-@
 
 The path to the solution can be graphically shown by means of:
 
diff --git a/lib/Numeric/GSL/ODE.hs b/lib/Numeric/GSL/ODE.hs
index ab037bd..9a29085 100644
--- a/lib/Numeric/GSL/ODE.hs
+++ b/lib/Numeric/GSL/ODE.hs
@@ -13,9 +13,10 @@ Solution of ordinary differential equation (ODE) initial value problems.
 
 A simple example:
 
-@import Numeric.GSL
+@
+import Numeric.GSL.ODE
 import Numeric.LinearAlgebra
-import Graphics.Plot
+import Numeric.LinearAlgebra.Util(mplot)
 
 xdot t [x,v] = [v, -0.95*x - 0.1*v]
 
@@ -23,7 +24,8 @@ ts = linspace 100 (0,20 :: Double)
 
 sol = odeSolve xdot [10,0] ts
 
-main = mplot (ts : toColumns sol)@
+main = mplot (ts : toColumns sol)
+@
 
 -}
 -----------------------------------------------------------------------------
diff --git a/lib/Numeric/GSL/Polynomials.hs b/lib/Numeric/GSL/Polynomials.hs
index 694c003..290c615 100644
--- a/lib/Numeric/GSL/Polynomials.hs
+++ b/lib/Numeric/GSL/Polynomials.hs
@@ -27,22 +27,22 @@ import System.IO.Unsafe (unsafePerformIO)
 import Foreign.C.Types (CInt(..))
 #endif
 
-{- | Solution of general polynomial equations, using /gsl_poly_complex_solve/. For example,
-     the three solutions of x^3 + 8 = 0
+{- | Solution of general polynomial equations, using /gsl_poly_complex_solve/. 
+
+For example, the three solutions of x^3 + 8 = 0
+
+>>> polySolve [8,0,0,1]
+[(-2.0) :+ 0.0,1.0 :+ 1.7320508075688776,1.0 :+ (-1.7320508075688776)]
 
-@\> polySolve [8,0,0,1]
-[(-1.9999999999999998) :+ 0.0,
- 1.0 :+ 1.732050807568877,
- 1.0 :+ (-1.732050807568877)]@
 
 The example in the GSL manual: To find the roots of x^5 -1 = 0:
 
-@\> polySolve [-1, 0, 0, 0, 0, 1]
-[(-0.8090169943749475) :+ 0.5877852522924731,
-(-0.8090169943749475) :+ (-0.5877852522924731),
-0.30901699437494734 :+ 0.9510565162951536,
-0.30901699437494734 :+ (-0.9510565162951536),
-1.0 :+ 0.0]@
+>>> polySolve [-1, 0, 0, 0, 0, 1]
+[(-0.8090169943749472) :+ 0.5877852522924731,
+(-0.8090169943749472) :+ (-0.5877852522924731),
+0.30901699437494756 :+ 0.9510565162951535,
+0.30901699437494756 :+ (-0.9510565162951535),
+1.0000000000000002 :+ 0.0]
 
 -}  
 polySolve :: [Double] -> [Complex Double]
diff --git a/lib/Numeric/GSL/Root.hs b/lib/Numeric/GSL/Root.hs
index 6da15e5..9d561c4 100644
--- a/lib/Numeric/GSL/Root.hs
+++ b/lib/Numeric/GSL/Root.hs
@@ -13,33 +13,23 @@ Multidimensional root finding.
 
 The example in the GSL manual:
 
-@import Numeric.GSL
-import Numeric.LinearAlgebra(format)
-import Text.Printf(printf)
-
-rosenbrock a b [x,y] = [ a*(1-x), b*(y-x^2) ]
-
-disp = putStrLn . format \"  \" (printf \"%.3f\")
-
-main = do
-    let (sol,path) = root Hybrids 1E-7 30 (rosenbrock 1 10) [-10,-5]
-    print sol
-    disp path
-
-\> main
+>>> let rosenbrock a b [x,y] = [ a*(1-x), b*(y-x^2) ]
+>>> let (sol,path) = root Hybrids 1E-7 30 (rosenbrock 1 10) [-10,-5]
+>>> sol
 [1.0,1.0]
- 0.000  -10.000  -5.000  11.000  -1050.000
- 1.000   -3.976  24.827   4.976     90.203
+>>> disp 3 path
+11x5
+ 1.000  -10.000  -5.000  11.000  -1050.000
  2.000   -3.976  24.827   4.976     90.203
  3.000   -3.976  24.827   4.976     90.203
- 4.000   -1.274  -5.680   2.274    -73.018
+ 4.000   -3.976  24.827   4.976     90.203
  5.000   -1.274  -5.680   2.274    -73.018
- 6.000    0.249   0.298   0.751      2.359
+ 6.000   -1.274  -5.680   2.274    -73.018
  7.000    0.249   0.298   0.751      2.359
- 8.000    1.000   0.878  -0.000     -1.218
- 9.000    1.000   0.989  -0.000     -0.108
-10.000    1.000   1.000   0.000      0.000
-@
+ 8.000    0.249   0.298   0.751      2.359
+ 9.000    1.000   0.878  -0.000     -1.218
+10.000    1.000   0.989  -0.000     -0.108
+11.000    1.000   1.000   0.000      0.000
 
 -}
 -----------------------------------------------------------------------------