67 files changed, 6710 insertions, 0 deletions

diff --git a/lib/Numeric/GSL/Differentiation.hs b/lib/Numeric/GSL/Differentiation.hs
new file mode 100644
index 0000000..e7fea92
--- /dev/null
+++ b/lib/Numeric/GSL/Differentiation.hs
@@ -0,0 +1,79 @@
+{-# OPTIONS  #-}
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Differentiation
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Numerical differentiation.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Numerical-Differentiation.html#Numerical-Differentiation>
+
+From the GSL manual: \"The functions described in this chapter compute numerical derivatives by finite differencing. An adaptive algorithm is used to find the best choice of finite difference and to estimate the error in the derivative.\"
+-}
+-----------------------------------------------------------------------------
+module Numeric.GSL.Differentiation (
+    derivCentral,
+    derivForward,
+    derivBackward
+) where
+
+import Foreign
+import Data.Packed.Internal(mkfun,check,(//))
+
+derivGen ::
+    Int                   -- ^ type: 0 central, 1 forward, 2 backward
+    -> Double             -- ^ initial step size
+    -> (Double -> Double) -- ^ function
+    -> Double             -- ^ point where the derivative is taken
+    -> (Double, Double)   -- ^ result and error
+derivGen c h f x = unsafePerformIO $ do
+    r <- malloc
+    e <- malloc
+    fp <- mkfun (\x _ -> f x) 
+    c_deriv c fp x h r e // check "deriv" []
+    vr <- peek r
+    ve <- peek e
+    let result = (vr,ve)
+    free r
+    free e
+    freeHaskellFunPtr fp
+    return result
+
+foreign import ccall "gsl-aux.h deriv" 
+ c_deriv :: Int -> FunPtr (Double -> Ptr () -> Double) -> Double -> Double 
+                    -> Ptr Double -> Ptr Double -> IO Int
+
+
+{- | 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 
+
+-}
+derivCentral :: Double                  -- ^ initial step size
+                -> (Double -> Double)   -- ^ function 
+                -> Double               -- ^ point where the derivative is taken
+                -> (Double, Double)     -- ^ result and absolute error
+derivCentral = derivGen 0
+
+-- | Adaptive forward difference algorithm, /gsl_deriv_forward/. The function is evaluated only at points greater than x, and never at x itself. The derivative is returned in result and an estimate of its absolute error is returned in abserr. This function should be used if f(x) has a discontinuity at x, or is undefined for values less than x. A backward derivative can be obtained using a negative step.
+derivForward :: Double                  -- ^ initial step size
+                -> (Double -> Double)   -- ^ function 
+                -> Double               -- ^ point where the derivative is taken
+                -> (Double, Double)     -- ^ result and absolute error
+derivForward = derivGen 1
+
+-- | Adaptive backward difference algorithm, /gsl_deriv_backward/. 
+derivBackward ::Double                  -- ^ initial step size
+                -> (Double -> Double)   -- ^ function 
+                -> Double               -- ^ point where the derivative is taken
+                -> (Double, Double)     -- ^ result and absolute error
+derivBackward = derivGen 2
diff --git a/lib/Numeric/GSL/Fourier.hs b/lib/Numeric/GSL/Fourier.hs
new file mode 100644
index 0000000..e975fbf
--- /dev/null
+++ b/lib/Numeric/GSL/Fourier.hs
@@ -0,0 +1,46 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+{- |
+Module      : Numeric.GSL.Fourier
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Fourier Transform.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Fast-Fourier-Transforms.html#Fast-Fourier-Transforms>
+
+-}
+-----------------------------------------------------------------------------
+module Numeric.GSL.Fourier (
+    fft,
+    ifft
+) where
+
+import Data.Packed.Internal
+import Complex
+import Foreign
+
+genfft code v = unsafePerformIO $ do
+    r <- createVector (dim v)
+    c_fft code // vec v // vec r // check "fft" [v]
+    return r
+
+foreign import ccall "gsl-aux.h fft" c_fft ::  Int -> 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 ('GSL.Matrix.fromList' [1,2,3,4])
+vector (4) [10.0 :+ 0.0,(-2.0) :+ 2.0,(-2.0) :+ 0.0,(-2.0) :+ (-2.0)]@
+
+-}
+fft :: Vector (Complex Double) -> Vector (Complex Double)
+fft = genfft 0
+
+-- | The inverse of 'fft', using /gsl_fft_complex_inverse/.
+ifft :: Vector (Complex Double) -> Vector (Complex Double)
+ifft = genfft 1
diff --git a/lib/Numeric/GSL/Integration.hs b/lib/Numeric/GSL/Integration.hs
new file mode 100644
index 0000000..d756417
--- /dev/null
+++ b/lib/Numeric/GSL/Integration.hs
@@ -0,0 +1,90 @@
+{-# OPTIONS #-}
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Integration
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Numerical integration routines.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Numerical-Integration.html#Numerical-Integration>
+-}
+-----------------------------------------------------------------------------
+
+module Numeric.GSL.Integration (
+    integrateQNG,
+    integrateQAGS
+) where
+
+import Foreign
+import Data.Packed.Internal(mkfun,check,(//))
+
+
+--------------------------------------------------------------------
+{- | 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)@
+ 
+-}
+
+integrateQAGS :: Double               -- ^ precision (e.g. 1E-9)
+                 -> Int               -- ^ size of auxiliary workspace (e.g. 1000)
+                 -> (Double -> Double) -- ^ function to be integrated on the interval (a,b)
+                 -> Double           -- ^ a
+                 -> Double           -- ^ b
+                 -> (Double, Double) -- ^ result of the integration and error
+integrateQAGS prec n f a b = unsafePerformIO $ do
+    r <- malloc
+    e <- malloc
+    fp <- mkfun (\x _ -> f x) 
+    c_integrate_qags fp a b prec n r e // check "integrate_qags" []
+    vr <- peek r
+    ve <- peek e
+    let result = (vr,ve)
+    free r
+    free e
+    freeHaskellFunPtr fp
+    return result
+
+foreign import ccall "gsl-aux.h integrate_qags" 
+ c_integrate_qags :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double -> Int 
+                     -> Ptr Double -> Ptr Double -> IO Int
+
+-----------------------------------------------------------------
+{- | 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)@
+ 
+-}
+
+integrateQNG :: Double               -- ^ precision (e.g. 1E-9)
+                 -> (Double -> Double) -- ^ function to be integrated on the interval (a,b)
+                 -> Double           -- ^ a
+                 -> Double           -- ^ b
+                 -> (Double, Double) -- ^ result of the integration and error
+integrateQNG prec f a b = unsafePerformIO $ do
+    r <- malloc
+    e <- malloc
+    fp <- mkfun (\x _ -> f x) 
+    c_integrate_qng fp a b prec r e  // check "integrate_qng" []
+    vr <- peek r
+    ve <- peek e
+    let result = (vr,ve)
+    free r
+    free e
+    freeHaskellFunPtr fp
+    return result
+
+foreign import ccall "gsl-aux.h integrate_qng" 
+ c_integrate_qng :: FunPtr (Double-> Ptr() -> Double) -> Double -> Double -> Double 
+                    -> Ptr Double -> Ptr Double -> IO Int
+
diff --git a/lib/Numeric/GSL/Matrix.hs b/lib/Numeric/GSL/Matrix.hs
new file mode 100644
index 0000000..eb1931a
--- /dev/null
+++ b/lib/Numeric/GSL/Matrix.hs
@@ -0,0 +1,302 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Matrix
+-- Copyright   :  (c) Alberto Ruiz 2007
+-- License     :  GPL-style
+--
+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>
+-- Stability   :  provisional
+-- Portability :  portable (uses FFI)
+--
+-- A few linear algebra computations based on the Numeric.GSL (<http://www.gnu.org/software/Numeric.GSL>).
+--
+-----------------------------------------------------------------------------
+-- #hide
+
+module Numeric.GSL.Matrix(
+    eigSg, eigHg,
+    svdg,
+    qr,
+    cholR, -- cholC,
+    luSolveR, luSolveC,
+    luR, luC
+) where
+
+import Data.Packed.Internal
+import Data.Packed.Matrix(fromLists,ident,takeDiag)
+import Numeric.GSL.Vector
+import Foreign
+import Complex
+
+{- | eigendecomposition of a real symmetric matrix using /gsl_eigen_symmv/.
+
+> > let (l,v) = eigS $ 'fromLists' [[1,2],[2,1]]
+> > l
+> 3.000 -1.000
+>
+> > v
+> 0.707 -0.707
+> 0.707  0.707
+>
+> > v <> diag l <> trans v
+> 1.000 2.000
+> 2.000 1.000
+
+-}
+eigSg :: Matrix Double -> (Vector Double, Matrix Double)
+eigSg m
+    | r == 1 = (fromList [cdat m `at` 0], singleton 1)
+    | otherwise = unsafePerformIO $ do
+        l <- createVector r
+        v <- createMatrix RowMajor r r
+        c_eigS // mat cdat m // vec l // mat dat v // check "eigSg" [cdat m]
+        return (l,v)
+  where r = rows m
+foreign import ccall "gsl-aux.h eigensystemR" c_eigS :: TMVM
+
+------------------------------------------------------------------
+
+
+
+{- | eigendecomposition of a complex hermitian matrix using /gsl_eigen_hermv/
+
+> > let (l,v) = eigH $ 'fromLists' [[1,2+i],[2-i,3]]
+>
+> > l
+> 4.449 -0.449
+>
+> > v
+>         -0.544          0.839
+> (-0.751,0.375) (-0.487,0.243)
+>
+> > v <> diag l <> (conjTrans) v
+>          1.000 (2.000,1.000)
+> (2.000,-1.000)         3.000
+
+-}
+eigHg :: Matrix (Complex Double)-> (Vector Double, Matrix (Complex Double))
+eigHg m
+    | r == 1 = (fromList [realPart $ cdat m `at` 0], singleton 1)
+    | otherwise = unsafePerformIO $ do
+        l <- createVector r
+        v <- createMatrix RowMajor r r
+        c_eigH // mat cdat m // vec l // mat dat v // check "eigHg" [cdat m]
+        return (l,v)
+  where r = rows m
+foreign import ccall "gsl-aux.h eigensystemC" c_eigH :: TCMVCM
+
+
+{- | Singular value decomposition of a real matrix, using /gsl_linalg_SV_decomp_mod/:
+
+@\> let (u,s,v) = svdg $ 'fromLists' [[1,2,3],[-4,1,7]]
+\
+\> u
+0.310 -0.951
+0.951  0.310
+\
+\> s
+8.497 2.792
+\
+\> v
+-0.411 -0.785
+ 0.185 -0.570
+ 0.893 -0.243
+\
+\> u \<\> 'diag' s \<\> 'trans' v
+ 1. 2. 3.
+-4. 1. 7.@
+
+-}
+svdg :: Matrix Double -> (Matrix Double, Vector Double, Matrix Double)
+svdg x = if rows x >= cols x
+    then svd' x
+    else (v, s, u) where (u,s,v) = svd' (trans x)
+
+svd' x = unsafePerformIO $ do
+    u <- createMatrix RowMajor r c
+    s <- createVector c
+    v <- createMatrix RowMajor c c
+    c_svd // mat cdat x // mat dat u // vec s // mat dat v // check "svdg" [cdat x]
+    return (u,s,v)
+  where r = rows x
+        c = cols x
+foreign import ccall "gsl-aux.h svd" c_svd :: TMMVM
+
+{- | QR decomposition of a real matrix using /gsl_linalg_QR_decomp/ and /gsl_linalg_QR_unpack/.
+
+@\> let (q,r) = qr $ 'fromLists' [[1,3,5,7],[2,0,-2,4]]
+\
+\> q
+-0.447 -0.894
+-0.894  0.447
+\
+\> r
+-2.236 -1.342 -0.447 -6.708
+    0. -2.683 -5.367 -4.472
+\
+\> q \<\> r
+1.000 3.000  5.000 7.000
+2.000    0. -2.000 4.000@
+
+-}
+qr :: Matrix Double -> (Matrix Double, Matrix Double)
+qr x = unsafePerformIO $ do
+    q <- createMatrix RowMajor r r
+    rot <- createMatrix RowMajor r c
+    c_qr // mat cdat x // mat dat q // mat dat rot // check "qr" [cdat x]
+    return (q,rot)
+  where r = rows x
+        c = cols x
+foreign import ccall "gsl-aux.h QR" c_qr :: TMMM
+
+{- | Cholesky decomposition of a symmetric positive definite real matrix using /gsl_linalg_cholesky_decomp/.
+
+@\> chol $ (2><2) [1,2,
+                   2,9::Double]
+(2><2)
+ [ 1.0,              0.0
+ , 2.0, 2.23606797749979 ]@
+
+-}
+cholR :: Matrix Double -> Matrix Double
+cholR x = unsafePerformIO $ do
+    res <- createMatrix RowMajor r r
+    c_cholR // mat cdat x // mat dat res // check "cholR" [cdat x]
+    return res
+  where r = rows x
+foreign import ccall "gsl-aux.h cholR" c_cholR :: TMM
+
+cholC :: Matrix (Complex Double) -> Matrix (Complex Double)
+cholC x = unsafePerformIO $ do
+    res <- createMatrix RowMajor r r
+    c_cholC // mat cdat x // mat dat res // check "cholC" [cdat x]
+    return res
+  where r = rows x
+foreign import ccall "gsl-aux.h cholC" c_cholC :: TCMCM
+
+
+--------------------------------------------------------
+
+{- -| efficient multiplication by the inverse of a matrix (for real matrices)
+-}
+luSolveR :: Matrix Double -> Matrix Double -> Matrix Double
+luSolveR a b
+    | n1==n2 && n1==r = unsafePerformIO $ do
+        s <- createMatrix RowMajor r c
+        c_luSolveR // mat cdat a // mat cdat b // mat dat s // check "luSolveR" [cdat a, cdat b]
+        return s
+    | otherwise = error "luSolveR of nonsquare matrix"
+  where n1 = rows a
+        n2 = cols a
+        r  = rows b
+        c  = cols b
+foreign import ccall "gsl-aux.h luSolveR" c_luSolveR ::  TMMM
+
+{- -| efficient multiplication by the inverse of a matrix (for complex matrices). 
+-}
+luSolveC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)
+luSolveC a b
+    | n1==n2 && n1==r = unsafePerformIO $ do
+        s <- createMatrix RowMajor r c
+        c_luSolveC // mat cdat a // mat cdat b // mat dat s // check "luSolveC" [cdat a, cdat b]
+        return s
+    | otherwise = error "luSolveC of nonsquare matrix"
+  where n1 = rows a
+        n2 = cols a
+        r  = rows b
+        c  = cols b
+foreign import ccall "gsl-aux.h luSolveC" c_luSolveC ::  TCMCMCM
+
+{- | lu decomposition of real matrix (packed as a vector including l, u, the permutation and sign)
+-}
+luRaux  :: Matrix Double -> Vector Double
+luRaux x = unsafePerformIO $ do
+    res <- createVector (r*r+r+1)
+    c_luRaux // mat cdat x // vec res // check "luRaux" [cdat x]
+    return res
+  where r = rows x
+        c = cols x
+foreign import ccall "gsl-aux.h luRaux" c_luRaux :: TMV
+
+{- | lu decomposition of complex matrix (packed as a vector including l, u, the permutation and sign)
+-}
+luCaux  :: Matrix (Complex Double) -> Vector (Complex Double)
+luCaux x = unsafePerformIO $ do
+    res <- createVector (r*r+r+1)
+    c_luCaux // mat cdat x // vec res // check "luCaux" [cdat x]
+    return res
+  where r = rows x
+        c = cols x
+foreign import ccall "gsl-aux.h luCaux" c_luCaux :: TCMCV
+
+{- | The LU decomposition of a square matrix. Is based on /gsl_linalg_LU_decomp/ and  /gsl_linalg_complex_LU_decomp/ as described in <http://www.gnu.org/software/Numeric.GSL/manual/Numeric.GSL-ref_13.html#SEC223>.
+
+@\> let m = 'fromLists' [[1,2,-3],[2+3*i,-7,0],[1,-i,2*i]]
+\> let (l,u,p,s) = luR m@
+
+L is the lower triangular:
+
+@\> l
+          1.            0.  0.
+0.154-0.231i            1.  0.
+0.154-0.231i  0.624-0.522i  1.@
+
+U is the upper triangular:
+
+@\> u
+2.+3.i           -7.            0.
+    0.  3.077-1.615i           -3.
+    0.            0.  1.873+0.433i@
+
+p is a permutation:
+
+@\> p
+[1,0,2]@
+
+L \* U obtains a permuted version of the original matrix:
+
+@\> extractRows p m
+  2.+3.i   -7.   0.
+      1.    2.  -3.
+      1.  -1.i  2.i
+\ 
+\> l \<\> u
+ 2.+3.i   -7.   0.
+     1.    2.  -3.
+     1.  -1.i  2.i@
+
+s is the sign of the permutation, required to obtain sign of the determinant:
+
+@\> s * product ('toList' $ 'takeDiag' u)
+(-18.0) :+ (-16.000000000000004)
+\> 'LinearAlgebra.Algorithms.det' m
+(-18.0) :+ (-16.000000000000004)@
+
+ -}
+luR :: Matrix Double -> (Matrix Double, Matrix Double, [Int], Double)
+luR m = (l,u,p, fromIntegral s') where
+    r = rows m
+    v = luRaux m
+    lu = reshape r $ subVector 0 (r*r) v
+    s':p = map round . toList . subVector (r*r) (r+1) $ v
+    u = triang r r 0 1`mul` lu
+    l = (triang r r 0 0 `mul` lu) `add` ident r
+    add = liftMatrix2 $ vectorZipR Add
+    mul = liftMatrix2 $ vectorZipR Mul
+
+-- | Complex version of 'luR'.
+luC :: Matrix (Complex Double) -> (Matrix (Complex Double), Matrix (Complex Double), [Int], Complex Double)
+luC m = (l,u,p, fromIntegral s') where
+    r = rows m
+    v = luCaux m
+    lu = reshape r $ subVector 0 (r*r) v
+    s':p = map (round.realPart) . toList . subVector (r*r) (r+1) $ v
+    u = triang r r 0 1 `mul` lu
+    l = (triang r r 0 0 `mul` lu) `add` liftMatrix comp (ident r)
+    add = liftMatrix2 $ vectorZipC Add
+    mul = liftMatrix2 $ vectorZipC Mul
+
+{- auxiliary function to get triangular matrices
+-}
+triang r c h v = reshape c $ fromList [el i j | i<-[0..r-1], j<-[0..c-1]]
+    where el i j = if j-i>=h then v else 1 - v
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
new file mode 100644
index 0000000..23ca51b
--- /dev/null
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -0,0 +1,213 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Minimization
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Minimization of a multidimensional function Minimization of a multidimensional function using some of the algorithms described in:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Multidimensional-Minimization.html>
+
+-}
+-----------------------------------------------------------------------------
+module Numeric.GSL.Minimization (
+    minimizeConjugateGradient,
+    minimizeNMSimplex
+) where
+
+
+import Data.Packed.Internal
+import Data.Packed.Matrix
+import Foreign
+import Complex
+
+
+-------------------------------------------------------------------------
+
+{- | The method of Nelder and Mead, implemented by /gsl_multimin_fminimizer_nmsimplex/. The gradient of the function is not required. This is the example in the GSL manual:
+
+@minimize f xi = minimizeNMSimplex f xi (replicate (length xi) 1) 1e-2 100
+\ 
+f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
+\ 
+main = do
+    let (s,p) = minimize f [5,7]
+    print s
+    print p
+\ 
+\> main
+[0.9920430849306285,1.9969168063253164]
+0. 512.500    1.082 6.500    5.
+ 1. 290.625    1.372 5.250    4.
+ 2. 290.625    1.372 5.250    4.
+ 3. 252.500    1.372 5.500    1.
+ 4. 101.406    1.823 2.625 3.500
+ 5. 101.406    1.823 2.625 3.500
+ 6.     60.    1.823    0.    3.
+ 7.  42.275    1.303 2.094 1.875
+ 8.  42.275    1.303 2.094 1.875
+ 9.  35.684    1.026 0.258 1.906
+10.  35.664    0.804 0.588 2.445
+11.  30.680    0.467 1.258 2.025
+12.  30.680    0.356 1.258 2.025
+13.  30.539    0.285 1.093 1.849
+14.  30.137    0.168 0.883 2.004
+15.  30.137    0.123 0.883 2.004
+16.  30.090    0.100 0.958 2.060
+17.  30.005 6.051e-2 1.022 2.004
+18.  30.005 4.249e-2 1.022 2.004
+19.  30.005 4.249e-2 1.022 2.004
+20.  30.005 2.742e-2 1.022 2.004
+21.  30.005 2.119e-2 1.022 2.004
+22.  30.001 1.530e-2 0.992 1.997
+23.  30.001 1.259e-2 0.992 1.997
+24.  30.001 7.663e-3 0.992 1.997@
+
+The path to the solution can be graphically shown by means of:
+
+@'GSL.Plot.mplot' $ drop 3 ('toColumns' p)@
+
+-}
+minimizeNMSimplex :: ([Double] -> Double) -- ^ function to minimize
+          -> [Double]            -- ^ starting point
+          -> [Double]            -- ^ sizes of the initial search box
+          -> Double              -- ^ desired precision of the solution
+          -> Int                 -- ^ maximum number of iterations allowed
+          -> ([Double], Matrix Double)
+          -- ^ solution vector, and the optimization trajectory followed by the algorithm
+minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do
+    let xiv = fromList xi
+        szv = fromList sz
+        n   = dim xiv
+    fp <- mkVecfun (iv (f.toList))
+    rawpath <- createMIO maxit (n+3)
+                         (c_minimizeNMSimplex fp tol maxit // vec xiv // vec szv) 
+                         "minimizeNMSimplex" [xiv,szv]
+    let it = round (rawpath @@> (maxit-1,0))
+        path = takeRows it rawpath
+        [sol] = toLists $ dropRows (it-1) path
+    freeHaskellFunPtr fp
+    return (drop 3 sol, path)
+
+
+foreign import ccall "gsl-aux.h minimize"
+    c_minimizeNMSimplex:: FunPtr (Int -> Ptr Double -> Double) -> Double -> Int
+                       -> TVVM
+
+----------------------------------------------------------------------------------
+
+{- | The Fletcher-Reeves conjugate gradient algorithm /gsl_multimin_fminimizer_conjugate_fr/. This is the example in the GSL manual:
+
+@minimize = minimizeConjugateGradient 1E-2 1E-4 1E-3 30
+f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
+\ 
+df [x,y] = [20*(x-1), 40*(y-2)]
+\  
+main = do
+    let (s,p) = minimize f df [5,7]
+    print s
+    print p
+\ 
+\> main
+[1.0,2.0]
+ 0. 687.848 4.996 6.991
+ 1. 683.555 4.989 6.972
+ 2. 675.013 4.974 6.935
+ 3. 658.108 4.944 6.861
+ 4. 625.013 4.885 6.712
+ 5. 561.684 4.766 6.415
+ 6. 446.467 4.528 5.821
+ 7. 261.794 4.053 4.632
+ 8.  75.498 3.102 2.255
+ 9.  67.037 2.852 1.630
+10.  45.316 2.191 1.762
+11.  30.186 0.869 2.026
+12.     30.    1.    2.@
+
+The path to the solution can be graphically shown by means of:
+
+@'GSL.Plot.mplot' $ drop 2 ('toColumns' p)@
+
+-}     
+minimizeConjugateGradient ::
+       Double        -- ^ initial step size
+    -> Double        -- ^ minimization parameter   
+    -> Double        -- ^ desired precision of the solution (gradient test)
+    -> Int           -- ^ maximum number of iterations allowed
+    -> ([Double] -> Double) -- ^ function to minimize
+    -> ([Double] -> [Double])      -- ^ gradient
+    -> [Double]             -- ^ starting point
+    -> ([Double], Matrix Double)        -- ^ solution vector, and the optimization trajectory followed by the algorithm
+minimizeConjugateGradient istep minimpar tol maxit f df xi = unsafePerformIO $ do
+    let xiv = fromList xi
+        n = dim xiv
+        f' = f . toList
+        df' = (fromList . df . toList)
+    fp <- mkVecfun (iv f')
+    dfp <- mkVecVecfun (aux_vTov df')
+    print "entro"
+    rawpath <- createMIO maxit (n+2)
+                         (c_minimizeConjugateGradient fp dfp istep minimpar tol maxit // vec xiv)
+                         "minimizeDerivV" [xiv]
+    print "salgo"
+    let it = round (rawpath @@> (maxit-1,0))
+        path = takeRows it rawpath
+        sol = toList $ cdat $ dropColumns 2 $ dropRows (it-1) path
+    freeHaskellFunPtr fp
+    freeHaskellFunPtr dfp
+    return (sol,path)
+
+
+foreign import ccall "gsl-aux.h minimizeWithDeriv"
+    c_minimizeConjugateGradient :: FunPtr (Int -> Ptr Double -> Double)
+                                -> FunPtr (Int -> Ptr Double -> Ptr Double -> IO ())
+                                -> Double -> Double -> Double -> Int
+                                -> TVM
+
+---------------------------------------------------------------------
+iv :: (Vector Double -> Double) -> (Int -> Ptr Double -> Double)
+iv f n p = f (createV n copy "iv" []) where
+    copy n q = do 
+        copyArray q p n
+        return 0
+
+-- | conversion of Haskell functions into function pointers that can be used in the C side
+foreign import ccall "wrapper"
+    mkVecfun :: (Int -> Ptr Double -> Double)
+             -> IO( FunPtr (Int -> Ptr Double -> Double))
+
+-- | another required conversion
+foreign import ccall "wrapper"
+    mkVecVecfun :: (Int -> Ptr Double -> Ptr Double -> IO ())
+                -> IO (FunPtr (Int -> Ptr Double -> Ptr Double->IO()))
+
+aux_vTov :: (Vector Double -> Vector Double) -> (Int -> Ptr Double -> Ptr Double -> IO())
+aux_vTov f n p r = g where
+    V {fptr = pr, ptr = t} = f x
+    x = createV n copy "aux_vTov" []
+    copy n q = do
+        copyArray q p n
+        return 0
+    g = withForeignPtr pr $ \_ -> copyArray r t n
+
+--------------------------------------------------------------------
+
+createV n fun msg ptrs = unsafePerformIO $ do
+    r <- createVector n
+    fun // vec r // check msg ptrs
+    return r
+
+createM r c fun msg ptrs = unsafePerformIO $ do
+    r <- createMatrix RowMajor r c
+    fun // mat cdat r // check msg ptrs
+    return r
+
+createMIO r c fun msg ptrs = do
+    r <- createMatrix RowMajor r c
+    fun // mat cdat r // check msg ptrs
+    return r
diff --git a/lib/Numeric/GSL/Polynomials.hs b/lib/Numeric/GSL/Polynomials.hs
new file mode 100644
index 0000000..42694f0
--- /dev/null
+++ b/lib/Numeric/GSL/Polynomials.hs
@@ -0,0 +1,54 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Polynomials
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Polynomials.
+
+<http://www.gnu.org/software/gsl/manual/html_node/General-Polynomial-Equations.html#General-Polynomial-Equations>
+
+-}
+-----------------------------------------------------------------------------
+module Numeric.GSL.Polynomials (
+    polySolve
+) where
+
+import Data.Packed.Internal
+import Complex
+import Foreign
+
+{- | 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]
+[(-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 :: [Double] -> [Complex Double]
+polySolve = toList . polySolve' . fromList
+
+polySolve' :: Vector Double -> Vector (Complex Double)
+polySolve' v | dim v > 1 = unsafePerformIO $ do
+    r <- createVector (dim v-1)
+    c_polySolve // vec v // vec r // check "polySolve" [v]
+    return r
+             | otherwise = error "polySolve on a polynomial of degree zero"
+
+foreign import ccall "gsl-aux.h polySolve" c_polySolve:: TVCV
diff --git a/lib/Numeric/GSL/Special.hs b/lib/Numeric/GSL/Special.hs
new file mode 100644
index 0000000..b6cea2b
--- /dev/null
+++ b/lib/Numeric/GSL/Special.hs
@@ -0,0 +1,74 @@
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected special functions.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>
+-}
+-----------------------------------------------------------------------------
+
+module Numeric.GSL.Special (
+  module Numeric.GSL.Special.Airy
+, module Numeric.GSL.Special.Bessel
+, module Numeric.GSL.Special.Clausen
+, module Numeric.GSL.Special.Coulomb
+, module Numeric.GSL.Special.Coupling
+, module Numeric.GSL.Special.Dawson
+, module Numeric.GSL.Special.Debye
+, module Numeric.GSL.Special.Dilog
+, module Numeric.GSL.Special.Elementary
+, module Numeric.GSL.Special.Ellint
+, module Numeric.GSL.Special.Erf
+, module Numeric.GSL.Special.Exp
+, module Numeric.GSL.Special.Expint
+, module Numeric.GSL.Special.Fermi_dirac
+, module Numeric.GSL.Special.Gamma
+, module Numeric.GSL.Special.Gegenbauer
+, module Numeric.GSL.Special.Hyperg
+, module Numeric.GSL.Special.Laguerre
+, module Numeric.GSL.Special.Lambert
+, module Numeric.GSL.Special.Legendre
+, module Numeric.GSL.Special.Log
+, module Numeric.GSL.Special.Pow_int
+, module Numeric.GSL.Special.Psi
+, module Numeric.GSL.Special.Synchrotron
+, module Numeric.GSL.Special.Trig
+, module Numeric.GSL.Special.Zeta
+)
+where
+
+import Foreign
+import Numeric.GSL.Special.Internal
+import Numeric.GSL.Special.Airy
+import Numeric.GSL.Special.Bessel
+import Numeric.GSL.Special.Clausen
+import Numeric.GSL.Special.Coulomb
+import Numeric.GSL.Special.Coupling
+import Numeric.GSL.Special.Dawson
+import Numeric.GSL.Special.Debye
+import Numeric.GSL.Special.Dilog
+import Numeric.GSL.Special.Elementary
+import Numeric.GSL.Special.Ellint
+import Numeric.GSL.Special.Erf
+import Numeric.GSL.Special.Exp
+import Numeric.GSL.Special.Expint
+import Numeric.GSL.Special.Fermi_dirac
+import Numeric.GSL.Special.Gamma
+import Numeric.GSL.Special.Gegenbauer
+import Numeric.GSL.Special.Hyperg
+import Numeric.GSL.Special.Laguerre
+import Numeric.GSL.Special.Lambert
+import Numeric.GSL.Special.Legendre
+import Numeric.GSL.Special.Log
+import Numeric.GSL.Special.Pow_int
+import Numeric.GSL.Special.Psi
+import Numeric.GSL.Special.Synchrotron
+import Numeric.GSL.Special.Trig
+import Numeric.GSL.Special.Zeta
diff --git a/lib/Numeric/GSL/Special/Airy.hs b/lib/Numeric/GSL/Special/Airy.hs
new file mode 100644
index 0000000..d987e1f
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Airy.hs
@@ -0,0 +1,166 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Airy
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Airy-Functions-and-Derivatives.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Airy(
+  Precision (..)
+, airy_Ai_e
+, airy_Ai
+, airy_Bi_e
+, airy_Bi
+, airy_Ai_scaled_e
+, airy_Ai_scaled
+, airy_Bi_scaled_e
+, airy_Bi_scaled
+, airy_Ai_deriv_e
+, airy_Ai_deriv
+, airy_Bi_deriv_e
+, airy_Bi_deriv
+, airy_Ai_deriv_scaled_e
+, airy_Ai_deriv_scaled
+, airy_Bi_deriv_scaled_e
+, airy_Bi_deriv_scaled
+, airy_zero_Ai_e
+, airy_zero_Ai
+, airy_zero_Bi_e
+, airy_zero_Bi
+, airy_zero_Ai_deriv_e
+, airy_zero_Ai_deriv
+, airy_zero_Bi_deriv_e
+, airy_zero_Bi_deriv
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_airy_Ai_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Ai_e :: Double -> Precision -> (Double,Double)
+airy_Ai_e x mode = createSFR "airy_Ai_e" $ gsl_sf_airy_Ai_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Ai(double x,gsl_mode_t mode);
+airy_Ai :: Double -> Precision -> Double
+airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Bi_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Bi_e :: Double -> Precision -> (Double,Double)
+airy_Bi_e x mode = createSFR "airy_Bi_e" $ gsl_sf_airy_Bi_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Bi(double x,gsl_mode_t mode);
+airy_Bi :: Double -> Precision -> Double
+airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Ai_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Ai_scaled_e :: Double -> Precision -> (Double,Double)
+airy_Ai_scaled_e x mode = createSFR "airy_Ai_scaled_e" $ gsl_sf_airy_Ai_scaled_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Ai_scaled(double x,gsl_mode_t mode);
+airy_Ai_scaled :: Double -> Precision -> Double
+airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Bi_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Bi_scaled_e :: Double -> Precision -> (Double,Double)
+airy_Bi_scaled_e x mode = createSFR "airy_Bi_scaled_e" $ gsl_sf_airy_Bi_scaled_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Bi_scaled(double x,gsl_mode_t mode);
+airy_Bi_scaled :: Double -> Precision -> Double
+airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Ai_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Ai_deriv_e :: Double -> Precision -> (Double,Double)
+airy_Ai_deriv_e x mode = createSFR "airy_Ai_deriv_e" $ gsl_sf_airy_Ai_deriv_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Ai_deriv(double x,gsl_mode_t mode);
+airy_Ai_deriv :: Double -> Precision -> Double
+airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Bi_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Bi_deriv_e :: Double -> Precision -> (Double,Double)
+airy_Bi_deriv_e x mode = createSFR "airy_Bi_deriv_e" $ gsl_sf_airy_Bi_deriv_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Bi_deriv(double x,gsl_mode_t mode);
+airy_Bi_deriv :: Double -> Precision -> Double
+airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Ai_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Ai_deriv_scaled_e :: Double -> Precision -> (Double,Double)
+airy_Ai_deriv_scaled_e x mode = createSFR "airy_Ai_deriv_scaled_e" $ gsl_sf_airy_Ai_deriv_scaled_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Ai_deriv_scaled(double x,gsl_mode_t mode);
+airy_Ai_deriv_scaled :: Double -> Precision -> Double
+airy_Ai_deriv_scaled x mode = gsl_sf_airy_Ai_deriv_scaled x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_Bi_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
+airy_Bi_deriv_scaled_e :: Double -> Precision -> (Double,Double)
+airy_Bi_deriv_scaled_e x mode = createSFR "airy_Bi_deriv_scaled_e" $ gsl_sf_airy_Bi_deriv_scaled_e x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_Bi_deriv_scaled(double x,gsl_mode_t mode);
+airy_Bi_deriv_scaled :: Double -> Precision -> Double
+airy_Bi_deriv_scaled x mode = gsl_sf_airy_Bi_deriv_scaled x  (precCode mode)
+foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_airy_zero_Ai_e(int s,gsl_sf_result* result);
+airy_zero_Ai_e :: Int -> (Double,Double)
+airy_zero_Ai_e s = createSFR "airy_zero_Ai_e" $ gsl_sf_airy_zero_Ai_e s
+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_zero_Ai(int s);
+airy_zero_Ai :: Int -> Double
+airy_zero_Ai = gsl_sf_airy_zero_Ai
+foreign import ccall "airy.h gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: Int -> Double
+
+-- | wrapper for int gsl_sf_airy_zero_Bi_e(int s,gsl_sf_result* result);
+airy_zero_Bi_e :: Int -> (Double,Double)
+airy_zero_Bi_e s = createSFR "airy_zero_Bi_e" $ gsl_sf_airy_zero_Bi_e s
+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_zero_Bi(int s);
+airy_zero_Bi :: Int -> Double
+airy_zero_Bi = gsl_sf_airy_zero_Bi
+foreign import ccall "airy.h gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: Int -> Double
+
+-- | wrapper for int gsl_sf_airy_zero_Ai_deriv_e(int s,gsl_sf_result* result);
+airy_zero_Ai_deriv_e :: Int -> (Double,Double)
+airy_zero_Ai_deriv_e s = createSFR "airy_zero_Ai_deriv_e" $ gsl_sf_airy_zero_Ai_deriv_e s
+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_zero_Ai_deriv(int s);
+airy_zero_Ai_deriv :: Int -> Double
+airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv
+foreign import ccall "airy.h gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: Int -> Double
+
+-- | wrapper for int gsl_sf_airy_zero_Bi_deriv_e(int s,gsl_sf_result* result);
+airy_zero_Bi_deriv_e :: Int -> (Double,Double)
+airy_zero_Bi_deriv_e s = createSFR "airy_zero_Bi_deriv_e" $ gsl_sf_airy_zero_Bi_deriv_e s
+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_airy_zero_Bi_deriv(int s);
+airy_zero_Bi_deriv :: Int -> Double
+airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv
+foreign import ccall "airy.h gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: Int -> Double
diff --git a/lib/Numeric/GSL/Special/Bessel.hs b/lib/Numeric/GSL/Special/Bessel.hs
new file mode 100644
index 0000000..e059666
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Bessel.hs
@@ -0,0 +1,809 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Bessel
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_bessel.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Bessel(
+  bessel_J0_e
+, bessel_J0
+, bessel_J1_e
+, bessel_J1
+, bessel_Jn_e
+, bessel_Jn
+, bessel_Y0_e
+, bessel_Y0
+, bessel_Y1_e
+, bessel_Y1
+, bessel_Yn_e
+, bessel_Yn
+, bessel_I0_e
+, bessel_I0
+, bessel_I1_e
+, bessel_I1
+, bessel_In_e
+, bessel_In
+, bessel_I0_scaled_e
+, bessel_I0_scaled
+, bessel_I1_scaled_e
+, bessel_I1_scaled
+, bessel_In_scaled_e
+, bessel_In_scaled
+, bessel_K0_e
+, bessel_K0
+, bessel_K1_e
+, bessel_K1
+, bessel_Kn_e
+, bessel_Kn
+, bessel_K0_scaled_e
+, bessel_K0_scaled
+, bessel_K1_scaled_e
+, bessel_K1_scaled
+, bessel_Kn_scaled_e
+, bessel_Kn_scaled
+, bessel_j0_e
+, bessel_j0
+, bessel_j1_e
+, bessel_j1
+, bessel_j2_e
+, bessel_j2
+, bessel_jl_e
+, bessel_jl
+, bessel_y0_e
+, bessel_y0
+, bessel_y1_e
+, bessel_y1
+, bessel_y2_e
+, bessel_y2
+, bessel_yl_e
+, bessel_yl
+, bessel_i0_scaled_e
+, bessel_i0_scaled
+, bessel_i1_scaled_e
+, bessel_i1_scaled
+, bessel_i2_scaled_e
+, bessel_i2_scaled
+, bessel_il_scaled_e
+, bessel_il_scaled
+, bessel_k0_scaled_e
+, bessel_k0_scaled
+, bessel_k1_scaled_e
+, bessel_k1_scaled
+, bessel_k2_scaled_e
+, bessel_k2_scaled
+, bessel_kl_scaled_e
+, bessel_kl_scaled
+, bessel_Jnu_e
+, bessel_Jnu
+, bessel_Ynu_e
+, bessel_Ynu
+, bessel_Inu_scaled_e
+, bessel_Inu_scaled
+, bessel_Inu_e
+, bessel_Inu
+, bessel_Knu_scaled_e
+, bessel_Knu_scaled
+, bessel_Knu_e
+, bessel_Knu
+, bessel_lnKnu_e
+, bessel_lnKnu
+, bessel_zero_J0_e
+, bessel_zero_J0
+, bessel_zero_J1_e
+, bessel_zero_J1
+, bessel_zero_Jnu_e
+, bessel_zero_Jnu
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_bessel_J0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_J0_e :: Double -> (Double,Double)
+bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_J0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_J0 :: Double -> Double
+bessel_J0 = gsl_sf_bessel_J0
+foreign import ccall "bessel.h gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_J1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_J1_e :: Double -> (Double,Double)
+bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_J1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_J1 :: Double -> Double
+bessel_J1 = gsl_sf_bessel_J1
+foreign import ccall "bessel.h gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Jn_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Jn_e :: Int -> Double -> (Double,Double)
+bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Jn(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Jn :: Int -> Double -> Double
+bessel_Jn = gsl_sf_bessel_Jn
+foreign import ccall "bessel.h gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Jn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_Jn_array = gsl_sf_bessel_Jn_array
+foreign import ccall "bessel.h gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_Y0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Y0_e :: Double -> (Double,Double)
+bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Y0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Y0 :: Double -> Double
+bessel_Y0 = gsl_sf_bessel_Y0
+foreign import ccall "bessel.h gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Y1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Y1_e :: Double -> (Double,Double)
+bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Y1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Y1 :: Double -> Double
+bessel_Y1 = gsl_sf_bessel_Y1
+foreign import ccall "bessel.h gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Yn_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Yn_e :: Int -> Double -> (Double,Double)
+bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Yn(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Yn :: Int -> Double -> Double
+bessel_Yn = gsl_sf_bessel_Yn
+foreign import ccall "bessel.h gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Yn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_Yn_array = gsl_sf_bessel_Yn_array
+foreign import ccall "bessel.h gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_I0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I0_e :: Double -> (Double,Double)
+bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_I0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I0 :: Double -> Double
+bessel_I0 = gsl_sf_bessel_I0
+foreign import ccall "bessel.h gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_I1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I1_e :: Double -> (Double,Double)
+bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_I1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I1 :: Double -> Double
+bessel_I1 = gsl_sf_bessel_I1
+foreign import ccall "bessel.h gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_In_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In_e :: Int -> Double -> (Double,Double)
+bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_In(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In :: Int -> Double -> Double
+bessel_In = gsl_sf_bessel_In
+foreign import ccall "bessel.h gsl_sf_bessel_In" gsl_sf_bessel_In :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_In_array = gsl_sf_bessel_In_array
+foreign import ccall "bessel.h gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_I0_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I0_scaled_e :: Double -> (Double,Double)
+bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_I0_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I0_scaled :: Double -> Double
+bessel_I0_scaled = gsl_sf_bessel_I0_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_I1_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I1_scaled_e :: Double -> (Double,Double)
+bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_I1_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_I1_scaled :: Double -> Double
+bessel_I1_scaled = gsl_sf_bessel_I1_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_In_scaled_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In_scaled_e :: Int -> Double -> (Double,Double)
+bessel_In_scaled_e n x = createSFR "bessel_In_scaled_e" $ gsl_sf_bessel_In_scaled_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_In_scaled(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In_scaled :: Int -> Double -> Double
+bessel_In_scaled = gsl_sf_bessel_In_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array
+foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_K0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K0_e :: Double -> (Double,Double)
+bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_K0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K0 :: Double -> Double
+bessel_K0 = gsl_sf_bessel_K0
+foreign import ccall "bessel.h gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_K1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K1_e :: Double -> (Double,Double)
+bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_K1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K1 :: Double -> Double
+bessel_K1 = gsl_sf_bessel_K1
+foreign import ccall "bessel.h gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Kn_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn_e :: Int -> Double -> (Double,Double)
+bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Kn(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn :: Int -> Double -> Double
+bessel_Kn = gsl_sf_bessel_Kn
+foreign import ccall "bessel.h gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_Kn_array = gsl_sf_bessel_Kn_array
+foreign import ccall "bessel.h gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_K0_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K0_scaled_e :: Double -> (Double,Double)
+bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_K0_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K0_scaled :: Double -> Double
+bessel_K0_scaled = gsl_sf_bessel_K0_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_K1_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K1_scaled_e :: Double -> (Double,Double)
+bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_K1_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_K1_scaled :: Double -> Double
+bessel_K1_scaled = gsl_sf_bessel_K1_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Kn_scaled_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn_scaled_e :: Int -> Double -> (Double,Double)
+bessel_Kn_scaled_e n x = createSFR "bessel_Kn_scaled_e" $ gsl_sf_bessel_Kn_scaled_e n x
+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Kn_scaled(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn_scaled :: Int -> Double -> Double
+bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int
+bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array
+foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_j0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j0_e :: Double -> (Double,Double)
+bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_j0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j0 :: Double -> Double
+bessel_j0 = gsl_sf_bessel_j0
+foreign import ccall "bessel.h gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_j1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j1_e :: Double -> (Double,Double)
+bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_j1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j1 :: Double -> Double
+bessel_j1 = gsl_sf_bessel_j1
+foreign import ccall "bessel.h gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_j2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j2_e :: Double -> (Double,Double)
+bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x
+foreign import ccall "bessel.h gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_j2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_j2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_j2 :: Double -> Double
+bessel_j2 = gsl_sf_bessel_j2
+foreign import ccall "bessel.h gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_jl_e(int l,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_jl_e :: Int -> Double -> (Double,Double)
+bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x
+foreign import ccall "bessel.h gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_jl(int l,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_jl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_jl :: Int -> Double -> Double
+bessel_jl = gsl_sf_bessel_jl
+foreign import ccall "bessel.h gsl_sf_bessel_jl" gsl_sf_bessel_jl :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_jl_array :: Int -> Double -> Ptr Double -> Int
+bessel_jl_array = gsl_sf_bessel_jl_array
+foreign import ccall "bessel.h gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_jl_steed_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int
+bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array
+foreign import ccall "bessel.h gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_y0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y0_e :: Double -> (Double,Double)
+bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x
+foreign import ccall "bessel.h gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_y0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y0 :: Double -> Double
+bessel_y0 = gsl_sf_bessel_y0
+foreign import ccall "bessel.h gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_y1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y1_e :: Double -> (Double,Double)
+bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x
+foreign import ccall "bessel.h gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_y1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y1 :: Double -> Double
+bessel_y1 = gsl_sf_bessel_y1
+foreign import ccall "bessel.h gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_y2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y2_e :: Double -> (Double,Double)
+bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x
+foreign import ccall "bessel.h gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_y2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_y2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_y2 :: Double -> Double
+bessel_y2 = gsl_sf_bessel_y2
+foreign import ccall "bessel.h gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_yl_e(int l,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_yl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_yl_e :: Int -> Double -> (Double,Double)
+bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x
+foreign import ccall "bessel.h gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_yl(int l,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_yl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_yl :: Int -> Double -> Double
+bessel_yl = gsl_sf_bessel_yl
+foreign import ccall "bessel.h gsl_sf_bessel_yl" gsl_sf_bessel_yl :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_yl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_yl_array :: Int -> Double -> Ptr Double -> Int
+bessel_yl_array = gsl_sf_bessel_yl_array
+foreign import ccall "bessel.h gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_i0_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i0_scaled_e :: Double -> (Double,Double)
+bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_i0_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i0_scaled :: Double -> Double
+bessel_i0_scaled = gsl_sf_bessel_i0_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_i1_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i1_scaled_e :: Double -> (Double,Double)
+bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_i1_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i1_scaled :: Double -> Double
+bessel_i1_scaled = gsl_sf_bessel_i1_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_i2_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i2_scaled_e :: Double -> (Double,Double)
+bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_i2_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_i2_scaled :: Double -> Double
+bessel_i2_scaled = gsl_sf_bessel_i2_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_il_scaled_e(int l,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_il_scaled_e :: Int -> Double -> (Double,Double)
+bessel_il_scaled_e l x = createSFR "bessel_il_scaled_e" $ gsl_sf_bessel_il_scaled_e l x
+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_il_scaled(int l,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_il_scaled :: Int -> Double -> Double
+bessel_il_scaled = gsl_sf_bessel_il_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int
+bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array
+foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_k0_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k0_scaled_e :: Double -> (Double,Double)
+bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_k0_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k0_scaled :: Double -> Double
+bessel_k0_scaled = gsl_sf_bessel_k0_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_k1_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k1_scaled_e :: Double -> (Double,Double)
+bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_k1_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k1_scaled :: Double -> Double
+bessel_k1_scaled = gsl_sf_bessel_k1_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_k2_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k2_scaled_e :: Double -> (Double,Double)
+bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x
+foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_k2_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_k2_scaled :: Double -> Double
+bessel_k2_scaled = gsl_sf_bessel_k2_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_kl_scaled_e(int l,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_kl_scaled_e :: Int -> Double -> (Double,Double)
+bessel_kl_scaled_e l x = createSFR "bessel_kl_scaled_e" $ gsl_sf_bessel_kl_scaled_e l x
+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_kl_scaled(int l,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_kl_scaled :: Int -> Double -> Double
+bessel_kl_scaled = gsl_sf_bessel_kl_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int
+bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array
+foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_Jnu_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Jnu_e :: Double -> Double -> (Double,Double)
+bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Jnu(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Jnu :: Double -> Double -> Double
+bessel_Jnu = gsl_sf_bessel_Jnu
+foreign import ccall "bessel.h gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Ynu_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Ynu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Ynu_e :: Double -> Double -> (Double,Double)
+bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Ynu(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Ynu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Ynu :: Double -> Double -> Double
+bessel_Ynu = gsl_sf_bessel_Ynu
+foreign import ccall "bessel.h gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_sequence_Jnu_e(double nu,gsl_mode_t mode,size_t size,double* v);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_sequence_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> Int
+bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v
+foreign import ccall "bessel.h gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_bessel_Inu_scaled_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Inu_scaled_e :: Double -> Double -> (Double,Double)
+bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Inu_scaled(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Inu_scaled :: Double -> Double -> Double
+bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Inu_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Inu_e :: Double -> Double -> (Double,Double)
+bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Inu(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Inu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Inu :: Double -> Double -> Double
+bessel_Inu = gsl_sf_bessel_Inu
+foreign import ccall "bessel.h gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Knu_scaled_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Knu_scaled_e :: Double -> Double -> (Double,Double)
+bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Knu_scaled(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Knu_scaled :: Double -> Double -> Double
+bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled
+foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_Knu_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Knu_e :: Double -> Double -> (Double,Double)
+bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_Knu(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_Knu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_Knu :: Double -> Double -> Double
+bessel_Knu = gsl_sf_bessel_Knu
+foreign import ccall "bessel.h gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_lnKnu_e(double nu,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_lnKnu_e :: Double -> Double -> (Double,Double)
+bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x
+foreign import ccall "bessel.h gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_lnKnu(double nu,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_lnKnu :: Double -> Double -> Double
+bessel_lnKnu = gsl_sf_bessel_lnKnu
+foreign import ccall "bessel.h gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_bessel_zero_J0_e(int s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_J0_e :: Int -> (Double,Double)
+bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s
+foreign import ccall "bessel.h gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_zero_J0(int s);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_J0 :: Int -> Double
+bessel_zero_J0 = gsl_sf_bessel_zero_J0
+foreign import ccall "bessel.h gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: Int -> Double
+
+-- | wrapper for int gsl_sf_bessel_zero_J1_e(int s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_J1_e :: Int -> (Double,Double)
+bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s
+foreign import ccall "bessel.h gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_zero_J1(int s);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_J1 :: Int -> Double
+bessel_zero_J1 = gsl_sf_bessel_zero_J1
+foreign import ccall "bessel.h gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: Int -> Double
+
+-- | wrapper for int gsl_sf_bessel_zero_Jnu_e(double nu,int s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_Jnu_e :: Double -> Int -> (Double,Double)
+bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s
+foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_bessel_zero_Jnu(double nu,int s);
+--
+--   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+bessel_zero_Jnu :: Double -> Int -> Double
+bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu
+foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> Int -> Double
diff --git a/lib/Numeric/GSL/Special/Clausen.hs b/lib/Numeric/GSL/Special/Clausen.hs
new file mode 100644
index 0000000..3052187
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Clausen.hs
@@ -0,0 +1,37 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Clausen
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_clausen.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Clausen(
+  clausen_e
+, clausen
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_clausen_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_clausen_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+clausen_e :: Double -> (Double,Double)
+clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x
+foreign import ccall "clausen.h gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_clausen(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_clausen&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+clausen :: Double -> Double
+clausen = gsl_sf_clausen
+foreign import ccall "clausen.h gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Coulomb.hs b/lib/Numeric/GSL/Special/Coulomb.hs
new file mode 100644
index 0000000..06848cb
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Coulomb.hs
@@ -0,0 +1,103 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Coulomb
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_coulomb.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Coulomb(
+  hydrogenicR_1_e
+, hydrogenicR_1
+, hydrogenicR_e
+, hydrogenicR
+, coulomb_CL_e
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_hydrogenicR_1_e(double Z,double r,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hydrogenicR_1_e :: Double -> Double -> (Double,Double)
+hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r
+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hydrogenicR_1(double Z,double r);
+--
+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hydrogenicR_1 :: Double -> Double -> Double
+hydrogenicR_1 = gsl_sf_hydrogenicR_1
+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hydrogenicR_e :: Int -> Int -> Double -> Double -> (Double,Double)
+hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r
+foreign import ccall "coulomb.h gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: Int -> Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hydrogenicR(int n,int l,double Z,double r);
+--
+--   <http://www.google.com/search?q=gsl_sf_hydrogenicR&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hydrogenicR :: Int -> Int -> Double -> Double -> Double
+hydrogenicR = gsl_sf_hydrogenicR
+foreign import ccall "coulomb.h gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: Int -> Int -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,gsl_sf_result* F,gsl_sf_result* Fp,gsl_sf_result* G,gsl_sf_result* Gp,double* exp_F,double* exp_G);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e
+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_F_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int
+coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array
+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array
+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FGp_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array
+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_wave_sphF_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int
+coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array
+foreign import ccall "coulomb.h gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_coulomb_CL_e(double L,double eta,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_CL_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_CL_e :: Double -> Double -> (Double,Double)
+coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta
+foreign import ccall "coulomb.h gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);
+--
+--   <http://www.google.com/search?q=gsl_sf_coulomb_CL_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int
+coulomb_CL_array = gsl_sf_coulomb_CL_array
+foreign import ccall "coulomb.h gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int
diff --git a/lib/Numeric/GSL/Special/Coupling.hs b/lib/Numeric/GSL/Special/Coupling.hs
new file mode 100644
index 0000000..9578b1b
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Coupling.hs
@@ -0,0 +1,81 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Coupling
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Coupling-Coefficients.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Coupling(
+  coupling_3j_e
+, coupling_3j
+, coupling_6j_e
+, coupling_6j
+, coupling_RacahW_e
+, coupling_RacahW
+, coupling_9j_e
+, coupling_9j
+-- , coupling_6j_INCORRECT_e
+-- , coupling_6j_INCORRECT
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_coupling_3j_e(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc,gsl_sf_result* result);
+coupling_3j_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)
+coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc = createSFR "coupling_3j_e" $ gsl_sf_coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc
+foreign import ccall "coupling.h gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);
+coupling_3j :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+coupling_3j = gsl_sf_coupling_3j
+foreign import ccall "coupling.h gsl_sf_coupling_3j" gsl_sf_coupling_3j :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
+coupling_6j_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)
+coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_e" $ gsl_sf_coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf
+foreign import ccall "coupling.h gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+coupling_6j :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+coupling_6j = gsl_sf_coupling_6j
+foreign import ccall "coupling.h gsl_sf_coupling_6j" gsl_sf_coupling_6j :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
+coupling_RacahW_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)
+coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_RacahW_e" $ gsl_sf_coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf
+foreign import ccall "coupling.h gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+coupling_RacahW :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+coupling_RacahW = gsl_sf_coupling_RacahW
+foreign import ccall "coupling.h gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,gsl_sf_result* result);
+coupling_9j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)
+coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji = createSFR "coupling_9j_e" $ gsl_sf_coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji
+foreign import ccall "coupling.h gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);
+coupling_9j :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double
+coupling_9j = gsl_sf_coupling_9j
+foreign import ccall "coupling.h gsl_sf_coupling_9j" gsl_sf_coupling_9j :: Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
+coupling_6j_INCORRECT_e :: Int -> Int -> Int -> Int -> Int -> Int -> (Double,Double)
+coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_INCORRECT_e" $ gsl_sf_coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf
+foreign import ccall "coupling.h gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: Int -> Int -> Int -> Int -> Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+coupling_6j_INCORRECT :: Int -> Int -> Int -> Int -> Int -> Int -> Double
+coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT
+foreign import ccall "coupling.h gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: Int -> Int -> Int -> Int -> Int -> Int -> Double
diff --git a/lib/Numeric/GSL/Special/Dawson.hs b/lib/Numeric/GSL/Special/Dawson.hs
new file mode 100644
index 0000000..1d77a2b
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Dawson.hs
@@ -0,0 +1,37 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Dawson
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_dawson.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Dawson(
+  dawson_e
+, dawson
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_dawson_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_dawson_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+dawson_e :: Double -> (Double,Double)
+dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x
+foreign import ccall "dawson.h gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_dawson(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_dawson&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+dawson :: Double -> Double
+dawson = gsl_sf_dawson
+foreign import ccall "dawson.h gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Debye.hs b/lib/Numeric/GSL/Special/Debye.hs
new file mode 100644
index 0000000..b8e9aca
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Debye.hs
@@ -0,0 +1,85 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Debye
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_debye.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Debye(
+  debye_1_e
+, debye_1
+, debye_2_e
+, debye_2
+, debye_3_e
+, debye_3
+, debye_4_e
+, debye_4
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_debye_1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_1_e :: Double -> (Double,Double)
+debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x
+foreign import ccall "debye.h gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_debye_1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_1 :: Double -> Double
+debye_1 = gsl_sf_debye_1
+foreign import ccall "debye.h gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_debye_2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_2_e :: Double -> (Double,Double)
+debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x
+foreign import ccall "debye.h gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_debye_2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_2 :: Double -> Double
+debye_2 = gsl_sf_debye_2
+foreign import ccall "debye.h gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_debye_3_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_3_e :: Double -> (Double,Double)
+debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x
+foreign import ccall "debye.h gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_debye_3(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_3 :: Double -> Double
+debye_3 = gsl_sf_debye_3
+foreign import ccall "debye.h gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
+
+-- | wrapper for int gsl_sf_debye_4_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_4_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_4_e :: Double -> (Double,Double)
+debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x
+foreign import ccall "debye.h gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_debye_4(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_debye_4&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+debye_4 :: Double -> Double
+debye_4 = gsl_sf_debye_4
+foreign import ccall "debye.h gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Dilog.hs b/lib/Numeric/GSL/Special/Dilog.hs
new file mode 100644
index 0000000..e7693da
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Dilog.hs
@@ -0,0 +1,58 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Dilog
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_dilog.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Dilog(
+  dilog_e
+, dilog
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_dilog_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+dilog_e :: Double -> (Double,Double)
+dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x
+foreign import ccall "dilog.h gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_dilog(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_dilog&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+dilog :: Double -> Double
+dilog = gsl_sf_dilog
+foreign import ccall "dilog.h gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
+
+-- | wrapper for int gsl_sf_complex_dilog_xy_e(double x,double y,gsl_sf_result* result_re,gsl_sf_result* result_im);
+--
+--   <http://www.google.com/search?q=gsl_sf_complex_dilog_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+complex_dilog_xy_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re
+foreign import ccall "dilog.h gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_complex_dilog_e(double r,double theta,gsl_sf_result* result_re,gsl_sf_result* result_im);
+--
+--   <http://www.google.com/search?q=gsl_sf_complex_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+complex_dilog_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re
+foreign import ccall "dilog.h gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_complex_spence_xy_e(double x,double y,gsl_sf_result* real_sp,gsl_sf_result* imag_sp);
+--
+--   <http://www.google.com/search?q=gsl_sf_complex_spence_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+complex_spence_xy_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp
+foreign import ccall "dilog.h gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
diff --git a/lib/Numeric/GSL/Special/Elementary.hs b/lib/Numeric/GSL/Special/Elementary.hs
new file mode 100644
index 0000000..0312ada
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Elementary.hs
@@ -0,0 +1,45 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Elementary
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_elementary.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Elementary(
+  multiply_e
+, multiply
+, multiply_err_e
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_multiply_e(double x,double y,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_multiply_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+multiply_e :: Double -> Double -> (Double,Double)
+multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y
+foreign import ccall "elementary.h gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_multiply(double x,double y);
+--
+--   <http://www.google.com/search?q=gsl_sf_multiply&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+multiply :: Double -> Double -> Double
+multiply = gsl_sf_multiply
+foreign import ccall "elementary.h gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_multiply_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
+multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy
+foreign import ccall "elementary.h gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
diff --git a/lib/Numeric/GSL/Special/Ellint.hs b/lib/Numeric/GSL/Special/Ellint.hs
new file mode 100644
index 0000000..798531a
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Ellint.hs
@@ -0,0 +1,181 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Ellint
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_ellint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Ellint(
+  ellint_Kcomp_e
+, ellint_Kcomp
+, ellint_Ecomp_e
+, ellint_Ecomp
+, ellint_F_e
+, ellint_F
+, ellint_E_e
+, ellint_E
+, ellint_P_e
+, ellint_P
+, ellint_D_e
+, ellint_D
+, ellint_RC_e
+, ellint_RC
+, ellint_RD_e
+, ellint_RD
+, ellint_RF_e
+, ellint_RF
+, ellint_RJ_e
+, ellint_RJ
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_ellint_Kcomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_Kcomp_e :: Double -> Precision -> (Double,Double)
+ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_Kcomp(double k,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_Kcomp :: Double -> Precision -> Double
+ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_Ecomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_Ecomp_e :: Double -> Precision -> (Double,Double)
+ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_Ecomp(double k,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_Ecomp :: Double -> Precision -> Double
+ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_F_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_F_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_F_e :: Double -> Double -> Precision -> (Double,Double)
+ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_F(double phi,double k,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_F&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_F :: Double -> Double -> Precision -> Double
+ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_E_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_E_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_E_e :: Double -> Double -> Precision -> (Double,Double)
+ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_E(double phi,double k,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_E&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_E :: Double -> Double -> Precision -> Double
+ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_P_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double)
+ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_P(double phi,double k,double n,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_P :: Double -> Double -> Double -> Precision -> Double
+ellint_P phi k n mode = gsl_sf_ellint_P phi k n  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_D_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_D_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double)
+ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_D(double phi,double k,double n,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_D&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_D :: Double -> Double -> Double -> Precision -> Double
+ellint_D phi k n mode = gsl_sf_ellint_D phi k n  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_RC_e(double x,double y,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RC_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RC_e :: Double -> Double -> Precision -> (Double,Double)
+ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_RC(double x,double y,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RC&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RC :: Double -> Double -> Precision -> Double
+ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_RD_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RD_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double)
+ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_RD(double x,double y,double z,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RD&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RD :: Double -> Double -> Double -> Precision -> Double
+ellint_RD x y z mode = gsl_sf_ellint_RD x y z  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_RF_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RF_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double)
+ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_RF(double x,double y,double z,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RF&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RF :: Double -> Double -> Double -> Precision -> Double
+ellint_RF x y z mode = gsl_sf_ellint_RF x y z  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+-- | wrapper for int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,gsl_mode_t mode,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RJ_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double)
+ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_ellint_RJ(double x,double y,double z,double p,gsl_mode_t mode);
+--
+--   <http://www.google.com/search?q=gsl_sf_ellint_RJ&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double
+ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p  (precCode mode)
+foreign import ccall "ellint.h gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
diff --git a/lib/Numeric/GSL/Special/Erf.hs b/lib/Numeric/GSL/Special/Erf.hs
new file mode 100644
index 0000000..ec73980
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Erf.hs
@@ -0,0 +1,117 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Erf
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_erf.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Erf(
+  erfc_e
+, erfc
+, log_erfc_e
+, log_erfc
+, erf_e
+, erf
+, erf_Z_e
+, erf_Q_e
+, erf_Z
+, erf_Q
+, hazard_e
+, hazard
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_erfc_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erfc_e :: Double -> (Double,Double)
+erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x
+foreign import ccall "erf.h gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_erfc(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erfc :: Double -> Double
+erfc = gsl_sf_erfc
+foreign import ccall "erf.h gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
+
+-- | wrapper for int gsl_sf_log_erfc_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_log_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+log_erfc_e :: Double -> (Double,Double)
+log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x
+foreign import ccall "erf.h gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_log_erfc(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_log_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+log_erfc :: Double -> Double
+log_erfc = gsl_sf_log_erfc
+foreign import ccall "erf.h gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
+
+-- | wrapper for int gsl_sf_erf_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf_e :: Double -> (Double,Double)
+erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x
+foreign import ccall "erf.h gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_erf(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf :: Double -> Double
+erf = gsl_sf_erf
+foreign import ccall "erf.h gsl_sf_erf" gsl_sf_erf :: Double -> Double
+
+-- | wrapper for int gsl_sf_erf_Z_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf_Z_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf_Z_e :: Double -> (Double,Double)
+erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x
+foreign import ccall "erf.h gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_erf_Q_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf_Q_e :: Double -> (Double,Double)
+erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x
+foreign import ccall "erf.h gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_erf_Z(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf_Z&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf_Z :: Double -> Double
+erf_Z = gsl_sf_erf_Z
+foreign import ccall "erf.h gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
+
+-- | wrapper for double gsl_sf_erf_Q(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_erf_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+erf_Q :: Double -> Double
+erf_Q = gsl_sf_erf_Q
+foreign import ccall "erf.h gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
+
+-- | wrapper for int gsl_sf_hazard_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hazard_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hazard_e :: Double -> (Double,Double)
+hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x
+foreign import ccall "erf.h gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hazard(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hazard&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hazard :: Double -> Double
+hazard = gsl_sf_hazard
+foreign import ccall "erf.h gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Exp.hs b/lib/Numeric/GSL/Special/Exp.hs
new file mode 100644
index 0000000..2787df4
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Exp.hs
@@ -0,0 +1,129 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Exp
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Exponential-Functions.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Exp(
+  exp_e
+, Numeric.GSL.Special.Exp.exp
+, exp_e10_e
+, exp_mult_e
+, exp_mult
+, exp_mult_e10_e
+, expm1_e
+, expm1
+, exprel_e
+, exprel
+, exprel_2_e
+, exprel_2
+, exprel_n_e
+, exprel_n
+, exp_err_e
+, exp_err_e10_e
+, exp_mult_err_e
+, exp_mult_err_e10_e
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_exp_e(double x,gsl_sf_result* result);
+exp_e :: Double -> (Double,Double)
+exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x
+foreign import ccall "exp.h gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_exp(double x);
+exp :: Double -> Double
+exp = gsl_sf_exp
+foreign import ccall "exp.h gsl_sf_exp" gsl_sf_exp :: Double -> Double
+
+-- | wrapper for int gsl_sf_exp_e10_e(double x,gsl_sf_result_e10* result);
+exp_e10_e :: Double -> (Double,Int,Double)
+exp_e10_e x = createSFR_E10 "exp_e10_e" $ gsl_sf_exp_e10_e x
+foreign import ccall "exp.h gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO(Int)
+
+-- | wrapper for int gsl_sf_exp_mult_e(double x,double y,gsl_sf_result* result);
+exp_mult_e :: Double -> Double -> (Double,Double)
+exp_mult_e x y = createSFR "exp_mult_e" $ gsl_sf_exp_mult_e x y
+foreign import ccall "exp.h gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_exp_mult(double x,double y);
+exp_mult :: Double -> Double -> Double
+exp_mult = gsl_sf_exp_mult
+foreign import ccall "exp.h gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_exp_mult_e10_e(double x,double y,gsl_sf_result_e10* result);
+exp_mult_e10_e :: Double -> Double -> (Double,Int,Double)
+exp_mult_e10_e x y = createSFR_E10 "exp_mult_e10_e" $ gsl_sf_exp_mult_e10_e x y
+foreign import ccall "exp.h gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO(Int)
+
+-- | wrapper for int gsl_sf_expm1_e(double x,gsl_sf_result* result);
+expm1_e :: Double -> (Double,Double)
+expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x
+foreign import ccall "exp.h gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expm1(double x);
+expm1 :: Double -> Double
+expm1 = gsl_sf_expm1
+foreign import ccall "exp.h gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_exprel_e(double x,gsl_sf_result* result);
+exprel_e :: Double -> (Double,Double)
+exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x
+foreign import ccall "exp.h gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_exprel(double x);
+exprel :: Double -> Double
+exprel = gsl_sf_exprel
+foreign import ccall "exp.h gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
+
+-- | wrapper for int gsl_sf_exprel_2_e(double x,gsl_sf_result* result);
+exprel_2_e :: Double -> (Double,Double)
+exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x
+foreign import ccall "exp.h gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_exprel_2(double x);
+exprel_2 :: Double -> Double
+exprel_2 = gsl_sf_exprel_2
+foreign import ccall "exp.h gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_exprel_n_e(int n,double x,gsl_sf_result* result);
+exprel_n_e :: Int -> Double -> (Double,Double)
+exprel_n_e n x = createSFR "exprel_n_e" $ gsl_sf_exprel_n_e n x
+foreign import ccall "exp.h gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_exprel_n(int n,double x);
+exprel_n :: Int -> Double -> Double
+exprel_n = gsl_sf_exprel_n
+foreign import ccall "exp.h gsl_sf_exprel_n" gsl_sf_exprel_n :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_exp_err_e(double x,double dx,gsl_sf_result* result);
+exp_err_e :: Double -> Double -> (Double,Double)
+exp_err_e x dx = createSFR "exp_err_e" $ gsl_sf_exp_err_e x dx
+foreign import ccall "exp.h gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_exp_err_e10_e(double x,double dx,gsl_sf_result_e10* result);
+exp_err_e10_e :: Double -> Double -> (Double,Int,Double)
+exp_err_e10_e x dx = createSFR_E10 "exp_err_e10_e" $ gsl_sf_exp_err_e10_e x dx
+foreign import ccall "exp.h gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO(Int)
+
+-- | wrapper for int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);
+exp_mult_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
+exp_mult_err_e x dx y dy = createSFR "exp_mult_err_e" $ gsl_sf_exp_mult_err_e x dx y dy
+foreign import ccall "exp.h gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,gsl_sf_result_e10* result);
+exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> (Double,Int,Double)
+exp_mult_err_e10_e x dx y dy = createSFR_E10 "exp_mult_err_e10_e" $ gsl_sf_exp_mult_err_e10_e x dx y dy
+foreign import ccall "exp.h gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO(Int)
diff --git a/lib/Numeric/GSL/Special/Expint.hs b/lib/Numeric/GSL/Special/Expint.hs
new file mode 100644
index 0000000..9882d09
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Expint.hs
@@ -0,0 +1,213 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Expint
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_expint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Expint(
+  expint_E1_e
+, expint_E1
+, expint_E2_e
+, expint_E2
+, expint_E1_scaled_e
+, expint_E1_scaled
+, expint_E2_scaled_e
+, expint_E2_scaled
+, expint_Ei_e
+, expint_Ei
+, expint_Ei_scaled_e
+, expint_Ei_scaled
+, shi_e
+, shi
+, chi_e
+, chi
+, expint_3_e
+, expint_3
+, si_e
+, si
+, ci_e
+, ci
+, atanint_e
+, atanint
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_expint_E1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E1_e :: Double -> (Double,Double)
+expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x
+foreign import ccall "expint.h gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_E1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E1 :: Double -> Double
+expint_E1 = gsl_sf_expint_E1
+foreign import ccall "expint.h gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_E2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E2_e :: Double -> (Double,Double)
+expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x
+foreign import ccall "expint.h gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_E2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E2 :: Double -> Double
+expint_E2 = gsl_sf_expint_E2
+foreign import ccall "expint.h gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_E1_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E1_scaled_e :: Double -> (Double,Double)
+expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x
+foreign import ccall "expint.h gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_E1_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E1_scaled :: Double -> Double
+expint_E1_scaled = gsl_sf_expint_E1_scaled
+foreign import ccall "expint.h gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_E2_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E2_scaled_e :: Double -> (Double,Double)
+expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x
+foreign import ccall "expint.h gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_E2_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_E2_scaled :: Double -> Double
+expint_E2_scaled = gsl_sf_expint_E2_scaled
+foreign import ccall "expint.h gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_Ei_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_Ei_e :: Double -> (Double,Double)
+expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x
+foreign import ccall "expint.h gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_Ei(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_Ei&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_Ei :: Double -> Double
+expint_Ei = gsl_sf_expint_Ei
+foreign import ccall "expint.h gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_Ei_scaled_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_Ei_scaled_e :: Double -> (Double,Double)
+expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x
+foreign import ccall "expint.h gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_Ei_scaled(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_Ei_scaled :: Double -> Double
+expint_Ei_scaled = gsl_sf_expint_Ei_scaled
+foreign import ccall "expint.h gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
+
+-- | wrapper for int gsl_sf_Shi_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_Shi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+shi_e :: Double -> (Double,Double)
+shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x
+foreign import ccall "expint.h gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_Shi(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_Shi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+shi :: Double -> Double
+shi = gsl_sf_Shi
+foreign import ccall "expint.h gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
+
+-- | wrapper for int gsl_sf_Chi_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_Chi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+chi_e :: Double -> (Double,Double)
+chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x
+foreign import ccall "expint.h gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_Chi(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_Chi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+chi :: Double -> Double
+chi = gsl_sf_Chi
+foreign import ccall "expint.h gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
+
+-- | wrapper for int gsl_sf_expint_3_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_3_e :: Double -> (Double,Double)
+expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x
+foreign import ccall "expint.h gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_expint_3(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_3 :: Double -> Double
+expint_3 = gsl_sf_expint_3
+foreign import ccall "expint.h gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
+
+-- | wrapper for int gsl_sf_Si_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_Si_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+si_e :: Double -> (Double,Double)
+si_e x = createSFR "si_e" $ gsl_sf_Si_e x
+foreign import ccall "expint.h gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_Si(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_Si&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+si :: Double -> Double
+si = gsl_sf_Si
+foreign import ccall "expint.h gsl_sf_Si" gsl_sf_Si :: Double -> Double
+
+-- | wrapper for int gsl_sf_Ci_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_Ci_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ci_e :: Double -> (Double,Double)
+ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x
+foreign import ccall "expint.h gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_Ci(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_Ci&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+ci :: Double -> Double
+ci = gsl_sf_Ci
+foreign import ccall "expint.h gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
+
+-- | wrapper for int gsl_sf_atanint_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_atanint_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+atanint_e :: Double -> (Double,Double)
+atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x
+foreign import ccall "expint.h gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_atanint(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_atanint&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+atanint :: Double -> Double
+atanint = gsl_sf_atanint
+foreign import ccall "expint.h gsl_sf_atanint" gsl_sf_atanint :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Fermi_dirac.hs b/lib/Numeric/GSL/Special/Fermi_dirac.hs
new file mode 100644
index 0000000..a189dd4
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Fermi_dirac.hs
@@ -0,0 +1,165 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Fermi_dirac
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_fermi_dirac.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Fermi_dirac(
+  fermi_dirac_m1_e
+, fermi_dirac_m1
+, fermi_dirac_0_e
+, fermi_dirac_0
+, fermi_dirac_1_e
+, fermi_dirac_1
+, fermi_dirac_2_e
+, fermi_dirac_2
+, fermi_dirac_int_e
+, fermi_dirac_int
+, fermi_dirac_mhalf_e
+, fermi_dirac_mhalf
+, fermi_dirac_half_e
+, fermi_dirac_half
+, fermi_dirac_3half_e
+, fermi_dirac_3half
+, fermi_dirac_inc_0_e
+, fermi_dirac_inc_0
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_fermi_dirac_m1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_m1_e :: Double -> (Double,Double)
+fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_m1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_m1 :: Double -> Double
+fermi_dirac_m1 = gsl_sf_fermi_dirac_m1
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_0_e :: Double -> (Double,Double)
+fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_0 :: Double -> Double
+fermi_dirac_0 = gsl_sf_fermi_dirac_0
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_1_e :: Double -> (Double,Double)
+fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_1 :: Double -> Double
+fermi_dirac_1 = gsl_sf_fermi_dirac_1
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_2_e :: Double -> (Double,Double)
+fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_2 :: Double -> Double
+fermi_dirac_2 = gsl_sf_fermi_dirac_2
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_int_e(int j,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_int_e :: Int -> Double -> (Double,Double)
+fermi_dirac_int_e j x = createSFR "fermi_dirac_int_e" $ gsl_sf_fermi_dirac_int_e j x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_int(int j,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_int :: Int -> Double -> Double
+fermi_dirac_int = gsl_sf_fermi_dirac_int
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_mhalf_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_mhalf_e :: Double -> (Double,Double)
+fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_mhalf(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_mhalf :: Double -> Double
+fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_half_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_half_e :: Double -> (Double,Double)
+fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_half(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_half :: Double -> Double
+fermi_dirac_half = gsl_sf_fermi_dirac_half
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_3half_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_3half_e :: Double -> (Double,Double)
+fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_3half(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_3half :: Double -> Double
+fermi_dirac_3half = gsl_sf_fermi_dirac_3half
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
+
+-- | wrapper for int gsl_sf_fermi_dirac_inc_0_e(double x,double b,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double)
+fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fermi_dirac_inc_0(double x,double b);
+--
+--   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fermi_dirac_inc_0 :: Double -> Double -> Double
+fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0
+foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Gamma.hs b/lib/Numeric/GSL/Special/Gamma.hs
new file mode 100644
index 0000000..aa03892
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Gamma.hs
@@ -0,0 +1,362 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Gamma
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_gamma.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Gamma(
+  lngamma_e
+, lngamma
+, gamma_e
+, gamma
+, gammastar_e
+, gammastar
+, gammainv_e
+, gammainv
+, taylorcoeff_e
+, taylorcoeff
+, fact_e
+, fact
+, doublefact_e
+, doublefact
+, lnfact_e
+, lnfact
+, lndoublefact_e
+, lndoublefact
+, lnchoose_e
+, lnchoose
+, choose_e
+, choose
+, lnpoch_e
+, lnpoch
+, poch_e
+, poch
+, pochrel_e
+, pochrel
+, gamma_inc_Q_e
+, gamma_inc_Q
+, gamma_inc_P_e
+, gamma_inc_P
+, gamma_inc_e
+, gamma_inc
+, lnbeta_e
+, lnbeta
+, beta_e
+, beta
+, beta_inc_e
+, beta_inc
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_lngamma_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lngamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lngamma_e :: Double -> (Double,Double)
+lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x
+foreign import ccall "gamma.h gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lngamma(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_lngamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lngamma :: Double -> Double
+lngamma = gsl_sf_lngamma
+foreign import ccall "gamma.h gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
+
+-- | wrapper for int gsl_sf_lngamma_sgn_e(double x,gsl_sf_result* result_lg,double* sgn);
+--
+--   <http://www.google.com/search?q=gsl_sf_lngamma_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int
+lngamma_sgn_e = gsl_sf_lngamma_sgn_e
+foreign import ccall "gamma.h gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_gamma_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_e :: Double -> (Double,Double)
+gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x
+foreign import ccall "gamma.h gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gamma(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma :: Double -> Double
+gamma = gsl_sf_gamma
+foreign import ccall "gamma.h gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
+
+-- | wrapper for int gsl_sf_gammastar_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gammastar_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gammastar_e :: Double -> (Double,Double)
+gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x
+foreign import ccall "gamma.h gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gammastar(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gammastar&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gammastar :: Double -> Double
+gammastar = gsl_sf_gammastar
+foreign import ccall "gamma.h gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
+
+-- | wrapper for int gsl_sf_gammainv_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gammainv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gammainv_e :: Double -> (Double,Double)
+gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x
+foreign import ccall "gamma.h gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gammainv(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gammainv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gammainv :: Double -> Double
+gammainv = gsl_sf_gammainv
+foreign import ccall "gamma.h gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
+
+-- | wrapper for int gsl_sf_lngamma_complex_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* arg);
+--
+--   <http://www.google.com/search?q=gsl_sf_lngamma_complex_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lngamma_complex_e :: Double -> Double -> Ptr Double -> (Double,Double)
+lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr
+foreign import ccall "gamma.h gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_taylorcoeff_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_taylorcoeff_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+taylorcoeff_e :: Int -> Double -> (Double,Double)
+taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x
+foreign import ccall "gamma.h gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_taylorcoeff(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_taylorcoeff&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+taylorcoeff :: Int -> Double -> Double
+taylorcoeff = gsl_sf_taylorcoeff
+foreign import ccall "gamma.h gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_fact_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_fact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fact_e :: Int -> (Double,Double)
+fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n
+foreign import ccall "gamma.h gsl_sf_fact_e" gsl_sf_fact_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_fact(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_fact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+fact :: Int -> Double
+fact = gsl_sf_fact
+foreign import ccall "gamma.h gsl_sf_fact" gsl_sf_fact :: Int -> Double
+
+-- | wrapper for int gsl_sf_doublefact_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_doublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+doublefact_e :: Int -> (Double,Double)
+doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n
+foreign import ccall "gamma.h gsl_sf_doublefact_e" gsl_sf_doublefact_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_doublefact(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_doublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+doublefact :: Int -> Double
+doublefact = gsl_sf_doublefact
+foreign import ccall "gamma.h gsl_sf_doublefact" gsl_sf_doublefact :: Int -> Double
+
+-- | wrapper for int gsl_sf_lnfact_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnfact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnfact_e :: Int -> (Double,Double)
+lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n
+foreign import ccall "gamma.h gsl_sf_lnfact_e" gsl_sf_lnfact_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lnfact(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnfact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnfact :: Int -> Double
+lnfact = gsl_sf_lnfact
+foreign import ccall "gamma.h gsl_sf_lnfact" gsl_sf_lnfact :: Int -> Double
+
+-- | wrapper for int gsl_sf_lndoublefact_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lndoublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lndoublefact_e :: Int -> (Double,Double)
+lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n
+foreign import ccall "gamma.h gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lndoublefact(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_lndoublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lndoublefact :: Int -> Double
+lndoublefact = gsl_sf_lndoublefact
+foreign import ccall "gamma.h gsl_sf_lndoublefact" gsl_sf_lndoublefact :: Int -> Double
+
+-- | wrapper for int gsl_sf_lnchoose_e(int n,int m,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnchoose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnchoose_e :: Int -> Int -> (Double,Double)
+lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m
+foreign import ccall "gamma.h gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lnchoose(int n,int m);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnchoose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnchoose :: Int -> Int -> Double
+lnchoose = gsl_sf_lnchoose
+foreign import ccall "gamma.h gsl_sf_lnchoose" gsl_sf_lnchoose :: Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_choose_e(int n,int m,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_choose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+choose_e :: Int -> Int -> (Double,Double)
+choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m
+foreign import ccall "gamma.h gsl_sf_choose_e" gsl_sf_choose_e :: Int -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_choose(int n,int m);
+--
+--   <http://www.google.com/search?q=gsl_sf_choose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+choose :: Int -> Int -> Double
+choose = gsl_sf_choose
+foreign import ccall "gamma.h gsl_sf_choose" gsl_sf_choose :: Int -> Int -> Double
+
+-- | wrapper for int gsl_sf_lnpoch_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnpoch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnpoch_e :: Double -> Double -> (Double,Double)
+lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x
+foreign import ccall "gamma.h gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lnpoch(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnpoch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnpoch :: Double -> Double -> Double
+lnpoch = gsl_sf_lnpoch
+foreign import ccall "gamma.h gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_lnpoch_sgn_e(double a,double x,gsl_sf_result* result,double* sgn);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnpoch_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int
+lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e
+foreign import ccall "gamma.h gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_poch_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_poch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+poch_e :: Double -> Double -> (Double,Double)
+poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x
+foreign import ccall "gamma.h gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_poch(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_poch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+poch :: Double -> Double -> Double
+poch = gsl_sf_poch
+foreign import ccall "gamma.h gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_pochrel_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_pochrel_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+pochrel_e :: Double -> Double -> (Double,Double)
+pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x
+foreign import ccall "gamma.h gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_pochrel(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_pochrel&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+pochrel :: Double -> Double -> Double
+pochrel = gsl_sf_pochrel
+foreign import ccall "gamma.h gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_gamma_inc_Q_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc_Q_e :: Double -> Double -> (Double,Double)
+gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x
+foreign import ccall "gamma.h gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gamma_inc_Q(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc_Q :: Double -> Double -> Double
+gamma_inc_Q = gsl_sf_gamma_inc_Q
+foreign import ccall "gamma.h gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_gamma_inc_P_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc_P_e :: Double -> Double -> (Double,Double)
+gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x
+foreign import ccall "gamma.h gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gamma_inc_P(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc_P :: Double -> Double -> Double
+gamma_inc_P = gsl_sf_gamma_inc_P
+foreign import ccall "gamma.h gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_gamma_inc_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc_e :: Double -> Double -> (Double,Double)
+gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x
+foreign import ccall "gamma.h gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gamma_inc(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gamma_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gamma_inc :: Double -> Double -> Double
+gamma_inc = gsl_sf_gamma_inc
+foreign import ccall "gamma.h gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_lnbeta_e(double a,double b,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnbeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnbeta_e :: Double -> Double -> (Double,Double)
+lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b
+foreign import ccall "gamma.h gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lnbeta(double a,double b);
+--
+--   <http://www.google.com/search?q=gsl_sf_lnbeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lnbeta :: Double -> Double -> Double
+lnbeta = gsl_sf_lnbeta
+foreign import ccall "gamma.h gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_beta_e(double a,double b,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_beta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+beta_e :: Double -> Double -> (Double,Double)
+beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b
+foreign import ccall "gamma.h gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_beta(double a,double b);
+--
+--   <http://www.google.com/search?q=gsl_sf_beta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+beta :: Double -> Double -> Double
+beta = gsl_sf_beta
+foreign import ccall "gamma.h gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_beta_inc_e(double a,double b,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_beta_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+beta_inc_e :: Double -> Double -> Double -> (Double,Double)
+beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x
+foreign import ccall "gamma.h gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_beta_inc(double a,double b,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_beta_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+beta_inc :: Double -> Double -> Double -> Double
+beta_inc = gsl_sf_beta_inc
+foreign import ccall "gamma.h gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Gegenbauer.hs b/lib/Numeric/GSL/Special/Gegenbauer.hs
new file mode 100644
index 0000000..40cc1e9
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Gegenbauer.hs
@@ -0,0 +1,92 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Gegenbauer
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_gegenbauer.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Gegenbauer(
+  gegenpoly_1_e
+, gegenpoly_2_e
+, gegenpoly_3_e
+, gegenpoly_1
+, gegenpoly_2
+, gegenpoly_3
+, gegenpoly_n_e
+, gegenpoly_n
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_gegenpoly_1_e(double lambda,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_1_e :: Double -> Double -> (Double,Double)
+gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_gegenpoly_2_e(double lambda,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_2_e :: Double -> Double -> (Double,Double)
+gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_gegenpoly_3_e(double lambda,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_3_e :: Double -> Double -> (Double,Double)
+gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gegenpoly_1(double lambda,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_1 :: Double -> Double -> Double
+gegenpoly_1 = gsl_sf_gegenpoly_1
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
+
+-- | wrapper for double gsl_sf_gegenpoly_2(double lambda,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_2 :: Double -> Double -> Double
+gegenpoly_2 = gsl_sf_gegenpoly_2
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
+
+-- | wrapper for double gsl_sf_gegenpoly_3(double lambda,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_3 :: Double -> Double -> Double
+gegenpoly_3 = gsl_sf_gegenpoly_3
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_n_e :: Int -> Double -> Double -> (Double,Double)
+gegenpoly_n_e n lambda x = createSFR "gegenpoly_n_e" $ gsl_sf_gegenpoly_n_e n lambda x
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_gegenpoly_n(int n,double lambda,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_n :: Int -> Double -> Double -> Double
+gegenpoly_n = gsl_sf_gegenpoly_n
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: Int -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);
+--
+--   <http://www.google.com/search?q=gsl_sf_gegenpoly_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int
+gegenpoly_array = gsl_sf_gegenpoly_array
+foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int
diff --git a/lib/Numeric/GSL/Special/Hyperg.hs b/lib/Numeric/GSL/Special/Hyperg.hs
new file mode 100644
index 0000000..28bf984
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Hyperg.hs
@@ -0,0 +1,197 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Hyperg
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_hyperg.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Hyperg(
+  hyperg_0F1_e
+, hyperg_0F1
+, hyperg_1F1_int_e
+, hyperg_1F1_int
+, hyperg_1F1_e
+, hyperg_1F1
+, hyperg_U_int_e
+, hyperg_U_int
+, hyperg_U_int_e10_e
+, hyperg_U_e
+, hyperg_U
+, hyperg_U_e10_e
+, hyperg_2F1_e
+, hyperg_2F1
+, hyperg_2F1_conj_e
+, hyperg_2F1_conj
+, hyperg_2F1_renorm_e
+, hyperg_2F1_renorm
+, hyperg_2F1_conj_renorm_e
+, hyperg_2F1_conj_renorm
+, hyperg_2F0_e
+, hyperg_2F0
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_hyperg_0F1_e(double c,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_0F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_0F1_e :: Double -> Double -> (Double,Double)
+hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x
+foreign import ccall "hyperg.h gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_0F1(double c,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_0F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_0F1 :: Double -> Double -> Double
+hyperg_0F1 = gsl_sf_hyperg_0F1
+foreign import ccall "hyperg.h gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_1F1_int_e :: Int -> Int -> Double -> (Double,Double)
+hyperg_1F1_int_e m n x = createSFR "hyperg_1F1_int_e" $ gsl_sf_hyperg_1F1_int_e m n x
+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_1F1_int(int m,int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_1F1_int :: Int -> Int -> Double -> Double
+hyperg_1F1_int = gsl_sf_hyperg_1F1_int
+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: Int -> Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_1F1_e(double a,double b,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double)
+hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x
+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_1F1(double a,double b,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_1F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_1F1 :: Double -> Double -> Double -> Double
+hyperg_1F1 = gsl_sf_hyperg_1F1
+foreign import ccall "hyperg.h gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_U_int_e(int m,int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U_int_e :: Int -> Int -> Double -> (Double,Double)
+hyperg_U_int_e m n x = createSFR "hyperg_U_int_e" $ gsl_sf_hyperg_U_int_e m n x
+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_U_int(int m,int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U_int :: Int -> Int -> Double -> Double
+hyperg_U_int = gsl_sf_hyperg_U_int
+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: Int -> Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,gsl_sf_result_e10* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U_int_e10_e :: Int -> Int -> Double -> (Double,Int,Double)
+hyperg_U_int_e10_e m n x = createSFR_E10 "hyperg_U_int_e10_e" $ gsl_sf_hyperg_U_int_e10_e m n x
+foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: Int -> Int -> Double -> Ptr () -> IO(Int)
+
+-- | wrapper for int gsl_sf_hyperg_U_e(double a,double b,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U_e :: Double -> Double -> Double -> (Double,Double)
+hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x
+foreign import ccall "hyperg.h gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_U(double a,double b,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U :: Double -> Double -> Double -> Double
+hyperg_U = gsl_sf_hyperg_U
+foreign import ccall "hyperg.h gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_U_e10_e(double a,double b,double x,gsl_sf_result_e10* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_U_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double)
+hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x
+foreign import ccall "hyperg.h gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO(Int)
+
+-- | wrapper for int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double)
+hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_2F1(double a,double b,double c,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1 = gsl_sf_hyperg_2F1
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double)
+hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
+hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
+hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_hyperg_2F0_e(double a,double b,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double)
+hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hyperg_2F0(double a,double b,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_hyperg_2F0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hyperg_2F0 :: Double -> Double -> Double -> Double
+hyperg_2F0 = gsl_sf_hyperg_2F0
+foreign import ccall "hyperg.h gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Internal.hs b/lib/Numeric/GSL/Special/Internal.hs
new file mode 100644
index 0000000..a08809b
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Internal.hs
@@ -0,0 +1,68 @@
+{-# OPTIONS #-}
+-----------------------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Internal
+Copyright   :  (c) Alberto Ruiz 2007
+License     :  GPL-style
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Support for Special functions.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>
+-}
+-----------------------------------------------------------------------------
+
+module Numeric.GSL.Special.Internal (
+    createSFR,
+    createSFR_E10,
+    Precision(..),
+    Gsl_mode_t,
+    Size_t,
+    precCode
+)
+where
+
+import Foreign
+import Data.Packed.Internal(check,(//))
+
+
+data Precision = PrecDouble | PrecSingle | PrecApprox
+
+precCode :: Precision -> Int
+precCode PrecDouble = 0
+precCode PrecSingle = 1
+precCode PrecApprox = 2
+
+type Gsl_mode_t = Int
+
+type Size_t = Int
+
+----------------------------------------------------------------
+-- | access to a sf_result
+createSFR :: Storable a => String -> (Ptr a -> IO Int) -> (a, a)
+createSFR s f = unsafePerformIO $ do
+    p <- mallocArray 2
+    f p // check s []
+    [val,err] <- peekArray 2 p
+    free p
+    return (val,err)
+
+
+---------------------------------------------------------------------
+-- the sf_result_e10 contains two doubles and the exponent
+
+-- | acces to sf_result_e10
+createSFR_E10 :: (Storable t2, Storable t3, Storable t1) => String -> (Ptr a -> IO Int) -> (t1, t2, t3)
+createSFR_E10 s f = unsafePerformIO $ do
+    let sd = sizeOf (0::Double)
+    let si = sizeOf (0::Int)
+    p <- mallocBytes (2*sd + si)
+    f p // check s []
+    val <- peekByteOff p 0
+    err <- peekByteOff p sd
+    expo <- peekByteOff p (2*sd) 
+    free p
+    return (val,expo,err)
diff --git a/lib/Numeric/GSL/Special/Laguerre.hs b/lib/Numeric/GSL/Special/Laguerre.hs
new file mode 100644
index 0000000..320e451
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Laguerre.hs
@@ -0,0 +1,85 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Laguerre
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_laguerre.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Laguerre(
+  laguerre_1_e
+, laguerre_2_e
+, laguerre_3_e
+, laguerre_1
+, laguerre_2
+, laguerre_3
+, laguerre_n_e
+, laguerre_n
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_laguerre_1_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_1_e :: Double -> Double -> (Double,Double)
+laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x
+foreign import ccall "laguerre.h gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_laguerre_2_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_2_e :: Double -> Double -> (Double,Double)
+laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x
+foreign import ccall "laguerre.h gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_laguerre_3_e(double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_3_e :: Double -> Double -> (Double,Double)
+laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x
+foreign import ccall "laguerre.h gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_laguerre_1(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_1 :: Double -> Double -> Double
+laguerre_1 = gsl_sf_laguerre_1
+foreign import ccall "laguerre.h gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
+
+-- | wrapper for double gsl_sf_laguerre_2(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_2 :: Double -> Double -> Double
+laguerre_2 = gsl_sf_laguerre_2
+foreign import ccall "laguerre.h gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
+
+-- | wrapper for double gsl_sf_laguerre_3(double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_3 :: Double -> Double -> Double
+laguerre_3 = gsl_sf_laguerre_3
+foreign import ccall "laguerre.h gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_laguerre_n_e(int n,double a,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_n_e :: Int -> Double -> Double -> (Double,Double)
+laguerre_n_e n a x = createSFR "laguerre_n_e" $ gsl_sf_laguerre_n_e n a x
+foreign import ccall "laguerre.h gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_laguerre_n(int n,double a,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_laguerre_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+laguerre_n :: Int -> Double -> Double -> Double
+laguerre_n = gsl_sf_laguerre_n
+foreign import ccall "laguerre.h gsl_sf_laguerre_n" gsl_sf_laguerre_n :: Int -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Lambert.hs b/lib/Numeric/GSL/Special/Lambert.hs
new file mode 100644
index 0000000..ad5579f
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Lambert.hs
@@ -0,0 +1,53 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Lambert
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_lambert.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Lambert(
+  lambert_W0_e
+, lambert_W0
+, lambert_Wm1_e
+, lambert_Wm1
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_lambert_W0_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lambert_W0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lambert_W0_e :: Double -> (Double,Double)
+lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x
+foreign import ccall "lambert.h gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lambert_W0(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_lambert_W0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lambert_W0 :: Double -> Double
+lambert_W0 = gsl_sf_lambert_W0
+foreign import ccall "lambert.h gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_lambert_Wm1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_lambert_Wm1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lambert_Wm1_e :: Double -> (Double,Double)
+lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x
+foreign import ccall "lambert.h gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lambert_Wm1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_lambert_Wm1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+lambert_Wm1 :: Double -> Double
+lambert_Wm1 = gsl_sf_lambert_Wm1
+foreign import ccall "lambert.h gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Legendre.hs b/lib/Numeric/GSL/Special/Legendre.hs
new file mode 100644
index 0000000..0ea7557
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Legendre.hs
@@ -0,0 +1,278 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Legendre
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Legendre-Functions-and-Spherical-Harmonics.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Legendre(
+  legendre_Pl_e
+, legendre_Pl
+, legendre_P1_e
+, legendre_P2_e
+, legendre_P3_e
+, legendre_P1
+, legendre_P2
+, legendre_P3
+, legendre_Q0_e
+, legendre_Q0
+, legendre_Q1_e
+, legendre_Q1
+, legendre_Ql_e
+, legendre_Ql
+, legendre_Plm_e
+, legendre_Plm
+, legendre_sphPlm_e
+, legendre_sphPlm
+, legendre_array_size
+, conicalP_half_e
+, conicalP_half
+, conicalP_mhalf_e
+, conicalP_mhalf
+, conicalP_0_e
+, conicalP_0
+, conicalP_1_e
+, conicalP_1
+, conicalP_sph_reg_e
+, conicalP_sph_reg
+, conicalP_cyl_reg_e
+, conicalP_cyl_reg
+, legendre_H3d_0_e
+, legendre_H3d_0
+, legendre_H3d_1_e
+, legendre_H3d_1
+, legendre_H3d_e
+, legendre_H3d
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_legendre_Pl_e(int l,double x,gsl_sf_result* result);
+legendre_Pl_e :: Int -> Double -> (Double,Double)
+legendre_Pl_e l x = createSFR "legendre_Pl_e" $ gsl_sf_legendre_Pl_e l x
+foreign import ccall "legendre.h gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_Pl(int l,double x);
+legendre_Pl :: Int -> Double -> Double
+legendre_Pl = gsl_sf_legendre_Pl
+foreign import ccall "legendre.h gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);
+legendre_Pl_array :: Int -> Double -> Ptr Double -> Int
+legendre_Pl_array = gsl_sf_legendre_Pl_array
+foreign import ccall "legendre.h gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);
+legendre_Pl_deriv_array :: Int -> Double -> Ptr Double -> Ptr Double -> Int
+legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array
+foreign import ccall "legendre.h gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: Int -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_P1_e(double x,gsl_sf_result* result);
+legendre_P1_e :: Double -> (Double,Double)
+legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x
+foreign import ccall "legendre.h gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_legendre_P2_e(double x,gsl_sf_result* result);
+legendre_P2_e :: Double -> (Double,Double)
+legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x
+foreign import ccall "legendre.h gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_legendre_P3_e(double x,gsl_sf_result* result);
+legendre_P3_e :: Double -> (Double,Double)
+legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x
+foreign import ccall "legendre.h gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_P1(double x);
+legendre_P1 :: Double -> Double
+legendre_P1 = gsl_sf_legendre_P1
+foreign import ccall "legendre.h gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
+
+-- | wrapper for double gsl_sf_legendre_P2(double x);
+legendre_P2 :: Double -> Double
+legendre_P2 = gsl_sf_legendre_P2
+foreign import ccall "legendre.h gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
+
+-- | wrapper for double gsl_sf_legendre_P3(double x);
+legendre_P3 :: Double -> Double
+legendre_P3 = gsl_sf_legendre_P3
+foreign import ccall "legendre.h gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Q0_e(double x,gsl_sf_result* result);
+legendre_Q0_e :: Double -> (Double,Double)
+legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x
+foreign import ccall "legendre.h gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_Q0(double x);
+legendre_Q0 :: Double -> Double
+legendre_Q0 = gsl_sf_legendre_Q0
+foreign import ccall "legendre.h gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Q1_e(double x,gsl_sf_result* result);
+legendre_Q1_e :: Double -> (Double,Double)
+legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x
+foreign import ccall "legendre.h gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_Q1(double x);
+legendre_Q1 :: Double -> Double
+legendre_Q1 = gsl_sf_legendre_Q1
+foreign import ccall "legendre.h gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Ql_e(int l,double x,gsl_sf_result* result);
+legendre_Ql_e :: Int -> Double -> (Double,Double)
+legendre_Ql_e l x = createSFR "legendre_Ql_e" $ gsl_sf_legendre_Ql_e l x
+foreign import ccall "legendre.h gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_Ql(int l,double x);
+legendre_Ql :: Int -> Double -> Double
+legendre_Ql = gsl_sf_legendre_Ql
+foreign import ccall "legendre.h gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Plm_e(int l,int m,double x,gsl_sf_result* result);
+legendre_Plm_e :: Int -> Int -> Double -> (Double,Double)
+legendre_Plm_e l m x = createSFR "legendre_Plm_e" $ gsl_sf_legendre_Plm_e l m x
+foreign import ccall "legendre.h gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_Plm(int l,int m,double x);
+legendre_Plm :: Int -> Int -> Double -> Double
+legendre_Plm = gsl_sf_legendre_Plm
+foreign import ccall "legendre.h gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: Int -> Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);
+legendre_Plm_array :: Int -> Int -> Double -> Ptr Double -> Int
+legendre_Plm_array = gsl_sf_legendre_Plm_array
+foreign import ccall "legendre.h gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
+legendre_Plm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int
+legendre_Plm_deriv_array = gsl_sf_legendre_Plm_deriv_array
+foreign import ccall "legendre.h gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_sphPlm_e(int l,int m,double x,gsl_sf_result* result);
+legendre_sphPlm_e :: Int -> Int -> Double -> (Double,Double)
+legendre_sphPlm_e l m x = createSFR "legendre_sphPlm_e" $ gsl_sf_legendre_sphPlm_e l m x
+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: Int -> Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_sphPlm(int l,int m,double x);
+legendre_sphPlm :: Int -> Int -> Double -> Double
+legendre_sphPlm = gsl_sf_legendre_sphPlm
+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: Int -> Int -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);
+legendre_sphPlm_array :: Int -> Int -> Double -> Ptr Double -> Int
+legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array
+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: Int -> Int -> Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
+legendre_sphPlm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int
+legendre_sphPlm_deriv_array = gsl_sf_legendre_sphPlm_deriv_array
+foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: Int -> Int -> Double -> Ptr Double -> Ptr Double -> Int
+
+-- | wrapper for int gsl_sf_legendre_array_size(int lmax,int m);
+legendre_array_size :: Int -> Int -> Int
+legendre_array_size = gsl_sf_legendre_array_size
+foreign import ccall "legendre.h gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: Int -> Int -> Int
+
+-- | wrapper for int gsl_sf_conicalP_half_e(double lambda,double x,gsl_sf_result* result);
+conicalP_half_e :: Double -> Double -> (Double,Double)
+conicalP_half_e lambda x = createSFR "conicalP_half_e" $ gsl_sf_conicalP_half_e lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_half(double lambda,double x);
+conicalP_half :: Double -> Double -> Double
+conicalP_half = gsl_sf_conicalP_half
+foreign import ccall "legendre.h gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_conicalP_mhalf_e(double lambda,double x,gsl_sf_result* result);
+conicalP_mhalf_e :: Double -> Double -> (Double,Double)
+conicalP_mhalf_e lambda x = createSFR "conicalP_mhalf_e" $ gsl_sf_conicalP_mhalf_e lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_mhalf(double lambda,double x);
+conicalP_mhalf :: Double -> Double -> Double
+conicalP_mhalf = gsl_sf_conicalP_mhalf
+foreign import ccall "legendre.h gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_conicalP_0_e(double lambda,double x,gsl_sf_result* result);
+conicalP_0_e :: Double -> Double -> (Double,Double)
+conicalP_0_e lambda x = createSFR "conicalP_0_e" $ gsl_sf_conicalP_0_e lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_0(double lambda,double x);
+conicalP_0 :: Double -> Double -> Double
+conicalP_0 = gsl_sf_conicalP_0
+foreign import ccall "legendre.h gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_conicalP_1_e(double lambda,double x,gsl_sf_result* result);
+conicalP_1_e :: Double -> Double -> (Double,Double)
+conicalP_1_e lambda x = createSFR "conicalP_1_e" $ gsl_sf_conicalP_1_e lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_1(double lambda,double x);
+conicalP_1 :: Double -> Double -> Double
+conicalP_1 = gsl_sf_conicalP_1
+foreign import ccall "legendre.h gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,gsl_sf_result* result);
+conicalP_sph_reg_e :: Int -> Double -> Double -> (Double,Double)
+conicalP_sph_reg_e l lambda x = createSFR "conicalP_sph_reg_e" $ gsl_sf_conicalP_sph_reg_e l lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);
+conicalP_sph_reg :: Int -> Double -> Double -> Double
+conicalP_sph_reg = gsl_sf_conicalP_sph_reg
+foreign import ccall "legendre.h gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: Int -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,gsl_sf_result* result);
+conicalP_cyl_reg_e :: Int -> Double -> Double -> (Double,Double)
+conicalP_cyl_reg_e m lambda x = createSFR "conicalP_cyl_reg_e" $ gsl_sf_conicalP_cyl_reg_e m lambda x
+foreign import ccall "legendre.h gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);
+conicalP_cyl_reg :: Int -> Double -> Double -> Double
+conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg
+foreign import ccall "legendre.h gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: Int -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_H3d_0_e(double lambda,double eta,gsl_sf_result* result);
+legendre_H3d_0_e :: Double -> Double -> (Double,Double)
+legendre_H3d_0_e lambda eta = createSFR "legendre_H3d_0_e" $ gsl_sf_legendre_H3d_0_e lambda eta
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_H3d_0(double lambda,double eta);
+legendre_H3d_0 :: Double -> Double -> Double
+legendre_H3d_0 = gsl_sf_legendre_H3d_0
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_H3d_1_e(double lambda,double eta,gsl_sf_result* result);
+legendre_H3d_1_e :: Double -> Double -> (Double,Double)
+legendre_H3d_1_e lambda eta = createSFR "legendre_H3d_1_e" $ gsl_sf_legendre_H3d_1_e lambda eta
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_H3d_1(double lambda,double eta);
+legendre_H3d_1 :: Double -> Double -> Double
+legendre_H3d_1 = gsl_sf_legendre_H3d_1
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,gsl_sf_result* result);
+legendre_H3d_e :: Int -> Double -> Double -> (Double,Double)
+legendre_H3d_e l lambda eta = createSFR "legendre_H3d_e" $ gsl_sf_legendre_H3d_e l lambda eta
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: Int -> Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_legendre_H3d(int l,double lambda,double eta);
+legendre_H3d :: Int -> Double -> Double -> Double
+legendre_H3d = gsl_sf_legendre_H3d
+foreign import ccall "legendre.h gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: Int -> Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);
+legendre_H3d_array :: Int -> Double -> Double -> Ptr Double -> Int
+legendre_H3d_array = gsl_sf_legendre_H3d_array
+foreign import ccall "legendre.h gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: Int -> Double -> Double -> Ptr Double -> Int
diff --git a/lib/Numeric/GSL/Special/Log.hs b/lib/Numeric/GSL/Special/Log.hs
new file mode 100644
index 0000000..e9c345b
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Log.hs
@@ -0,0 +1,74 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Log
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Logarithm-and-Related-Functions.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Log(
+  log_e
+, Numeric.GSL.Special.Log.log
+, log_abs_e
+, log_abs
+, log_1plusx_e
+, log_1plusx
+, log_1plusx_mx_e
+, log_1plusx_mx
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_log_e(double x,gsl_sf_result* result);
+log_e :: Double -> (Double,Double)
+log_e x = createSFR "log_e" $ gsl_sf_log_e x
+foreign import ccall "log.h gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_log(double x);
+log :: Double -> Double
+log = gsl_sf_log
+foreign import ccall "log.h gsl_sf_log" gsl_sf_log :: Double -> Double
+
+-- | wrapper for int gsl_sf_log_abs_e(double x,gsl_sf_result* result);
+log_abs_e :: Double -> (Double,Double)
+log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x
+foreign import ccall "log.h gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_log_abs(double x);
+log_abs :: Double -> Double
+log_abs = gsl_sf_log_abs
+foreign import ccall "log.h gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
+
+-- | wrapper for int gsl_sf_complex_log_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* theta);
+complex_log_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_log_e zr zi lnr = createSFR "complex_log_e" $ gsl_sf_complex_log_e zr zi lnr
+foreign import ccall "log.h gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_log_1plusx_e(double x,gsl_sf_result* result);
+log_1plusx_e :: Double -> (Double,Double)
+log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x
+foreign import ccall "log.h gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_log_1plusx(double x);
+log_1plusx :: Double -> Double
+log_1plusx = gsl_sf_log_1plusx
+foreign import ccall "log.h gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
+
+-- | wrapper for int gsl_sf_log_1plusx_mx_e(double x,gsl_sf_result* result);
+log_1plusx_mx_e :: Double -> (Double,Double)
+log_1plusx_mx_e x = createSFR "log_1plusx_mx_e" $ gsl_sf_log_1plusx_mx_e x
+foreign import ccall "log.h gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_log_1plusx_mx(double x);
+log_1plusx_mx :: Double -> Double
+log_1plusx_mx = gsl_sf_log_1plusx_mx
+foreign import ccall "log.h gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Pow_int.hs b/lib/Numeric/GSL/Special/Pow_int.hs
new file mode 100644
index 0000000..384dfc4
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Pow_int.hs
@@ -0,0 +1,37 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Pow_int
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_pow_int.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Pow_int(
+  pow_int_e
+, pow_int
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_pow_int_e(double x,int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_pow_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+pow_int_e :: Double -> Int -> (Double,Double)
+pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n
+foreign import ccall "pow_int.h gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_pow_int(double x,int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_pow_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+pow_int :: Double -> Int -> Double
+pow_int = gsl_sf_pow_int
+foreign import ccall "pow_int.h gsl_sf_pow_int" gsl_sf_pow_int :: Double -> Int -> Double
diff --git a/lib/Numeric/GSL/Special/Psi.hs b/lib/Numeric/GSL/Special/Psi.hs
new file mode 100644
index 0000000..c0021e4
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Psi.hs
@@ -0,0 +1,117 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Psi
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_psi.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Psi(
+  psi_int_e
+, psi_int
+, psi_e
+, psi
+, psi_1piy_e
+, psi_1piy
+, psi_1_int_e
+, psi_1_int
+, psi_1_e
+, psi_1
+, psi_n_e
+, psi_n
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_psi_int_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_int_e :: Int -> (Double,Double)
+psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n
+foreign import ccall "psi.h gsl_sf_psi_int_e" gsl_sf_psi_int_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi_int(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_int :: Int -> Double
+psi_int = gsl_sf_psi_int
+foreign import ccall "psi.h gsl_sf_psi_int" gsl_sf_psi_int :: Int -> Double
+
+-- | wrapper for int gsl_sf_psi_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_e :: Double -> (Double,Double)
+psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x
+foreign import ccall "psi.h gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi :: Double -> Double
+psi = gsl_sf_psi
+foreign import ccall "psi.h gsl_sf_psi" gsl_sf_psi :: Double -> Double
+
+-- | wrapper for int gsl_sf_psi_1piy_e(double y,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1piy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1piy_e :: Double -> (Double,Double)
+psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y
+foreign import ccall "psi.h gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi_1piy(double y);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1piy&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1piy :: Double -> Double
+psi_1piy = gsl_sf_psi_1piy
+foreign import ccall "psi.h gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
+
+-- | wrapper for int gsl_sf_psi_1_int_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1_int_e :: Int -> (Double,Double)
+psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n
+foreign import ccall "psi.h gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi_1_int(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1_int :: Int -> Double
+psi_1_int = gsl_sf_psi_1_int
+foreign import ccall "psi.h gsl_sf_psi_1_int" gsl_sf_psi_1_int :: Int -> Double
+
+-- | wrapper for int gsl_sf_psi_1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1_e :: Double -> (Double,Double)
+psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x
+foreign import ccall "psi.h gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi_1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_1 :: Double -> Double
+psi_1 = gsl_sf_psi_1
+foreign import ccall "psi.h gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_psi_n_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_n_e :: Int -> Double -> (Double,Double)
+psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x
+foreign import ccall "psi.h gsl_sf_psi_n_e" gsl_sf_psi_n_e :: Int -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_psi_n(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_psi_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+psi_n :: Int -> Double -> Double
+psi_n = gsl_sf_psi_n
+foreign import ccall "psi.h gsl_sf_psi_n" gsl_sf_psi_n :: Int -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Synchrotron.hs b/lib/Numeric/GSL/Special/Synchrotron.hs
new file mode 100644
index 0000000..14881fe
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Synchrotron.hs
@@ -0,0 +1,53 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Synchrotron
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_synchrotron.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Synchrotron(
+  synchrotron_1_e
+, synchrotron_1
+, synchrotron_2_e
+, synchrotron_2
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_synchrotron_1_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_synchrotron_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+synchrotron_1_e :: Double -> (Double,Double)
+synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x
+foreign import ccall "synchrotron.h gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_synchrotron_1(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_synchrotron_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+synchrotron_1 :: Double -> Double
+synchrotron_1 = gsl_sf_synchrotron_1
+foreign import ccall "synchrotron.h gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_synchrotron_2_e(double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_synchrotron_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+synchrotron_2_e :: Double -> (Double,Double)
+synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x
+foreign import ccall "synchrotron.h gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_synchrotron_2(double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_synchrotron_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+synchrotron_2 :: Double -> Double
+synchrotron_2 = gsl_sf_synchrotron_2
+foreign import ccall "synchrotron.h gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Trig.hs b/lib/Numeric/GSL/Special/Trig.hs
new file mode 100644
index 0000000..b846c1d
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Trig.hs
@@ -0,0 +1,164 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Trig
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.gnu.org/software/gsl/manual/html_node/Trigonometric-Functions.html>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Trig(
+  sin_e
+, Numeric.GSL.Special.Trig.sin
+, cos_e
+, Numeric.GSL.Special.Trig.cos
+, hypot_e
+, hypot
+, sinc_e
+, sinc
+, lnsinh_e
+, lnsinh
+, lncosh_e
+, lncosh
+, sin_err_e
+, cos_err_e
+, angle_restrict_symm
+, angle_restrict_pos
+, angle_restrict_symm_err_e
+, angle_restrict_pos_err_e
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_sin_e(double x,gsl_sf_result* result);
+sin_e :: Double -> (Double,Double)
+sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x
+foreign import ccall "trig.h gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_sin(double x);
+sin :: Double -> Double
+sin = gsl_sf_sin
+foreign import ccall "trig.h gsl_sf_sin" gsl_sf_sin :: Double -> Double
+
+-- | wrapper for int gsl_sf_cos_e(double x,gsl_sf_result* result);
+cos_e :: Double -> (Double,Double)
+cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x
+foreign import ccall "trig.h gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_cos(double x);
+cos :: Double -> Double
+cos = gsl_sf_cos
+foreign import ccall "trig.h gsl_sf_cos" gsl_sf_cos :: Double -> Double
+
+-- | wrapper for int gsl_sf_hypot_e(double x,double y,gsl_sf_result* result);
+hypot_e :: Double -> Double -> (Double,Double)
+hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y
+foreign import ccall "trig.h gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hypot(double x,double y);
+hypot :: Double -> Double -> Double
+hypot = gsl_sf_hypot
+foreign import ccall "trig.h gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_complex_sin_e(double zr,double zi,gsl_sf_result* szr,gsl_sf_result* szi);
+complex_sin_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_sin_e zr zi szr = createSFR "complex_sin_e" $ gsl_sf_complex_sin_e zr zi szr
+foreign import ccall "trig.h gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_complex_cos_e(double zr,double zi,gsl_sf_result* czr,gsl_sf_result* czi);
+complex_cos_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_cos_e zr zi czr = createSFR "complex_cos_e" $ gsl_sf_complex_cos_e zr zi czr
+foreign import ccall "trig.h gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_complex_logsin_e(double zr,double zi,gsl_sf_result* lszr,gsl_sf_result* lszi);
+complex_logsin_e :: Double -> Double -> Ptr Double -> (Double,Double)
+complex_logsin_e zr zi lszr = createSFR "complex_logsin_e" $ gsl_sf_complex_logsin_e zr zi lszr
+foreign import ccall "trig.h gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_sinc_e(double x,gsl_sf_result* result);
+sinc_e :: Double -> (Double,Double)
+sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x
+foreign import ccall "trig.h gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_sinc(double x);
+sinc :: Double -> Double
+sinc = gsl_sf_sinc
+foreign import ccall "trig.h gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
+
+-- | wrapper for int gsl_sf_lnsinh_e(double x,gsl_sf_result* result);
+lnsinh_e :: Double -> (Double,Double)
+lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x
+foreign import ccall "trig.h gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lnsinh(double x);
+lnsinh :: Double -> Double
+lnsinh = gsl_sf_lnsinh
+foreign import ccall "trig.h gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
+
+-- | wrapper for int gsl_sf_lncosh_e(double x,gsl_sf_result* result);
+lncosh_e :: Double -> (Double,Double)
+lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x
+foreign import ccall "trig.h gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_lncosh(double x);
+lncosh :: Double -> Double
+lncosh = gsl_sf_lncosh
+foreign import ccall "trig.h gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
+
+-- | wrapper for int gsl_sf_polar_to_rect(double r,double theta,gsl_sf_result* x,gsl_sf_result* y);
+polar_to_rect :: Double -> Double -> Ptr Double -> (Double,Double)
+polar_to_rect r theta x = createSFR "polar_to_rect" $ gsl_sf_polar_to_rect r theta x
+foreign import ccall "trig.h gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_rect_to_polar(double x,double y,gsl_sf_result* r,gsl_sf_result* theta);
+rect_to_polar :: Double -> Double -> Ptr Double -> (Double,Double)
+rect_to_polar x y r = createSFR "rect_to_polar" $ gsl_sf_rect_to_polar x y r
+foreign import ccall "trig.h gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_sin_err_e(double x,double dx,gsl_sf_result* result);
+sin_err_e :: Double -> Double -> (Double,Double)
+sin_err_e x dx = createSFR "sin_err_e" $ gsl_sf_sin_err_e x dx
+foreign import ccall "trig.h gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_cos_err_e(double x,double dx,gsl_sf_result* result);
+cos_err_e :: Double -> Double -> (Double,Double)
+cos_err_e x dx = createSFR "cos_err_e" $ gsl_sf_cos_err_e x dx
+foreign import ccall "trig.h gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_angle_restrict_symm_e(double* theta);
+angle_restrict_symm_e :: Ptr Double -> Int
+angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e
+foreign import ccall "trig.h gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> Int
+
+-- | wrapper for double gsl_sf_angle_restrict_symm(double theta);
+angle_restrict_symm :: Double -> Double
+angle_restrict_symm = gsl_sf_angle_restrict_symm
+foreign import ccall "trig.h gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
+
+-- | wrapper for int gsl_sf_angle_restrict_pos_e(double* theta);
+angle_restrict_pos_e :: Ptr Double -> Int
+angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e
+foreign import ccall "trig.h gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> Int
+
+-- | wrapper for double gsl_sf_angle_restrict_pos(double theta);
+angle_restrict_pos :: Double -> Double
+angle_restrict_pos = gsl_sf_angle_restrict_pos
+foreign import ccall "trig.h gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
+
+-- | wrapper for int gsl_sf_angle_restrict_symm_err_e(double theta,gsl_sf_result* result);
+angle_restrict_symm_err_e :: Double -> (Double,Double)
+angle_restrict_symm_err_e theta = createSFR "angle_restrict_symm_err_e" $ gsl_sf_angle_restrict_symm_err_e theta
+foreign import ccall "trig.h gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for int gsl_sf_angle_restrict_pos_err_e(double theta,gsl_sf_result* result);
+angle_restrict_pos_err_e :: Double -> (Double,Double)
+angle_restrict_pos_err_e theta = createSFR "angle_restrict_pos_err_e" $ gsl_sf_angle_restrict_pos_err_e theta
+foreign import ccall "trig.h gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr Double -> IO(Int)
diff --git a/lib/Numeric/GSL/Special/Zeta.hs b/lib/Numeric/GSL/Special/Zeta.hs
new file mode 100644
index 0000000..48c8ff1
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Zeta.hs
@@ -0,0 +1,133 @@
+------------------------------------------------------------
+{- |
+Module      :  Numeric.GSL.Special.Zeta
+Copyright   :  (c) Alberto Ruiz 2006
+License     :  GPL-style
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Wrappers for selected functions described at:
+
+<http://www.google.com/search?q=gsl_sf_zeta.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+
+-}
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Zeta(
+  zeta_int_e
+, zeta_int
+, zeta_e
+, zeta
+, zetam1_e
+, zetam1
+, zetam1_int_e
+, zetam1_int
+, hzeta_e
+, hzeta
+, eta_int_e
+, eta_int
+, eta_e
+, eta
+) where
+
+import Foreign(Ptr)
+import Numeric.GSL.Special.Internal
+
+-- | wrapper for int gsl_sf_zeta_int_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_zeta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zeta_int_e :: Int -> (Double,Double)
+zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n
+foreign import ccall "zeta.h gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_zeta_int(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_zeta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zeta_int :: Int -> Double
+zeta_int = gsl_sf_zeta_int
+foreign import ccall "zeta.h gsl_sf_zeta_int" gsl_sf_zeta_int :: Int -> Double
+
+-- | wrapper for int gsl_sf_zeta_e(double s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_zeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zeta_e :: Double -> (Double,Double)
+zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s
+foreign import ccall "zeta.h gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_zeta(double s);
+--
+--   <http://www.google.com/search?q=gsl_sf_zeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zeta :: Double -> Double
+zeta = gsl_sf_zeta
+foreign import ccall "zeta.h gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
+
+-- | wrapper for int gsl_sf_zetam1_e(double s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_zetam1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zetam1_e :: Double -> (Double,Double)
+zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s
+foreign import ccall "zeta.h gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_zetam1(double s);
+--
+--   <http://www.google.com/search?q=gsl_sf_zetam1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zetam1 :: Double -> Double
+zetam1 = gsl_sf_zetam1
+foreign import ccall "zeta.h gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
+
+-- | wrapper for int gsl_sf_zetam1_int_e(int s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_zetam1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zetam1_int_e :: Int -> (Double,Double)
+zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s
+foreign import ccall "zeta.h gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_zetam1_int(int s);
+--
+--   <http://www.google.com/search?q=gsl_sf_zetam1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+zetam1_int :: Int -> Double
+zetam1_int = gsl_sf_zetam1_int
+foreign import ccall "zeta.h gsl_sf_zetam1_int" gsl_sf_zetam1_int :: Int -> Double
+
+-- | wrapper for int gsl_sf_hzeta_e(double s,double q,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_hzeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hzeta_e :: Double -> Double -> (Double,Double)
+hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q
+foreign import ccall "zeta.h gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_hzeta(double s,double q);
+--
+--   <http://www.google.com/search?q=gsl_sf_hzeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+hzeta :: Double -> Double -> Double
+hzeta = gsl_sf_hzeta
+foreign import ccall "zeta.h gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
+
+-- | wrapper for int gsl_sf_eta_int_e(int n,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_eta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+eta_int_e :: Int -> (Double,Double)
+eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n
+foreign import ccall "zeta.h gsl_sf_eta_int_e" gsl_sf_eta_int_e :: Int -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_eta_int(int n);
+--
+--   <http://www.google.com/search?q=gsl_sf_eta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+eta_int :: Int -> Double
+eta_int = gsl_sf_eta_int
+foreign import ccall "zeta.h gsl_sf_eta_int" gsl_sf_eta_int :: Int -> Double
+
+-- | wrapper for int gsl_sf_eta_e(double s,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_eta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+eta_e :: Double -> (Double,Double)
+eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s
+foreign import ccall "zeta.h gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr Double -> IO(Int)
+
+-- | wrapper for double gsl_sf_eta(double s);
+--
+--   <http://www.google.com/search?q=gsl_sf_eta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+eta :: Double -> Double
+eta = gsl_sf_eta
+foreign import ccall "zeta.h gsl_sf_eta" gsl_sf_eta :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/airy.h b/lib/Numeric/GSL/Special/airy.h
new file mode 100644
index 0000000..e34e012
--- /dev/null
+++ b/lib/Numeric/GSL/Special/airy.h
@@ -0,0 +1,24 @@
+int gsl_sf_airy_Ai_e(double x,int mode,double* result);
+double gsl_sf_airy_Ai(double x,int mode);
+int gsl_sf_airy_Bi_e(double x,int mode,double* result);
+double gsl_sf_airy_Bi(double x,int mode);
+int gsl_sf_airy_Ai_scaled_e(double x,int mode,double* result);
+double gsl_sf_airy_Ai_scaled(double x,int mode);
+int gsl_sf_airy_Bi_scaled_e(double x,int mode,double* result);
+double gsl_sf_airy_Bi_scaled(double x,int mode);
+int gsl_sf_airy_Ai_deriv_e(double x,int mode,double* result);
+double gsl_sf_airy_Ai_deriv(double x,int mode);
+int gsl_sf_airy_Bi_deriv_e(double x,int mode,double* result);
+double gsl_sf_airy_Bi_deriv(double x,int mode);
+int gsl_sf_airy_Ai_deriv_scaled_e(double x,int mode,double* result);
+double gsl_sf_airy_Ai_deriv_scaled(double x,int mode);
+int gsl_sf_airy_Bi_deriv_scaled_e(double x,int mode,double* result);
+double gsl_sf_airy_Bi_deriv_scaled(double x,int mode);
+int gsl_sf_airy_zero_Ai_e(int s,double* result);
+double gsl_sf_airy_zero_Ai(int s);
+int gsl_sf_airy_zero_Bi_e(int s,double* result);
+double gsl_sf_airy_zero_Bi(int s);
+int gsl_sf_airy_zero_Ai_deriv_e(int s,double* result);
+double gsl_sf_airy_zero_Ai_deriv(int s);
+int gsl_sf_airy_zero_Bi_deriv_e(int s,double* result);
+double gsl_sf_airy_zero_Bi_deriv(int s);
diff --git a/lib/Numeric/GSL/Special/auto.hs b/lib/Numeric/GSL/Special/auto.hs
new file mode 100644
index 0000000..d2baff6
--- /dev/null
+++ b/lib/Numeric/GSL/Special/auto.hs
@@ -0,0 +1,233 @@
+-- automatic generation of wrappers for simple GSL special functions
+
+import Text.ParserCombinators.Parsec
+import System
+import Data.List(intersperse, isPrefixOf)
+import Data.Char(toUpper,isUpper,toLower)
+
+data Type = Normal Ident | Pointer Ident deriving (Eq, Show)
+
+type Ident = String
+
+data Header = Header Type Ident [(Type,Ident)] deriving Show
+
+headers f = case parse parseHeaders "" f of
+    Right l -> l
+    Left s -> error (show s)
+
+
+rep (c,r) [] = []
+rep (c,r) f@(x:xs) 
+  | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f)
+  | otherwise        = x:(rep (c,r) xs)
+
+
+fixlong [] = []
+fixlong "\\" = []
+fixlong ('\\':'\n':xs) = xs
+fixlong (x:xs) = x : fixlong xs
+
+
+safe (Header _ _ args) =  all ok args 
+                         || all ok (init args) && kn (last args)
+    where ok ((Normal s),_) | s `elem` ["double","float","int","gsl_mode_t"] = True
+          ok _ = False
+          kn ((Pointer "gsl_sf_result"),_) = True
+          kn ((Pointer "gsl_sf_result_e10"),_) = True
+          kn _ = False
+
+
+
+fixC s = rep ("gsl_mode_t","int") $ rep ("gsl_sf_result","double") $ rep ("gsl_sf_result_e10","double") $ s
+
+main = do
+    args <- getArgs
+    let name = args!!0
+        headerfile =
+            case args of
+                [n] -> "/usr/include/gsl/gsl_sf_"++n++".h"
+                [_,f] -> f
+    file <- readFile headerfile
+
+    putStrLn headerfile
+    --mapM_ print (headers $ fixlong file)
+    let parsed = (headers $ fixlong file)
+    writeFile (name ++".h") (fixC $ unlines $ map showC parsed) 
+
+    --putStrLn ""
+    --mapM (\(Header _ n _) -> putStrLn (drop 7 n ++",")) parsed
+    --putStrLn ""
+    --mapM_ (putStrLn.showFull (name ++".h")) parsed
+    let exports = rep (")",") where") $ rep ("(\n","(\n  ") $ rep (",\n",", ") $ unlines $ ["("]++intersperse "," (map (\(Header _ n _) -> hName n) (filter safe parsed))++[")"]
+    let defs = unlines $ map (showFull (name ++".h")) parsed
+    let imports = "\nimport Foreign(Ptr)\nimport Numeric.GSL.Special.Internal\n"
+    let mod = modhead name ++ "module Numeric.GSL.Special."++ upperFirst name++exports++imports++defs
+    writeFile (upperFirst name ++ ".hs") mod
+
+
+google name = "<http://www.google.com/search?q="
+               ++name
+               ++"&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>"
+
+modhead name = replicate 60 '-' ++ "\n"
+             ++"{- |\n"
+             ++"Module      :  Numeric.GSL.Special."++upperFirst name++"\n"
+             ++"Copyright   :  (c) Alberto Ruiz 2006\n"
+             ++"License     :  GPL-style\n"
+             ++"Maintainer  :  Alberto Ruiz (aruiz at um dot es)\n"
+             ++"Stability   :  provisional\n"
+             ++"Portability :  uses ffi\n"
+             ++"\nWrappers for selected functions described at:\n\n"
+             ++ google ( "gsl_sf_"++name++".h")
+             ++"\n\n-}\n"
+             ++ replicate 60 '-' ++ "\n\n"
+
+upperFirst (x:xs) = toUpper x : xs
+
+comment = do
+    string "/*"
+    closecomment
+    spaces
+    return "comment"
+
+closecomment = try (string "*/")
+               <|> (do anyChar
+                       closecomment)
+
+ident = do 
+    spaces
+    id <- many1 (noneOf "()[]* \n\t,;")
+    spaces
+    return id
+
+comment' = between (char '(') (char ')') (many $ noneOf ")") 
+
+
+define = do
+    string "#"
+    closedefine
+    spaces
+    return "define"
+
+closedefine = try (string "\n")
+              <|> (do anyChar
+                      closedefine)
+
+marks = do
+    try (string "__BEGIN_DECLS" >> spaces >> return "begin")
+    <|>
+    try (string "__END_DECLS" >> spaces >> return "end")
+
+
+
+irrelevant =
+    try comment
+    <|>
+    try define
+    <|>
+    marks
+
+
+parseHeaders = many parseHeader
+
+parseHeader = do
+    spaces
+    many irrelevant
+    spaces
+    (res,name)  <- typ
+    spaces
+    args <- between (char '(') (char ')') (sepBy typ (char ','))
+    spaces
+    char ';'
+    spaces
+    many irrelevant
+    return $ Header res name args
+
+typ = try t1 <|> t2
+
+symbol s = spaces >> string s >> spaces
+
+t1 = do
+    t <- try (symbol "const" >> symbol "unsigned" >> ident) -- aaagh 
+         <|>
+         try (symbol "const" >> ident)
+         <|>
+         try (symbol "unsigned" >> ident)
+         <|> ident
+    n <- ident
+    return (Normal t,n)
+
+t2 = do
+    t <- ident
+    spaces
+    char '*'
+    spaces
+    n <- ident
+    return (Pointer t,n)
+
+pure (Header _ _ args) | fst (last args) == Pointer "gsl_sf_result" = False
+                       | fst (last args) == Pointer "gsl_sf_result_e10" = False
+                       | otherwise = True
+
+showC (Header t n args) = showCt t ++ " " ++ n ++ "("  ++ (concat $ intersperse "," $ map showCa args) ++ ");"
+
+showCt (Normal s) = s
+showCt (Pointer s) = s ++ "*"
+
+showCa (t, a) = showCt t ++" "++ a
+
+showH hc h@(Header t n args) = "foreign import ccall \""++hc++" "++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
+    where t' | pure h = showHt t
+             | otherwise = "IO("++showHt t++")"
+
+showHt (Normal (s:ss)) = toUpper s : ss
+showHt (Pointer "gsl_sf_result") = "Ptr Double"
+showHt (Pointer "gsl_sf_result_e10") = "Ptr ()"
+showHt (Pointer (s:ss)) = "Ptr "++toUpper s : ss
+
+showHa (t,a) = showHt t
+
+showFull hc h@(Header t n args) = "\n-- | wrapper for "++showC h
+                                ++"\n--\n--   "++google n ++"\n"
+                                ++ boiler h ++"\n" 
+                                ++showH hc h 
+
+fixmd1 = rep ("Gsl_mode_t","Precision")
+fixmd2 = rep ("mode"," (precCode mode)")
+
+boiler h@(Header t n args) | fst (last args) == Pointer "gsl_sf_result" = boilerResult h
+                           | fst (last args) == Pointer "gsl_sf_result_e10" = boilerResultE10 h
+                           | any isMode args = boilerMode h
+                           | otherwise = boilerBasic h
+
+isMode (Normal "gsl_mode_t",_) = True
+isMode _ = False
+
+hName n = f $ drop 7 n
+    where f (s:ss) = toLower s : ss
+
+
+boilerResult h@(Header t n args) =
+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Double)\n" ++
+     hName n ++ " "++ initArgs args ++
+       " = createSFR \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)
+
+boilerResultE10 h@(Header t n args) =
+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Int,Double)\n" ++
+     hName n ++ " "++ initArgs args ++
+       " = createSFR_E10 \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)
+
+boilerBasic h@(Header t n args) = 
+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$map showHa args) ++" -> " ++showHt t ++ "\n" ++
+      hName n ++ " = " ++fixmd2 n
+
+boilerMode h@(Header t n args) =
+    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa args) ++" -> " ++ showHt t++"\n" ++
+     hName n ++ " "++ allArgs args ++
+       " = " ++ n ++ " "++ (fixmd2 $ allArgs args)
+
+cVar (v:vs) | isUpper v = toLower v : v : vs
+            | otherwise = v:vs
+
+allArgs args =  unwords (map (cVar.snd) args)
+initArgs args = unwords (map (cVar.snd) (init args))
\ No newline at end of file
diff --git a/lib/Numeric/GSL/Special/autoall.sh b/lib/Numeric/GSL/Special/autoall.sh
new file mode 100644
index 0000000..cb45957
--- /dev/null
+++ b/lib/Numeric/GSL/Special/autoall.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+#Airy.hs
+#  include Precision (..) in the export list
+#Exp.hs
+#  remove extern inline definition, qualify name
+#Coupling
+#  remove deprecated INCORRECT
+#Trig.hs
+#  qualify names
+#Legendre.hs
+#  remove extern inline
+#Log.hs
+#  remove extern inline, qualify name
+
+#runhaskell auto airy
+runhaskell auto bessel
+runhaskell auto clausen
+runhaskell auto coulomb
+#runhaskell auto coupling
+runhaskell auto dawson
+runhaskell auto debye
+runhaskell auto dilog
+runhaskell auto elementary
+runhaskell auto ellint
+runhaskell auto erf
+#runhaskell auto exp
+runhaskell auto expint
+runhaskell auto fermi_dirac
+runhaskell auto gamma
+runhaskell auto gegenbauer
+runhaskell auto hyperg
+runhaskell auto laguerre
+runhaskell auto lambert
+#runhaskell auto legendre
+#runhaskell auto log
+runhaskell auto pow_int
+runhaskell auto psi
+runhaskell auto synchrotron
+#runhaskell auto trig
+runhaskell auto zeta
\ No newline at end of file
diff --git a/lib/Numeric/GSL/Special/bessel.h b/lib/Numeric/GSL/Special/bessel.h
new file mode 100644
index 0000000..5a2445d
--- /dev/null
+++ b/lib/Numeric/GSL/Special/bessel.h
@@ -0,0 +1,100 @@
+int gsl_sf_bessel_J0_e(double x,double* result);
+double gsl_sf_bessel_J0(double x);
+int gsl_sf_bessel_J1_e(double x,double* result);
+double gsl_sf_bessel_J1(double x);
+int gsl_sf_bessel_Jn_e(int n,double x,double* result);
+double gsl_sf_bessel_Jn(int n,double x);
+int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_Y0_e(double x,double* result);
+double gsl_sf_bessel_Y0(double x);
+int gsl_sf_bessel_Y1_e(double x,double* result);
+double gsl_sf_bessel_Y1(double x);
+int gsl_sf_bessel_Yn_e(int n,double x,double* result);
+double gsl_sf_bessel_Yn(int n,double x);
+int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_I0_e(double x,double* result);
+double gsl_sf_bessel_I0(double x);
+int gsl_sf_bessel_I1_e(double x,double* result);
+double gsl_sf_bessel_I1(double x);
+int gsl_sf_bessel_In_e(int n,double x,double* result);
+double gsl_sf_bessel_In(int n,double x);
+int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_I0_scaled_e(double x,double* result);
+double gsl_sf_bessel_I0_scaled(double x);
+int gsl_sf_bessel_I1_scaled_e(double x,double* result);
+double gsl_sf_bessel_I1_scaled(double x);
+int gsl_sf_bessel_In_scaled_e(int n,double x,double* result);
+double gsl_sf_bessel_In_scaled(int n,double x);
+int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_K0_e(double x,double* result);
+double gsl_sf_bessel_K0(double x);
+int gsl_sf_bessel_K1_e(double x,double* result);
+double gsl_sf_bessel_K1(double x);
+int gsl_sf_bessel_Kn_e(int n,double x,double* result);
+double gsl_sf_bessel_Kn(int n,double x);
+int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_K0_scaled_e(double x,double* result);
+double gsl_sf_bessel_K0_scaled(double x);
+int gsl_sf_bessel_K1_scaled_e(double x,double* result);
+double gsl_sf_bessel_K1_scaled(double x);
+int gsl_sf_bessel_Kn_scaled_e(int n,double x,double* result);
+double gsl_sf_bessel_Kn_scaled(int n,double x);
+int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);
+int gsl_sf_bessel_j0_e(double x,double* result);
+double gsl_sf_bessel_j0(double x);
+int gsl_sf_bessel_j1_e(double x,double* result);
+double gsl_sf_bessel_j1(double x);
+int gsl_sf_bessel_j2_e(double x,double* result);
+double gsl_sf_bessel_j2(double x);
+int gsl_sf_bessel_jl_e(int l,double x,double* result);
+double gsl_sf_bessel_jl(int l,double x);
+int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);
+int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);
+int gsl_sf_bessel_y0_e(double x,double* result);
+double gsl_sf_bessel_y0(double x);
+int gsl_sf_bessel_y1_e(double x,double* result);
+double gsl_sf_bessel_y1(double x);
+int gsl_sf_bessel_y2_e(double x,double* result);
+double gsl_sf_bessel_y2(double x);
+int gsl_sf_bessel_yl_e(int l,double x,double* result);
+double gsl_sf_bessel_yl(int l,double x);
+int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);
+int gsl_sf_bessel_i0_scaled_e(double x,double* result);
+double gsl_sf_bessel_i0_scaled(double x);
+int gsl_sf_bessel_i1_scaled_e(double x,double* result);
+double gsl_sf_bessel_i1_scaled(double x);
+int gsl_sf_bessel_i2_scaled_e(double x,double* result);
+double gsl_sf_bessel_i2_scaled(double x);
+int gsl_sf_bessel_il_scaled_e(int l,double x,double* result);
+double gsl_sf_bessel_il_scaled(int l,double x);
+int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);
+int gsl_sf_bessel_k0_scaled_e(double x,double* result);
+double gsl_sf_bessel_k0_scaled(double x);
+int gsl_sf_bessel_k1_scaled_e(double x,double* result);
+double gsl_sf_bessel_k1_scaled(double x);
+int gsl_sf_bessel_k2_scaled_e(double x,double* result);
+double gsl_sf_bessel_k2_scaled(double x);
+int gsl_sf_bessel_kl_scaled_e(int l,double x,double* result);
+double gsl_sf_bessel_kl_scaled(int l,double x);
+int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);
+int gsl_sf_bessel_Jnu_e(double nu,double x,double* result);
+double gsl_sf_bessel_Jnu(double nu,double x);
+int gsl_sf_bessel_Ynu_e(double nu,double x,double* result);
+double gsl_sf_bessel_Ynu(double nu,double x);
+int gsl_sf_bessel_sequence_Jnu_e(double nu,int mode,size_t size,double* v);
+int gsl_sf_bessel_Inu_scaled_e(double nu,double x,double* result);
+double gsl_sf_bessel_Inu_scaled(double nu,double x);
+int gsl_sf_bessel_Inu_e(double nu,double x,double* result);
+double gsl_sf_bessel_Inu(double nu,double x);
+int gsl_sf_bessel_Knu_scaled_e(double nu,double x,double* result);
+double gsl_sf_bessel_Knu_scaled(double nu,double x);
+int gsl_sf_bessel_Knu_e(double nu,double x,double* result);
+double gsl_sf_bessel_Knu(double nu,double x);
+int gsl_sf_bessel_lnKnu_e(double nu,double x,double* result);
+double gsl_sf_bessel_lnKnu(double nu,double x);
+int gsl_sf_bessel_zero_J0_e(int s,double* result);
+double gsl_sf_bessel_zero_J0(int s);
+int gsl_sf_bessel_zero_J1_e(int s,double* result);
+double gsl_sf_bessel_zero_J1(int s);
+int gsl_sf_bessel_zero_Jnu_e(double nu,int s,double* result);
+double gsl_sf_bessel_zero_Jnu(double nu,int s);
diff --git a/lib/Numeric/GSL/Special/clausen.h b/lib/Numeric/GSL/Special/clausen.h
new file mode 100644
index 0000000..9f0225b
--- /dev/null
+++ b/lib/Numeric/GSL/Special/clausen.h
@@ -0,0 +1,2 @@
+int gsl_sf_clausen_e(double x,double* result);
+double gsl_sf_clausen(double x);
diff --git a/lib/Numeric/GSL/Special/coulomb.h b/lib/Numeric/GSL/Special/coulomb.h
new file mode 100644
index 0000000..2551081
--- /dev/null
+++ b/lib/Numeric/GSL/Special/coulomb.h
@@ -0,0 +1,11 @@
+int gsl_sf_hydrogenicR_1_e(double Z,double r,double* result);
+double gsl_sf_hydrogenicR_1(double Z,double r);
+int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,double* result);
+double gsl_sf_hydrogenicR(int n,int l,double Z,double r);
+int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,double* F,double* Fp,double* G,double* Gp,double* exp_F,double* exp_G);
+int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
+int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);
+int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);
+int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
+int gsl_sf_coulomb_CL_e(double L,double eta,double* result);
+int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);
diff --git a/lib/Numeric/GSL/Special/coupling.h b/lib/Numeric/GSL/Special/coupling.h
new file mode 100644
index 0000000..17de964
--- /dev/null
+++ b/lib/Numeric/GSL/Special/coupling.h
@@ -0,0 +1,10 @@
+int gsl_sf_coupling_3j_e(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc,double* result);
+double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);
+int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
+double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
+double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
+int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,double* result);
+double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);
+int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
+double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
diff --git a/lib/Numeric/GSL/Special/dawson.h b/lib/Numeric/GSL/Special/dawson.h
new file mode 100644
index 0000000..5f878b5
--- /dev/null
+++ b/lib/Numeric/GSL/Special/dawson.h
@@ -0,0 +1,2 @@
+int gsl_sf_dawson_e(double x,double* result);
+double gsl_sf_dawson(double x);
diff --git a/lib/Numeric/GSL/Special/debye.h b/lib/Numeric/GSL/Special/debye.h
new file mode 100644
index 0000000..2424b63
--- /dev/null
+++ b/lib/Numeric/GSL/Special/debye.h
@@ -0,0 +1,8 @@
+int gsl_sf_debye_1_e(double x,double* result);
+double gsl_sf_debye_1(double x);
+int gsl_sf_debye_2_e(double x,double* result);
+double gsl_sf_debye_2(double x);
+int gsl_sf_debye_3_e(double x,double* result);
+double gsl_sf_debye_3(double x);
+int gsl_sf_debye_4_e(double x,double* result);
+double gsl_sf_debye_4(double x);
diff --git a/lib/Numeric/GSL/Special/dilog.h b/lib/Numeric/GSL/Special/dilog.h
new file mode 100644
index 0000000..ce1599e
--- /dev/null
+++ b/lib/Numeric/GSL/Special/dilog.h
@@ -0,0 +1,5 @@
+int gsl_sf_dilog_e(double x,double* result);
+double gsl_sf_dilog(double x);
+int gsl_sf_complex_dilog_xy_e(double x,double y,double* result_re,double* result_im);
+int gsl_sf_complex_dilog_e(double r,double theta,double* result_re,double* result_im);
+int gsl_sf_complex_spence_xy_e(double x,double y,double* real_sp,double* imag_sp);
diff --git a/lib/Numeric/GSL/Special/elementary.h b/lib/Numeric/GSL/Special/elementary.h
new file mode 100644
index 0000000..bf5adf8
--- /dev/null
+++ b/lib/Numeric/GSL/Special/elementary.h
@@ -0,0 +1,3 @@
+int gsl_sf_multiply_e(double x,double y,double* result);
+double gsl_sf_multiply(double x,double y);
+int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,double* result);
diff --git a/lib/Numeric/GSL/Special/ellint.h b/lib/Numeric/GSL/Special/ellint.h
new file mode 100644
index 0000000..5329c6c
--- /dev/null
+++ b/lib/Numeric/GSL/Special/ellint.h
@@ -0,0 +1,20 @@
+int gsl_sf_ellint_Kcomp_e(double k,int mode,double* result);
+double gsl_sf_ellint_Kcomp(double k,int mode);
+int gsl_sf_ellint_Ecomp_e(double k,int mode,double* result);
+double gsl_sf_ellint_Ecomp(double k,int mode);
+int gsl_sf_ellint_F_e(double phi,double k,int mode,double* result);
+double gsl_sf_ellint_F(double phi,double k,int mode);
+int gsl_sf_ellint_E_e(double phi,double k,int mode,double* result);
+double gsl_sf_ellint_E(double phi,double k,int mode);
+int gsl_sf_ellint_P_e(double phi,double k,double n,int mode,double* result);
+double gsl_sf_ellint_P(double phi,double k,double n,int mode);
+int gsl_sf_ellint_D_e(double phi,double k,double n,int mode,double* result);
+double gsl_sf_ellint_D(double phi,double k,double n,int mode);
+int gsl_sf_ellint_RC_e(double x,double y,int mode,double* result);
+double gsl_sf_ellint_RC(double x,double y,int mode);
+int gsl_sf_ellint_RD_e(double x,double y,double z,int mode,double* result);
+double gsl_sf_ellint_RD(double x,double y,double z,int mode);
+int gsl_sf_ellint_RF_e(double x,double y,double z,int mode,double* result);
+double gsl_sf_ellint_RF(double x,double y,double z,int mode);
+int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,int mode,double* result);
+double gsl_sf_ellint_RJ(double x,double y,double z,double p,int mode);
diff --git a/lib/Numeric/GSL/Special/erf.h b/lib/Numeric/GSL/Special/erf.h
new file mode 100644
index 0000000..17369cf
--- /dev/null
+++ b/lib/Numeric/GSL/Special/erf.h
@@ -0,0 +1,12 @@
+int gsl_sf_erfc_e(double x,double* result);
+double gsl_sf_erfc(double x);
+int gsl_sf_log_erfc_e(double x,double* result);
+double gsl_sf_log_erfc(double x);
+int gsl_sf_erf_e(double x,double* result);
+double gsl_sf_erf(double x);
+int gsl_sf_erf_Z_e(double x,double* result);
+int gsl_sf_erf_Q_e(double x,double* result);
+double gsl_sf_erf_Z(double x);
+double gsl_sf_erf_Q(double x);
+int gsl_sf_hazard_e(double x,double* result);
+double gsl_sf_hazard(double x);
diff --git a/lib/Numeric/GSL/Special/exp.h b/lib/Numeric/GSL/Special/exp.h
new file mode 100644
index 0000000..20062f0
--- /dev/null
+++ b/lib/Numeric/GSL/Special/exp.h
@@ -0,0 +1,18 @@
+int gsl_sf_exp_e(double x,double* result);
+double gsl_sf_exp(double x);
+int gsl_sf_exp_e10_e(double x,double* result);
+int gsl_sf_exp_mult_e(double x,double y,double* result);
+double gsl_sf_exp_mult(double x,double y);
+int gsl_sf_exp_mult_e10_e(double x,double y,double* result);
+int gsl_sf_expm1_e(double x,double* result);
+double gsl_sf_expm1(double x);
+int gsl_sf_exprel_e(double x,double* result);
+double gsl_sf_exprel(double x);
+int gsl_sf_exprel_2_e(double x,double* result);
+double gsl_sf_exprel_2(double x);
+int gsl_sf_exprel_n_e(int n,double x,double* result);
+double gsl_sf_exprel_n(int n,double x);
+int gsl_sf_exp_err_e(double x,double dx,double* result);
+int gsl_sf_exp_err_e10_e(double x,double dx,double* result);
+int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,double* result);
+int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,double* result);
diff --git a/lib/Numeric/GSL/Special/expint.h b/lib/Numeric/GSL/Special/expint.h
new file mode 100644
index 0000000..1dd469f
--- /dev/null
+++ b/lib/Numeric/GSL/Special/expint.h
@@ -0,0 +1,24 @@
+int gsl_sf_expint_E1_e(double x,double* result);
+double gsl_sf_expint_E1(double x);
+int gsl_sf_expint_E2_e(double x,double* result);
+double gsl_sf_expint_E2(double x);
+int gsl_sf_expint_E1_scaled_e(double x,double* result);
+double gsl_sf_expint_E1_scaled(double x);
+int gsl_sf_expint_E2_scaled_e(double x,double* result);
+double gsl_sf_expint_E2_scaled(double x);
+int gsl_sf_expint_Ei_e(double x,double* result);
+double gsl_sf_expint_Ei(double x);
+int gsl_sf_expint_Ei_scaled_e(double x,double* result);
+double gsl_sf_expint_Ei_scaled(double x);
+int gsl_sf_Shi_e(double x,double* result);
+double gsl_sf_Shi(double x);
+int gsl_sf_Chi_e(double x,double* result);
+double gsl_sf_Chi(double x);
+int gsl_sf_expint_3_e(double x,double* result);
+double gsl_sf_expint_3(double x);
+int gsl_sf_Si_e(double x,double* result);
+double gsl_sf_Si(double x);
+int gsl_sf_Ci_e(double x,double* result);
+double gsl_sf_Ci(double x);
+int gsl_sf_atanint_e(double x,double* result);
+double gsl_sf_atanint(double x);
diff --git a/lib/Numeric/GSL/Special/fermi_dirac.h b/lib/Numeric/GSL/Special/fermi_dirac.h
new file mode 100644
index 0000000..7a4c757
--- /dev/null
+++ b/lib/Numeric/GSL/Special/fermi_dirac.h
@@ -0,0 +1,18 @@
+int gsl_sf_fermi_dirac_m1_e(double x,double* result);
+double gsl_sf_fermi_dirac_m1(double x);
+int gsl_sf_fermi_dirac_0_e(double x,double* result);
+double gsl_sf_fermi_dirac_0(double x);
+int gsl_sf_fermi_dirac_1_e(double x,double* result);
+double gsl_sf_fermi_dirac_1(double x);
+int gsl_sf_fermi_dirac_2_e(double x,double* result);
+double gsl_sf_fermi_dirac_2(double x);
+int gsl_sf_fermi_dirac_int_e(int j,double x,double* result);
+double gsl_sf_fermi_dirac_int(int j,double x);
+int gsl_sf_fermi_dirac_mhalf_e(double x,double* result);
+double gsl_sf_fermi_dirac_mhalf(double x);
+int gsl_sf_fermi_dirac_half_e(double x,double* result);
+double gsl_sf_fermi_dirac_half(double x);
+int gsl_sf_fermi_dirac_3half_e(double x,double* result);
+double gsl_sf_fermi_dirac_3half(double x);
+int gsl_sf_fermi_dirac_inc_0_e(double x,double b,double* result);
+double gsl_sf_fermi_dirac_inc_0(double x,double b);
diff --git a/lib/Numeric/GSL/Special/gamma.h b/lib/Numeric/GSL/Special/gamma.h
new file mode 100644
index 0000000..c5cc417
--- /dev/null
+++ b/lib/Numeric/GSL/Special/gamma.h
@@ -0,0 +1,43 @@
+int gsl_sf_lngamma_e(double x,double* result);
+double gsl_sf_lngamma(double x);
+int gsl_sf_lngamma_sgn_e(double x,double* result_lg,double* sgn);
+int gsl_sf_gamma_e(double x,double* result);
+double gsl_sf_gamma(double x);
+int gsl_sf_gammastar_e(double x,double* result);
+double gsl_sf_gammastar(double x);
+int gsl_sf_gammainv_e(double x,double* result);
+double gsl_sf_gammainv(double x);
+int gsl_sf_lngamma_complex_e(double zr,double zi,double* lnr,double* arg);
+int gsl_sf_taylorcoeff_e(int n,double x,double* result);
+double gsl_sf_taylorcoeff(int n,double x);
+int gsl_sf_fact_e(int n,double* result);
+double gsl_sf_fact(int n);
+int gsl_sf_doublefact_e(int n,double* result);
+double gsl_sf_doublefact(int n);
+int gsl_sf_lnfact_e(int n,double* result);
+double gsl_sf_lnfact(int n);
+int gsl_sf_lndoublefact_e(int n,double* result);
+double gsl_sf_lndoublefact(int n);
+int gsl_sf_lnchoose_e(int n,int m,double* result);
+double gsl_sf_lnchoose(int n,int m);
+int gsl_sf_choose_e(int n,int m,double* result);
+double gsl_sf_choose(int n,int m);
+int gsl_sf_lnpoch_e(double a,double x,double* result);
+double gsl_sf_lnpoch(double a,double x);
+int gsl_sf_lnpoch_sgn_e(double a,double x,double* result,double* sgn);
+int gsl_sf_poch_e(double a,double x,double* result);
+double gsl_sf_poch(double a,double x);
+int gsl_sf_pochrel_e(double a,double x,double* result);
+double gsl_sf_pochrel(double a,double x);
+int gsl_sf_gamma_inc_Q_e(double a,double x,double* result);
+double gsl_sf_gamma_inc_Q(double a,double x);
+int gsl_sf_gamma_inc_P_e(double a,double x,double* result);
+double gsl_sf_gamma_inc_P(double a,double x);
+int gsl_sf_gamma_inc_e(double a,double x,double* result);
+double gsl_sf_gamma_inc(double a,double x);
+int gsl_sf_lnbeta_e(double a,double b,double* result);
+double gsl_sf_lnbeta(double a,double b);
+int gsl_sf_beta_e(double a,double b,double* result);
+double gsl_sf_beta(double a,double b);
+int gsl_sf_beta_inc_e(double a,double b,double x,double* result);
+double gsl_sf_beta_inc(double a,double b,double x);
diff --git a/lib/Numeric/GSL/Special/gegenbauer.h b/lib/Numeric/GSL/Special/gegenbauer.h
new file mode 100644
index 0000000..228cbd3
--- /dev/null
+++ b/lib/Numeric/GSL/Special/gegenbauer.h
@@ -0,0 +1,9 @@
+int gsl_sf_gegenpoly_1_e(double lambda,double x,double* result);
+int gsl_sf_gegenpoly_2_e(double lambda,double x,double* result);
+int gsl_sf_gegenpoly_3_e(double lambda,double x,double* result);
+double gsl_sf_gegenpoly_1(double lambda,double x);
+double gsl_sf_gegenpoly_2(double lambda,double x);
+double gsl_sf_gegenpoly_3(double lambda,double x);
+int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,double* result);
+double gsl_sf_gegenpoly_n(int n,double lambda,double x);
+int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);
diff --git a/lib/Numeric/GSL/Special/gsl_sf_exp.h b/lib/Numeric/GSL/Special/gsl_sf_exp.h
new file mode 100644
index 0000000..b1f0d89
--- /dev/null
+++ b/lib/Numeric/GSL/Special/gsl_sf_exp.h
@@ -0,0 +1,146 @@
+/* specfunc/gsl_sf_exp.h
+ * 
+ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/* Author:  G. Jungman */
+
+#ifndef __GSL_SF_EXP_H__
+#define __GSL_SF_EXP_H__
+
+#include <gsl/gsl_sf_result.h>
+#include <gsl/gsl_precision.h>
+
+#undef __BEGIN_DECLS
+#undef __END_DECLS
+#ifdef __cplusplus
+# define __BEGIN_DECLS extern "C" {
+# define __END_DECLS }
+#else
+# define __BEGIN_DECLS /* empty */
+# define __END_DECLS /* empty */
+#endif
+
+__BEGIN_DECLS
+
+/* Provide an exp() function with GSL semantics,
+ * i.e. with proper error checking, etc.
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_e(const double x, gsl_sf_result * result);
+double gsl_sf_exp(const double x);
+
+
+/* Exp(x)
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_e10_e(const double x, gsl_sf_result_e10 * result);
+
+
+/* Exponentiate and multiply by a given factor:  y * Exp(x)
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_mult_e(const double x, const double y, gsl_sf_result * result);
+double gsl_sf_exp_mult(const double x, const double y);
+
+
+/* Exponentiate and multiply by a given factor:  y * Exp(x)
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_mult_e10_e(const double x, const double y, gsl_sf_result_e10 * result);
+
+
+/* exp(x)-1
+ *
+ * exceptions: GSL_EOVRFLW
+ */
+int gsl_sf_expm1_e(const double x, gsl_sf_result * result);
+double gsl_sf_expm1(const double x);
+
+
+/* (exp(x)-1)/x = 1 + x/2 + x^2/(2*3) + x^3/(2*3*4) + ...
+ *
+ * exceptions: GSL_EOVRFLW
+ */
+int gsl_sf_exprel_e(const double x, gsl_sf_result * result);
+double gsl_sf_exprel(const double x);
+
+
+/* 2(exp(x)-1-x)/x^2 = 1 + x/3 + x^2/(3*4) + x^3/(3*4*5) + ...
+ *
+ * exceptions: GSL_EOVRFLW
+ */
+int gsl_sf_exprel_2_e(double x, gsl_sf_result * result);
+double gsl_sf_exprel_2(const double x);
+
+
+/* Similarly for the N-th generalization of
+ * the above. The so-called N-relative exponential
+ *
+ * exprel_N(x) = N!/x^N (exp(x) - Sum[x^k/k!, {k,0,N-1}])
+ *             = 1 + x/(N+1) + x^2/((N+1)(N+2)) + ...
+ *             = 1F1(1,1+N,x)
+ */
+int gsl_sf_exprel_n_e(const int n, const double x, gsl_sf_result * result);
+double gsl_sf_exprel_n(const int n, const double x);
+
+
+/* Exponentiate a quantity with an associated error.
+ */
+int gsl_sf_exp_err_e(const double x, const double dx, gsl_sf_result * result);
+
+/* Exponentiate a quantity with an associated error.
+ */
+int gsl_sf_exp_err_e10_e(const double x, const double dx, gsl_sf_result_e10 * result);
+
+
+/* Exponentiate and multiply by a given factor:  y * Exp(x),
+ * for quantities with associated errors.
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_mult_err_e(const double x, const double dx, const double y, const double dy, gsl_sf_result * result);
+
+
+/* Exponentiate and multiply by a given factor:  y * Exp(x),
+ * for quantities with associated errors.
+ *
+ * exceptions: GSL_EOVRFLW, GSL_EUNDRFLW
+ */
+int gsl_sf_exp_mult_err_e10_e(const double x, const double dx, const double y, const double dy, gsl_sf_result_e10 * result);
+
+__END_DECLS
+
+
+#ifdef HAVE_INLINE
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_errno.h>
+
+__BEGIN_DECLS
+
+
+
+__END_DECLS
+
+#endif /* HAVE_INLINE */
+
+
+#endif /* __GSL_SF_EXP_H__ */
diff --git a/lib/Numeric/GSL/Special/gsl_sf_log.h b/lib/Numeric/GSL/Special/gsl_sf_log.h
new file mode 100644
index 0000000..5225d05
--- /dev/null
+++ b/lib/Numeric/GSL/Special/gsl_sf_log.h
@@ -0,0 +1,90 @@
+/* specfunc/gsl_sf_log.h
+ * 
+ * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/* Author:  G. Jungman */
+
+#ifndef __GSL_SF_LOG_H__
+#define __GSL_SF_LOG_H__
+
+#include <gsl/gsl_sf_result.h>
+
+#undef __BEGIN_DECLS
+#undef __END_DECLS
+#ifdef __cplusplus
+# define __BEGIN_DECLS extern "C" {
+# define __END_DECLS }
+#else
+# define __BEGIN_DECLS /* empty */
+# define __END_DECLS /* empty */
+#endif
+
+__BEGIN_DECLS
+
+
+/* Provide a logarithm function with GSL semantics.
+ *
+ * exceptions: GSL_EDOM
+ */
+int gsl_sf_log_e(const double x, gsl_sf_result * result);
+double gsl_sf_log(const double x);
+
+
+/* Log(|x|)
+ *
+ * exceptions: GSL_EDOM
+ */
+int gsl_sf_log_abs_e(const double x, gsl_sf_result * result);
+double gsl_sf_log_abs(const double x);
+
+
+/* Complex Logarithm
+ *   exp(lnr + I theta) = zr + I zi
+ * Returns argument in [-pi,pi].
+ *
+ * exceptions: GSL_EDOM
+ */
+int gsl_sf_complex_log_e(const double zr, const double zi, gsl_sf_result * lnr, gsl_sf_result * theta);
+
+
+/* Log(1 + x)
+ *
+ * exceptions: GSL_EDOM
+ */
+int gsl_sf_log_1plusx_e(const double x, gsl_sf_result * result);
+double gsl_sf_log_1plusx(const double x);
+
+
+/* Log(1 + x) - x
+ *
+ * exceptions: GSL_EDOM
+ */
+int gsl_sf_log_1plusx_mx_e(const double x, gsl_sf_result * result);
+double gsl_sf_log_1plusx_mx(const double x);
+
+
+#ifdef HAVE_INLINE
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_errno.h>
+
+#endif /* HAVE_INLINE */
+
+
+__END_DECLS
+
+#endif /* __GSL_SF_LOG_H__ */
diff --git a/lib/Numeric/GSL/Special/hyperg.h b/lib/Numeric/GSL/Special/hyperg.h
new file mode 100644
index 0000000..aa59106
--- /dev/null
+++ b/lib/Numeric/GSL/Special/hyperg.h
@@ -0,0 +1,22 @@
+int gsl_sf_hyperg_0F1_e(double c,double x,double* result);
+double gsl_sf_hyperg_0F1(double c,double x);
+int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,double* result);
+double gsl_sf_hyperg_1F1_int(int m,int n,double x);
+int gsl_sf_hyperg_1F1_e(double a,double b,double x,double* result);
+double gsl_sf_hyperg_1F1(double a,double b,double x);
+int gsl_sf_hyperg_U_int_e(int m,int n,double x,double* result);
+double gsl_sf_hyperg_U_int(int m,int n,double x);
+int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,double* result);
+int gsl_sf_hyperg_U_e(double a,double b,double x,double* result);
+double gsl_sf_hyperg_U(double a,double b,double x);
+int gsl_sf_hyperg_U_e10_e(double a,double b,double x,double* result);
+int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,double* result);
+double gsl_sf_hyperg_2F1(double a,double b,double c,double x);
+int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,double* result);
+double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);
+int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,double* result);
+double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);
+int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,double* result);
+double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);
+int gsl_sf_hyperg_2F0_e(double a,double b,double x,double* result);
+double gsl_sf_hyperg_2F0(double a,double b,double x);
diff --git a/lib/Numeric/GSL/Special/laguerre.h b/lib/Numeric/GSL/Special/laguerre.h
new file mode 100644
index 0000000..6275a05
--- /dev/null
+++ b/lib/Numeric/GSL/Special/laguerre.h
@@ -0,0 +1,8 @@
+int gsl_sf_laguerre_1_e(double a,double x,double* result);
+int gsl_sf_laguerre_2_e(double a,double x,double* result);
+int gsl_sf_laguerre_3_e(double a,double x,double* result);
+double gsl_sf_laguerre_1(double a,double x);
+double gsl_sf_laguerre_2(double a,double x);
+double gsl_sf_laguerre_3(double a,double x);
+int gsl_sf_laguerre_n_e(int n,double a,double x,double* result);
+double gsl_sf_laguerre_n(int n,double a,double x);
diff --git a/lib/Numeric/GSL/Special/lambert.h b/lib/Numeric/GSL/Special/lambert.h
new file mode 100644
index 0000000..df90d11
--- /dev/null
+++ b/lib/Numeric/GSL/Special/lambert.h
@@ -0,0 +1,4 @@
+int gsl_sf_lambert_W0_e(double x,double* result);
+double gsl_sf_lambert_W0(double x);
+int gsl_sf_lambert_Wm1_e(double x,double* result);
+double gsl_sf_lambert_Wm1(double x);
diff --git a/lib/Numeric/GSL/Special/legendre.h b/lib/Numeric/GSL/Special/legendre.h
new file mode 100644
index 0000000..aebe84f
--- /dev/null
+++ b/lib/Numeric/GSL/Special/legendre.h
@@ -0,0 +1,44 @@
+int gsl_sf_legendre_Pl_e(int l,double x,double* result);
+double gsl_sf_legendre_Pl(int l,double x);
+int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);
+int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);
+int gsl_sf_legendre_P1_e(double x,double* result);
+int gsl_sf_legendre_P2_e(double x,double* result);
+int gsl_sf_legendre_P3_e(double x,double* result);
+double gsl_sf_legendre_P1(double x);
+double gsl_sf_legendre_P2(double x);
+double gsl_sf_legendre_P3(double x);
+int gsl_sf_legendre_Q0_e(double x,double* result);
+double gsl_sf_legendre_Q0(double x);
+int gsl_sf_legendre_Q1_e(double x,double* result);
+double gsl_sf_legendre_Q1(double x);
+int gsl_sf_legendre_Ql_e(int l,double x,double* result);
+double gsl_sf_legendre_Ql(int l,double x);
+int gsl_sf_legendre_Plm_e(int l,int m,double x,double* result);
+double gsl_sf_legendre_Plm(int l,int m,double x);
+int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);
+int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
+int gsl_sf_legendre_sphPlm_e(int l,int m,double x,double* result);
+double gsl_sf_legendre_sphPlm(int l,int m,double x);
+int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);
+int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
+int gsl_sf_legendre_array_size(int lmax,int m);
+int gsl_sf_conicalP_half_e(double lambda,double x,double* result);
+double gsl_sf_conicalP_half(double lambda,double x);
+int gsl_sf_conicalP_mhalf_e(double lambda,double x,double* result);
+double gsl_sf_conicalP_mhalf(double lambda,double x);
+int gsl_sf_conicalP_0_e(double lambda,double x,double* result);
+double gsl_sf_conicalP_0(double lambda,double x);
+int gsl_sf_conicalP_1_e(double lambda,double x,double* result);
+double gsl_sf_conicalP_1(double lambda,double x);
+int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,double* result);
+double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);
+int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,double* result);
+double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);
+int gsl_sf_legendre_H3d_0_e(double lambda,double eta,double* result);
+double gsl_sf_legendre_H3d_0(double lambda,double eta);
+int gsl_sf_legendre_H3d_1_e(double lambda,double eta,double* result);
+double gsl_sf_legendre_H3d_1(double lambda,double eta);
+int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,double* result);
+double gsl_sf_legendre_H3d(int l,double lambda,double eta);
+int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);
diff --git a/lib/Numeric/GSL/Special/log.h b/lib/Numeric/GSL/Special/log.h
new file mode 100644
index 0000000..5713845
--- /dev/null
+++ b/lib/Numeric/GSL/Special/log.h
@@ -0,0 +1,9 @@
+int gsl_sf_log_e(double x,double* result);
+double gsl_sf_log(double x);
+int gsl_sf_log_abs_e(double x,double* result);
+double gsl_sf_log_abs(double x);
+int gsl_sf_complex_log_e(double zr,double zi,double* lnr,double* theta);
+int gsl_sf_log_1plusx_e(double x,double* result);
+double gsl_sf_log_1plusx(double x);
+int gsl_sf_log_1plusx_mx_e(double x,double* result);
+double gsl_sf_log_1plusx_mx(double x);
diff --git a/lib/Numeric/GSL/Special/pow_int.h b/lib/Numeric/GSL/Special/pow_int.h
new file mode 100644
index 0000000..aba8bc9
--- /dev/null
+++ b/lib/Numeric/GSL/Special/pow_int.h
@@ -0,0 +1,2 @@
+int gsl_sf_pow_int_e(double x,int n,double* result);
+double gsl_sf_pow_int(double x,int n);
diff --git a/lib/Numeric/GSL/Special/psi.h b/lib/Numeric/GSL/Special/psi.h
new file mode 100644
index 0000000..589eb34
--- /dev/null
+++ b/lib/Numeric/GSL/Special/psi.h
@@ -0,0 +1,12 @@
+int gsl_sf_psi_int_e(int n,double* result);
+double gsl_sf_psi_int(int n);
+int gsl_sf_psi_e(double x,double* result);
+double gsl_sf_psi(double x);
+int gsl_sf_psi_1piy_e(double y,double* result);
+double gsl_sf_psi_1piy(double y);
+int gsl_sf_psi_1_int_e(int n,double* result);
+double gsl_sf_psi_1_int(int n);
+int gsl_sf_psi_1_e(double x,double* result);
+double gsl_sf_psi_1(double x);
+int gsl_sf_psi_n_e(int n,double x,double* result);
+double gsl_sf_psi_n(int n,double x);
diff --git a/lib/Numeric/GSL/Special/synchrotron.h b/lib/Numeric/GSL/Special/synchrotron.h
new file mode 100644
index 0000000..786401c
--- /dev/null
+++ b/lib/Numeric/GSL/Special/synchrotron.h
@@ -0,0 +1,4 @@
+int gsl_sf_synchrotron_1_e(double x,double* result);
+double gsl_sf_synchrotron_1(double x);
+int gsl_sf_synchrotron_2_e(double x,double* result);
+double gsl_sf_synchrotron_2(double x);
diff --git a/lib/Numeric/GSL/Special/trig.h b/lib/Numeric/GSL/Special/trig.h
new file mode 100644
index 0000000..50677f2
--- /dev/null
+++ b/lib/Numeric/GSL/Special/trig.h
@@ -0,0 +1,25 @@
+int gsl_sf_sin_e(double x,double* result);
+double gsl_sf_sin(double x);
+int gsl_sf_cos_e(double x,double* result);
+double gsl_sf_cos(double x);
+int gsl_sf_hypot_e(double x,double y,double* result);
+double gsl_sf_hypot(double x,double y);
+int gsl_sf_complex_sin_e(double zr,double zi,double* szr,double* szi);
+int gsl_sf_complex_cos_e(double zr,double zi,double* czr,double* czi);
+int gsl_sf_complex_logsin_e(double zr,double zi,double* lszr,double* lszi);
+int gsl_sf_sinc_e(double x,double* result);
+double gsl_sf_sinc(double x);
+int gsl_sf_lnsinh_e(double x,double* result);
+double gsl_sf_lnsinh(double x);
+int gsl_sf_lncosh_e(double x,double* result);
+double gsl_sf_lncosh(double x);
+int gsl_sf_polar_to_rect(double r,double theta,double* x,double* y);
+int gsl_sf_rect_to_polar(double x,double y,double* r,double* theta);
+int gsl_sf_sin_err_e(double x,double dx,double* result);
+int gsl_sf_cos_err_e(double x,double dx,double* result);
+int gsl_sf_angle_restrict_symm_e(double* theta);
+double gsl_sf_angle_restrict_symm(double theta);
+int gsl_sf_angle_restrict_pos_e(double* theta);
+double gsl_sf_angle_restrict_pos(double theta);
+int gsl_sf_angle_restrict_symm_err_e(double theta,double* result);
+int gsl_sf_angle_restrict_pos_err_e(double theta,double* result);
diff --git a/lib/Numeric/GSL/Special/zeta.h b/lib/Numeric/GSL/Special/zeta.h
new file mode 100644
index 0000000..b961ece
--- /dev/null
+++ b/lib/Numeric/GSL/Special/zeta.h
@@ -0,0 +1,14 @@
+int gsl_sf_zeta_int_e(int n,double* result);
+double gsl_sf_zeta_int(int n);
+int gsl_sf_zeta_e(double s,double* result);
+double gsl_sf_zeta(double s);
+int gsl_sf_zetam1_e(double s,double* result);
+double gsl_sf_zetam1(double s);
+int gsl_sf_zetam1_int_e(int s,double* result);
+double gsl_sf_zetam1_int(int s);
+int gsl_sf_hzeta_e(double s,double q,double* result);
+double gsl_sf_hzeta(double s,double q);
+int gsl_sf_eta_int_e(int n,double* result);
+double gsl_sf_eta_int(int n);
+int gsl_sf_eta_e(double s,double* result);
+double gsl_sf_eta(double s);
diff --git a/lib/Numeric/GSL/Vector.hs b/lib/Numeric/GSL/Vector.hs
new file mode 100644
index 0000000..ef3d5e8
--- /dev/null
+++ b/lib/Numeric/GSL/Vector.hs
@@ -0,0 +1,145 @@
+{-# OPTIONS_GHC -fglasgow-exts #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Vector
+-- Copyright   :  (c) Alberto Ruiz 2007
+-- License     :  GPL-style
+--
+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>
+-- Stability   :  provisional
+-- Portability :  portable (uses FFI)
+--
+-- Vector operations
+--
+-----------------------------------------------------------------------------
+-- #hide
+
+module Numeric.GSL.Vector (
+    FunCodeS(..), toScalarR,
+    FunCodeV(..), vectorMapR, vectorMapC,
+    FunCodeSV(..), vectorMapValR, vectorMapValC,
+    FunCodeVV(..), vectorZipR, vectorZipC
+) where
+
+import Data.Packed.Internal.Common
+import Data.Packed.Internal.Vector
+
+import Complex
+import Foreign
+
+data FunCodeV = Sin
+              | Cos
+              | Tan
+              | Abs
+              | ASin
+              | ACos
+              | ATan
+              | Sinh
+              | Cosh
+              | Tanh
+              | ASinh
+              | ACosh
+              | ATanh
+              | Exp
+              | Log
+              | Sign
+              | Sqrt
+              deriving Enum
+
+data FunCodeSV = Scale
+               | Recip
+               | AddConstant
+               | Negate
+               | PowSV
+               | PowVS
+               deriving Enum
+
+data FunCodeVV = Add
+               | Sub
+               | Mul
+               | Div
+               | Pow
+               | ATan2
+               deriving Enum
+
+data FunCodeS = Norm2
+              | AbsSum
+              | MaxIdx
+              | Max
+              | MinIdx
+              | Min
+              deriving Enum
+
+------------------------------------------------------------------
+
+toScalarAux fun code v = unsafePerformIO $ do
+    r <- createVector 1
+    fun (fromEnum code) // vec v // vec r // check "toScalarAux" [v]
+    return (r `at` 0)
+
+vectorMapAux fun code v = unsafePerformIO $ do
+    r <- createVector (dim v)
+    fun (fromEnum code) // vec v // vec r // check "vectorMapAux" [v]
+    return r
+
+vectorMapValAux fun code val v = unsafePerformIO $ do
+    r <- createVector (dim v)
+    pval <- newArray [val]
+    fun (fromEnum code) pval // vec v // vec r // check "vectorMapValAux" [v]
+    free pval
+    return r
+
+vectorZipAux fun code u v = unsafePerformIO $ do
+    r <- createVector (dim u)
+    fun (fromEnum code) // vec u // vec v // vec r // check "vectorZipAux" [u,v]
+    return r
+
+---------------------------------------------------------------------
+
+-- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
+toScalarR :: FunCodeS -> Vector Double -> Double
+toScalarR oper =  toScalarAux c_toScalarR (fromEnum oper)
+
+foreign import ccall safe "gsl-aux.h toScalarR" c_toScalarR :: Int -> TVV
+
+------------------------------------------------------------------
+
+-- | map of real vectors with given function
+vectorMapR :: FunCodeV -> Vector Double -> Vector Double
+vectorMapR = vectorMapAux c_vectorMapR
+
+foreign import ccall safe "gsl-aux.h mapR" c_vectorMapR :: Int -> TVV
+
+-- | map of complex vectors with given function
+vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)
+vectorMapC oper = vectorMapAux c_vectorMapC (fromEnum oper)
+
+foreign import ccall safe "gsl-aux.h mapC" c_vectorMapC :: Int -> TCVCV
+
+-------------------------------------------------------------------
+
+-- | map of real vectors with given function
+vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double
+vectorMapValR oper = vectorMapValAux c_vectorMapValR (fromEnum oper)
+
+foreign import ccall safe "gsl-aux.h mapValR" c_vectorMapValR :: Int -> Ptr Double -> TVV
+
+-- | map of complex vectors with given function
+vectorMapValC :: FunCodeSV -> Complex Double -> Vector (Complex Double) -> Vector (Complex Double)
+vectorMapValC = vectorMapValAux c_vectorMapValC
+
+foreign import ccall safe "gsl-aux.h mapValC" c_vectorMapValC :: Int -> Ptr (Complex Double) -> TCVCV
+
+-------------------------------------------------------------------
+
+-- | elementwise operation on real vectors
+vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double
+vectorZipR = vectorZipAux c_vectorZipR
+
+foreign import ccall safe "gsl-aux.h zipR" c_vectorZipR :: Int -> TVVV
+
+-- | elementwise operation on complex vectors
+vectorZipC :: FunCodeVV -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)
+vectorZipC = vectorZipAux c_vectorZipC
+
+foreign import ccall safe "gsl-aux.h zipC" c_vectorZipC :: Int -> TCVCVCV
diff --git a/lib/Numeric/GSL/gsl-aux.c b/lib/Numeric/GSL/gsl-aux.c
new file mode 100644
index 0000000..c602d5e
--- /dev/null
+++ b/lib/Numeric/GSL/gsl-aux.c
@@ -0,0 +1,743 @@
+#include "gsl-aux.h"
+#include <gsl/gsl_blas.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_fft_complex.h>
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_integration.h>
+#include <gsl/gsl_deriv.h>
+#include <gsl/gsl_poly.h>
+#include <gsl/gsl_multimin.h>
+#include <gsl/gsl_complex.h>
+#include <gsl/gsl_complex_math.h>
+#include <string.h>
+#include <stdio.h>
+
+#define MACRO(B) do {B} while (0)
+#define ERROR(CODE) MACRO(return CODE;)
+#define REQUIRES(COND, CODE) MACRO(if(!(COND)) {ERROR(CODE);})
+#define OK return 0;
+
+#define MIN(A,B) ((A)<(B)?(A):(B))
+#define MAX(A,B) ((A)>(B)?(A):(B))
+
+#ifdef DBG
+#define DEBUGMSG(M) printf("*** calling aux C function: %s\n",M);
+#else
+#define DEBUGMSG(M)
+#endif
+
+#define CHECK(RES,CODE) MACRO(if(RES) return CODE;)
+
+#ifdef DBG
+#define DEBUGMAT(MSG,X) printf(MSG" = \n"); gsl_matrix_fprintf(stdout,X,"%f"); printf("\n");
+#else
+#define DEBUGMAT(MSG,X)
+#endif
+
+#ifdef DBG
+#define DEBUGVEC(MSG,X) printf(MSG" = \n"); gsl_vector_fprintf(stdout,X,"%f"); printf("\n");
+#else
+#define DEBUGVEC(MSG,X)
+#endif
+
+#define DVVIEW(A) gsl_vector_view A = gsl_vector_view_array(A##p,A##n)
+#define DMVIEW(A) gsl_matrix_view A = gsl_matrix_view_array(A##p,A##r,A##c)
+#define CVVIEW(A) gsl_vector_complex_view A = gsl_vector_complex_view_array((double*)A##p,A##n)
+#define CMVIEW(A) gsl_matrix_complex_view A = gsl_matrix_complex_view_array((double*)A##p,A##r,A##c)
+#define KDVVIEW(A) gsl_vector_const_view A = gsl_vector_const_view_array(A##p,A##n)
+#define KDMVIEW(A) gsl_matrix_const_view A = gsl_matrix_const_view_array(A##p,A##r,A##c)
+#define KCVVIEW(A) gsl_vector_complex_const_view A = gsl_vector_complex_const_view_array((double*)A##p,A##n)
+#define KCMVIEW(A) gsl_matrix_complex_const_view A = gsl_matrix_complex_const_view_array((double*)A##p,A##r,A##c)
+
+#define V(a) (&a.vector)
+#define M(a) (&a.matrix)
+
+#define GCVEC(A) int A##n, gsl_complex*A##p
+#define KGCVEC(A) int A##n, const gsl_complex*A##p
+
+#define BAD_SIZE 2000
+#define BAD_CODE 2001
+#define MEM      2002
+#define BAD_FILE 2003
+
+
+void no_abort_on_error() {
+    gsl_set_error_handler_off();
+}
+
+
+int toScalarR(int code, KRVEC(x), RVEC(r)) { 
+    REQUIRES(rn==1,BAD_SIZE);
+    DEBUGMSG("toScalarR");
+    KDVVIEW(x);
+    double res;
+    switch(code) {
+        case 0: { res = gsl_blas_dnrm2(V(x)); break; } 
+        case 1: { res = gsl_blas_dasum(V(x));  break; }
+        case 2: { res = gsl_vector_max_index(V(x));  break; }
+        case 3: { res = gsl_vector_max(V(x));  break; }
+        case 4: { res = gsl_vector_min_index(V(x)); break; }
+        case 5: { res = gsl_vector_min(V(x)); break; }
+        default: ERROR(BAD_CODE);
+    }
+    rp[0] = res;
+    OK
+}
+
+
+inline double sign(double x) {
+    if(x>0) {
+        return +1.0;
+    } else if (x<0) {
+        return -1.0;
+    } else {
+        return 0.0;
+    }
+}
+
+
+#define OP(C,F) case C: { for(k=0;k<xn;k++) rp[k] = F(xp[k]); OK }
+#define OPV(C,E) case C: { for(k=0;k<xn;k++) rp[k] = E; OK }
+int mapR(int code, KRVEC(x), RVEC(r)) {
+    int k;
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("mapR");
+    switch (code) {
+        OP(0,sin)
+        OP(1,cos)
+        OP(2,tan)
+        OP(3,fabs)
+        OP(4,asin)
+        OP(5,acos)
+        OP(6,atan) /* atan2 mediante vectorZip */
+        OP(7,sinh)
+        OP(8,cosh)
+        OP(9,tanh)
+        OP(10,asinh)
+        OP(11,acosh)
+        OP(12,atanh)
+        OP(13,exp)
+        OP(14,log)
+        OP(15,sign)
+        OP(16,sqrt)
+        default: ERROR(BAD_CODE);
+    }
+}
+
+int mapCAux(int code, KGCVEC(x), GCVEC(r)) {
+    int k;
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("mapC");
+    switch (code) {
+        OP(0,gsl_complex_sin)
+        OP(1,gsl_complex_cos)
+        OP(2,gsl_complex_tan)
+
+        OP(4,gsl_complex_arcsin)
+        OP(5,gsl_complex_arccos)
+        OP(6,gsl_complex_arctan)
+        OP(7,gsl_complex_sinh)
+        OP(8,gsl_complex_cosh)
+        OP(9,gsl_complex_tanh)
+        OP(10,gsl_complex_arcsinh)
+        OP(11,gsl_complex_arccosh)
+        OP(12,gsl_complex_arctanh)
+        OP(13,gsl_complex_exp)
+        OP(14,gsl_complex_log)
+
+        OP(16,gsl_complex_sqrt)
+
+        // gsl_complex_arg
+        // gsl_complex_abs
+        default: ERROR(BAD_CODE);
+    }
+}
+
+int mapC(int code, KCVEC(x), CVEC(r)) {
+    return mapCAux(code, xn, (gsl_complex*)xp, rn, (gsl_complex*)rp);
+}
+
+
+/*
+int scaleR(double* alpha, KRVEC(x), RVEC(r)) {
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("scaleR");
+    KDVVIEW(x);
+    DVVIEW(r);
+    CHECK( gsl_vector_memcpy(V(r),V(x)) , MEM);
+    int res = gsl_vector_scale(V(r),*alpha);
+    CHECK(res,res);
+    OK
+}
+
+int scaleC(gsl_complex *alpha, KCVEC(x), CVEC(r)) {
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("scaleC");
+    //KCVVIEW(x);
+    CVVIEW(r);
+    gsl_vector_const_view vrx = gsl_vector_const_view_array((double*)xp,xn*2);
+    gsl_vector_view vrr = gsl_vector_view_array((double*)rp,rn*2);
+    CHECK(gsl_vector_memcpy(V(vrr),V(vrx)) , MEM);
+    gsl_blas_zscal(*alpha,V(r)); // void !
+    int res = 0; 
+    CHECK(res,res);
+    OK
+}
+
+int addConstantR(double offs, KRVEC(x), RVEC(r)) { 
+    REQUIRES(xn == rn,BAD_SIZE); 
+    DEBUGMSG("addConstantR");
+    KDVVIEW(x);
+    DVVIEW(r);
+    CHECK(gsl_vector_memcpy(V(r),V(x)), MEM);
+    int res = gsl_vector_add_constant(V(r),offs);
+    CHECK(res,res);
+    OK
+}
+
+*/
+
+
+
+int mapValR(int code, double* pval, KRVEC(x), RVEC(r)) {
+    int k;
+    double val = *pval;
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("mapValR");
+    switch (code) {
+        OPV(0,val*xp[k])
+        OPV(1,val/xp[k])
+        OPV(2,val+xp[k])
+        OPV(3,val-xp[k])
+        OPV(4,pow(val,xp[k]))
+        OPV(5,pow(xp[k],val))
+        default: ERROR(BAD_CODE);
+    }
+}
+
+int mapValCAux(int code, gsl_complex* pval, KGCVEC(x), GCVEC(r)) {
+    int k;
+    gsl_complex val = *pval;
+    REQUIRES(xn == rn,BAD_SIZE);
+    DEBUGMSG("mapValC");
+    switch (code) {
+        OPV(0,gsl_complex_mul(val,xp[k]))
+        OPV(1,gsl_complex_div(val,xp[k]))
+        OPV(2,gsl_complex_add(val,xp[k]))
+        OPV(3,gsl_complex_sub(val,xp[k]))
+        OPV(4,gsl_complex_pow(val,xp[k]))
+        OPV(5,gsl_complex_pow(xp[k],val))
+        default: ERROR(BAD_CODE);
+    }
+}
+
+int mapValC(int code, gsl_complex* val, KCVEC(x), CVEC(r)) {
+    return mapValCAux(code, val, xn, (gsl_complex*)xp, rn, (gsl_complex*)rp);
+}
+
+
+#define OPZE(C,msg,E) case C: {DEBUGMSG(msg) for(k=0;k<an;k++) rp[k] = E(ap[k],bp[k]); OK }
+#define OPZV(C,msg,E) case C: {DEBUGMSG(msg) res = E(V(r),V(b)); CHECK(res,res); OK }
+int zipR(int code, KRVEC(a), KRVEC(b), RVEC(r)) {
+    REQUIRES(an == bn && an == rn, BAD_SIZE);
+    int k;
+    switch(code) {
+        OPZE(4,"zipR Pow",pow)
+        OPZE(5,"zipR ATan2",atan2)
+    }
+    KDVVIEW(a);
+    KDVVIEW(b);
+    DVVIEW(r);
+    gsl_vector_memcpy(V(r),V(a));
+    int res;
+    switch(code) {
+        OPZV(0,"zipR Add",gsl_vector_add)
+        OPZV(1,"zipR Sub",gsl_vector_sub)
+        OPZV(2,"zipR Mul",gsl_vector_mul)
+        OPZV(3,"zipR Div",gsl_vector_div)
+        default: ERROR(BAD_CODE);
+    }
+}
+
+
+int zipCAux(int code, KGCVEC(a), KGCVEC(b), GCVEC(r)) {
+    REQUIRES(an == bn && an == rn, BAD_SIZE);
+    int k;
+    switch(code) {
+        OPZE(0,"zipC Add",gsl_complex_add)
+        OPZE(1,"zipC Sub",gsl_complex_sub)
+        OPZE(2,"zipC Mul",gsl_complex_mul)
+        OPZE(3,"zipC Div",gsl_complex_div)
+        OPZE(4,"zipC Pow",gsl_complex_pow)
+        //OPZE(5,"zipR ATan2",atan2)
+    }
+    //KCVVIEW(a);
+    //KCVVIEW(b);
+    //CVVIEW(r);
+    //gsl_vector_memcpy(V(r),V(a));
+    //int res;
+    switch(code) {
+        default: ERROR(BAD_CODE);
+    }
+}
+
+
+int zipC(int code, KCVEC(a), KCVEC(b), CVEC(r)) {
+    return zipCAux(code, an, (gsl_complex*)ap, bn, (gsl_complex*)bp, rn, (gsl_complex*)rp);
+}
+
+
+
+
+int luSolveR(KRMAT(a),KRMAT(b),RMAT(r)) {
+    REQUIRES(ar==ac && ac==br && ar==rr && bc==rc,BAD_SIZE);
+    DEBUGMSG("luSolveR");
+    KDMVIEW(a);
+    KDMVIEW(b);
+    DMVIEW(r);
+    int res;
+    gsl_matrix *LU = gsl_matrix_alloc(ar,ar);
+    CHECK(!LU,MEM);
+    int s;
+    gsl_permutation * p = gsl_permutation_alloc (ar);
+    CHECK(!p,MEM);
+    CHECK(gsl_matrix_memcpy(LU,M(a)),MEM);
+    res = gsl_linalg_LU_decomp(LU, p, &s);
+    CHECK(res,res);
+    int c;
+
+    for (c=0; c<bc; c++) {
+        gsl_vector_const_view colb = gsl_matrix_const_column (M(b), c);
+        gsl_vector_view colr = gsl_matrix_column (M(r), c);
+        res = gsl_linalg_LU_solve (LU, p, V(colb), V(colr));
+        CHECK(res,res);
+    }
+    gsl_permutation_free(p);
+    gsl_matrix_free(LU);
+    OK
+}
+
+
+int luSolveC(KCMAT(a),KCMAT(b),CMAT(r)) {
+    REQUIRES(ar==ac && ac==br && ar==rr && bc==rc,BAD_SIZE);
+    DEBUGMSG("luSolveC");
+    KCMVIEW(a);
+    KCMVIEW(b);
+    CMVIEW(r);
+    gsl_matrix_complex *LU = gsl_matrix_complex_alloc(ar,ar);
+    CHECK(!LU,MEM);
+    int s;
+    gsl_permutation * p = gsl_permutation_alloc (ar);
+    CHECK(!p,MEM);
+    CHECK(gsl_matrix_complex_memcpy(LU,M(a)),MEM);
+    int res;
+    res = gsl_linalg_complex_LU_decomp(LU, p, &s);
+    CHECK(res,res);
+    int c;
+    for (c=0; c<bc; c++) {
+        gsl_vector_complex_const_view colb = gsl_matrix_complex_const_column (M(b), c);
+        gsl_vector_complex_view colr = gsl_matrix_complex_column (M(r), c);
+        res = gsl_linalg_complex_LU_solve (LU, p, V(colb), V(colr));
+        CHECK(res,res);
+    }
+    gsl_permutation_free(p);
+    gsl_matrix_complex_free(LU);
+    OK
+}
+
+
+int luRaux(KRMAT(a),RVEC(b)) {
+    REQUIRES(ar==ac && bn==ar*ar+ar+1,BAD_SIZE);
+    DEBUGMSG("luRaux");
+    KDMVIEW(a);
+    //DVVIEW(b);
+    gsl_matrix_view LU = gsl_matrix_view_array(bp,ar,ac);
+    int s;
+    gsl_permutation * p = gsl_permutation_alloc (ar);
+    CHECK(!p,MEM);
+    CHECK(gsl_matrix_memcpy(M(LU),M(a)),MEM);
+    gsl_linalg_LU_decomp(M(LU), p, &s);
+    bp[ar*ar] = s;
+    int k;
+    for (k=0; k<ar; k++) {
+        bp[ar*ar+k+1] = gsl_permutation_get(p,k);
+    }
+    gsl_permutation_free(p);
+    OK
+}
+
+int luCaux(KCMAT(a),CVEC(b)) {
+    REQUIRES(ar==ac && bn==ar*ar+ar+1,BAD_SIZE);
+    DEBUGMSG("luCaux");
+    KCMVIEW(a);
+    //DVVIEW(b);
+    gsl_matrix_complex_view LU = gsl_matrix_complex_view_array((double*)bp,ar,ac);
+    int s;
+    gsl_permutation * p = gsl_permutation_alloc (ar);
+    CHECK(!p,MEM);
+    CHECK(gsl_matrix_complex_memcpy(M(LU),M(a)),MEM);
+    int res;
+    res = gsl_linalg_complex_LU_decomp(M(LU), p, &s);
+    CHECK(res,res);
+    ((double*)bp)[2*ar*ar] = s;
+    ((double*)bp)[2*ar*ar+1] = 0;
+    int k;
+    for (k=0; k<ar; k++) {
+        ((double*)bp)[2*ar*ar+2*k+2] = gsl_permutation_get(p,k);
+        ((double*)bp)[2*ar*ar+2*k+2+1] = 0;
+    }
+    gsl_permutation_free(p);
+    OK
+}
+
+int svd(KRMAT(a),RMAT(u), RVEC(s),RMAT(v)) {
+    REQUIRES(ar==ur && ac==uc && ac==sn && ac==vr && ac==vc,BAD_SIZE);
+    DEBUGMSG("svd");
+    KDMVIEW(a);
+    DMVIEW(u);
+    DVVIEW(s);
+    DMVIEW(v);
+    gsl_vector  *workv = gsl_vector_alloc(ac);
+    CHECK(!workv,MEM);
+    gsl_matrix  *workm = gsl_matrix_alloc(ac,ac);
+    CHECK(!workm,MEM);
+    CHECK(gsl_matrix_memcpy(M(u),M(a)),MEM);
+    // int res = gsl_linalg_SV_decomp_jacobi (&U.matrix, &V.matrix, &S.vector);
+    // doesn't work 
+    //int res = gsl_linalg_SV_decomp (&U.matrix, &V.matrix, &S.vector, workv);
+    int res = gsl_linalg_SV_decomp_mod (M(u), workm, M(v), V(s), workv);
+    CHECK(res,res);
+    //gsl_matrix_transpose(M(v));
+    gsl_vector_free(workv);
+    gsl_matrix_free(workm);
+    OK
+}
+
+
+// for real symmetric matrices
+int eigensystemR(KRMAT(x),RVEC(l),RMAT(v)) {
+    REQUIRES(xr==xc && xr==ln && xr==vr && vr==vc,BAD_SIZE);
+    DEBUGMSG("eigensystemR (gsl_eigen_symmv)");
+    KDMVIEW(x);
+    DVVIEW(l);
+    DMVIEW(v);
+    gsl_matrix *XC = gsl_matrix_alloc(xr,xr);
+    gsl_matrix_memcpy(XC,M(x)); // needed because the argument is destroyed
+                                // many thanks to Nico Mahlo for the bug report 
+    gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (xc);
+    int res = gsl_eigen_symmv (XC, V(l), M(v), w);
+    CHECK(res,res);
+    gsl_eigen_symmv_free (w);
+    gsl_matrix_free(XC);
+    gsl_eigen_symmv_sort (V(l), M(v), GSL_EIGEN_SORT_ABS_DESC);
+    OK
+}
+
+// for hermitian matrices
+int eigensystemC(KCMAT(x),RVEC(l),CMAT(v)) {
+    REQUIRES(xr==xc && xr==ln && xr==vr && vr==vc,BAD_SIZE);
+    DEBUGMSG("eigensystemC");
+    KCMVIEW(x);
+    DVVIEW(l);
+    CMVIEW(v);
+    gsl_matrix_complex *XC = gsl_matrix_complex_alloc(xr,xr);
+    gsl_matrix_complex_memcpy(XC,M(x)); // again needed because the argument is destroyed
+    gsl_eigen_hermv_workspace * w = gsl_eigen_hermv_alloc (xc);
+    int res = gsl_eigen_hermv (XC, V(l), M(v), w);
+    CHECK(res,res);
+    gsl_eigen_hermv_free (w);
+    gsl_matrix_complex_free(XC);
+    gsl_eigen_hermv_sort (V(l), M(v), GSL_EIGEN_SORT_ABS_DESC);
+    OK
+}
+
+int QR(KRMAT(x),RMAT(q),RMAT(r)) {
+    REQUIRES(xr==rr && xc==rc && qr==qc && xr==qr,BAD_SIZE);
+    DEBUGMSG("QR");
+    KDMVIEW(x);
+    DMVIEW(q);
+    DMVIEW(r);
+    gsl_matrix * a = gsl_matrix_alloc(xr,xc);
+    gsl_vector * tau = gsl_vector_alloc(MIN(xr,xc));
+    gsl_matrix_memcpy(a,M(x));
+    int res = gsl_linalg_QR_decomp(a,tau);
+    CHECK(res,res);
+    gsl_linalg_QR_unpack(a,tau,M(q),M(r));
+    gsl_vector_free(tau);
+    gsl_matrix_free(a);
+    OK
+}
+
+int cholR(KRMAT(x),RMAT(l)) {
+    REQUIRES(xr==xc && lr==xr && lr==lc,BAD_SIZE);
+    DEBUGMSG("cholR");
+    KDMVIEW(x);
+    DMVIEW(l);
+    gsl_matrix_memcpy(M(l),M(x));
+    int res = gsl_linalg_cholesky_decomp(M(l));
+    CHECK(res,res);
+    int r,c;
+    for (r=0; r<xr-1; r++) {
+        for(c=r+1; c<xc; c++) {
+            lp[r*lc+c] = 0.;
+        }
+    }
+    OK
+}
+
+int cholC(KCMAT(x),CMAT(l)) {
+    REQUIRES(xr==xc && lr==xr && lr==lc,BAD_SIZE);
+    DEBUGMSG("cholC");
+    KCMVIEW(x);
+    CMVIEW(l);
+    gsl_matrix_complex_memcpy(M(l),M(x));
+    int res = 0; // gsl_linalg_complex_cholesky_decomp(M(l));
+    CHECK(res,res);
+    gsl_complex zero = {0.,0.};
+    int r,c;
+    for (r=0; r<xr-1; r++) {
+        for(c=r+1; c<xc; c++) {
+            lp[r*lc+c] = zero;
+        }
+    }
+    OK
+}
+
+int fft(int code, KCVEC(X), CVEC(R)) {
+    REQUIRES(Xn == Rn,BAD_SIZE);
+    DEBUGMSG("fft");
+    int s = Xn;
+    gsl_fft_complex_wavetable * wavetable = gsl_fft_complex_wavetable_alloc (s);
+    gsl_fft_complex_workspace * workspace = gsl_fft_complex_workspace_alloc (s);
+    gsl_vector_const_view X = gsl_vector_const_view_array((double*)Xp, 2*Xn);
+    gsl_vector_view R = gsl_vector_view_array((double*)Rp, 2*Rn);
+    gsl_blas_dcopy(&X.vector,&R.vector);
+    if(code==0) {
+        gsl_fft_complex_forward ((double*)Rp, 1, s, wavetable, workspace);
+    } else {
+        gsl_fft_complex_inverse ((double*)Rp, 1, s, wavetable, workspace);
+    }
+    gsl_fft_complex_wavetable_free (wavetable);
+    gsl_fft_complex_workspace_free (workspace);
+    OK
+}
+
+
+int integrate_qng(double f(double, void*), double a, double b, double prec,
+                   double *result, double*error) {
+    DEBUGMSG("integrate_qng");
+    gsl_function F;
+    F.function = f;
+    F.params = NULL;
+    size_t neval;
+    int res = gsl_integration_qng (&F, a,b, 0, prec, result, error, &neval); 
+    CHECK(res,res);
+    OK
+}
+
+int integrate_qags(double f(double,void*), double a, double b, double prec, int w, 
+               double *result, double* error) {
+    DEBUGMSG("integrate_qags");
+    gsl_integration_workspace * wk = gsl_integration_workspace_alloc (w);
+    gsl_function F;
+    F.function = f;
+    F.params = NULL;
+    int res = gsl_integration_qags (&F, a,b, 0, prec, w,wk, result, error); 
+    CHECK(res,res);
+    gsl_integration_workspace_free (wk); 
+    OK
+}
+
+int polySolve(KRVEC(a), CVEC(z)) {
+    DEBUGMSG("polySolve");
+    REQUIRES(an>1,BAD_SIZE);
+    gsl_poly_complex_workspace * w = gsl_poly_complex_workspace_alloc (an);
+    int res = gsl_poly_complex_solve ((double*)ap, an, w, (double*)zp);
+    CHECK(res,res);
+    gsl_poly_complex_workspace_free (w);
+    OK;
+}
+
+int matrix_fscanf(char*filename, RMAT(a)) {
+    DEBUGMSG("gsl_matrix_fscanf");
+    //printf(filename); printf("\n");
+    DMVIEW(a);
+    FILE * f = fopen(filename,"r");
+    CHECK(!f,BAD_FILE);
+    int res = gsl_matrix_fscanf(f, M(a));
+    CHECK(res,res);
+    fclose (f);
+    OK
+}
+
+//---------------------------------------------------------------
+
+typedef double Trawfun(int, double*);
+
+double only_f_aux_min(const gsl_vector*x, void *pars) {
+    Trawfun * f = (Trawfun*) pars;  
+    double* p = (double*)calloc(x->size,sizeof(double));
+    int k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }  
+    double res = f(x->size,p);
+    free(p);
+    return res;
+}
+
+// this version returns info about intermediate steps
+int minimize(double f(int, double*), double tolsize, int maxit, 
+                 KRVEC(xi), KRVEC(sz), RMAT(sol)) {
+    REQUIRES(xin==szn && solr == maxit && solc == 3+xin,BAD_SIZE);
+    DEBUGMSG("minimizeList (nmsimplex)");
+    gsl_multimin_function my_func;
+    // extract function from pars
+    my_func.f = only_f_aux_min;
+    my_func.n = xin; 
+    my_func.params = f;
+    size_t iter = 0;
+    int status;
+    double size;
+    const gsl_multimin_fminimizer_type *T;
+    gsl_multimin_fminimizer *s = NULL;
+    // Initial vertex size vector 
+    KDVVIEW(sz);
+    // Starting point
+    KDVVIEW(xi);
+    // Minimizer nmsimplex, without derivatives
+    T = gsl_multimin_fminimizer_nmsimplex;
+    s = gsl_multimin_fminimizer_alloc (T, my_func.n);
+    gsl_multimin_fminimizer_set (s, &my_func, V(xi), V(sz));
+    do {
+        status = gsl_multimin_fminimizer_iterate (s);
+        size = gsl_multimin_fminimizer_size (s);
+
+        solp[iter*solc+0] = iter;
+        solp[iter*solc+1] = s->fval;
+        solp[iter*solc+2] = size;
+
+        int k;
+        for(k=0;k<xin;k++) {
+            solp[iter*solc+k+3] = gsl_vector_get(s->x,k);
+        }
+        status = gsl_multimin_test_size (size, tolsize);
+        iter++;
+    } while (status == GSL_CONTINUE && iter < maxit);
+    int i,j;
+    for (i=iter; i<solr; i++) {
+        solp[i*solc+0] = iter;
+        for(j=1;j<solc;j++) {
+            solp[i*solc+j]=0.;
+        }
+    }
+    gsl_multimin_fminimizer_free(s);
+    OK
+}
+
+// working with the gradient
+
+typedef struct {double (*f)(int, double*); void (*df)(int, double*, double*);} Tfdf;
+
+double f_aux_min(const gsl_vector*x, void *pars) {
+    Tfdf * fdf = ((Tfdf*) pars);
+    double* p = (double*)calloc(x->size,sizeof(double));
+    int k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }
+    double res = fdf->f(x->size,p);
+    free(p);
+    return res;
+}
+
+
+void df_aux_min(const gsl_vector * x, void * pars, gsl_vector * g) {
+    Tfdf * fdf = ((Tfdf*) pars);  
+    double* p = (double*)calloc(x->size,sizeof(double));
+    double* q = (double*)calloc(x->size,sizeof(double));
+    int k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }
+
+    fdf->df(x->size,p,q);
+
+    for(k=0;k<x->size;k++) {
+        gsl_vector_set(g,k,q[k]);
+    }
+    free(p);
+    free(q);
+}
+
+void fdf_aux_min(const gsl_vector * x, void * pars, double * f, gsl_vector * g) {
+    *f = f_aux_min(x,pars);
+    df_aux_min(x,pars,g);
+}
+
+// conjugate gradient
+int minimizeWithDeriv(double f(int, double*), void df(int, double*, double*), 
+                      double initstep, double minimpar, double tolgrad, int maxit, 
+                      KRVEC(xi), RMAT(sol)) {
+    REQUIRES(solr == maxit && solc == 2+xin,BAD_SIZE);
+    DEBUGMSG("minimizeWithDeriv (conjugate_fr)");
+    gsl_multimin_function_fdf my_func;
+    // extract function from pars
+    my_func.f = f_aux_min;
+    my_func.df = df_aux_min;
+    my_func.fdf = fdf_aux_min;
+    my_func.n = xin; 
+    Tfdf stfdf;
+    stfdf.f = f;
+    stfdf.df = df;
+    my_func.params = &stfdf;
+    size_t iter = 0;
+    int status;
+    const gsl_multimin_fdfminimizer_type *T;
+    gsl_multimin_fdfminimizer *s = NULL;
+    // Starting point
+    KDVVIEW(xi);
+    // conjugate gradient fr
+    T = gsl_multimin_fdfminimizer_conjugate_fr;
+    s = gsl_multimin_fdfminimizer_alloc (T, my_func.n);
+    gsl_multimin_fdfminimizer_set (s, &my_func, V(xi), initstep, minimpar);
+    do {
+        status = gsl_multimin_fdfminimizer_iterate (s);
+        solp[iter*solc+0] = iter;
+        solp[iter*solc+1] = s->f;
+        int k;
+        for(k=0;k<xin;k++) {
+            solp[iter*solc+k+2] = gsl_vector_get(s->x,k);
+        }
+        status = gsl_multimin_test_gradient (s->gradient, tolgrad);
+        iter++;
+    } while (status == GSL_CONTINUE && iter < maxit);
+    int i,j;
+    for (i=iter; i<solr; i++) {
+        solp[i*solc+0] = iter;
+        for(j=1;j<solc;j++) {
+            solp[i*solc+j]=0.;
+        }
+    }
+    gsl_multimin_fdfminimizer_free(s);
+    OK
+}
+
+
+int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr)
+{
+    gsl_function F;
+    F.function = f;
+    F.params = 0;
+
+    if(code==0) return gsl_deriv_central (&F, x, h, result, abserr);
+
+    if(code==1) return gsl_deriv_forward (&F, x, h, result, abserr);
+
+    if(code==2) return gsl_deriv_backward (&F, x, h, result, abserr);
+
+    return 0;
+}
diff --git a/lib/Numeric/GSL/gsl-aux.h b/lib/Numeric/GSL/gsl-aux.h
new file mode 100644
index 0000000..3ccac25
--- /dev/null
+++ b/lib/Numeric/GSL/gsl-aux.h
@@ -0,0 +1,62 @@
+#include <gsl/gsl_complex.h>
+
+#define RVEC(A) int A##n, double*A##p
+#define RMAT(A) int A##r, int A##c, double* A##p
+#define KRVEC(A) int A##n, const double*A##p
+#define KRMAT(A) int A##r, int A##c, const double* A##p
+
+#define CVEC(A) int A##n, gsl_complex*A##p
+#define CMAT(A) int A##r, int A##c, gsl_complex* A##p
+#define KCVEC(A) int A##n, const gsl_complex*A##p
+#define KCMAT(A) int A##r, int A##c, const gsl_complex* A##p
+
+void no_abort_on_error();
+
+int toScalarR(int code, KRVEC(x), RVEC(r));
+/* norm2, absdif, maximum, posmax, etc. */
+
+int mapR(int code, KRVEC(x), RVEC(r));
+int mapC(int code, KCVEC(x), CVEC(r));
+/* sin cos tan etc. */
+
+int mapValR(int code, double*, KRVEC(x), RVEC(r));
+int mapValC(int code, gsl_complex*, KCVEC(x), CVEC(r));
+
+int zipR(int code, KRVEC(a), KRVEC(b), RVEC(r));
+int zipC(int code, KCVEC(a), KCVEC(b), CVEC(r));
+
+
+int luSolveR(KRMAT(a),KRMAT(b),RMAT(r)); 
+int luSolveC(KCMAT(a),KCMAT(b),CMAT(r));
+int luRaux(KRMAT(a),RVEC(b));
+int luCaux(KCMAT(a),CVEC(b));
+
+int svd(KRMAT(x),RMAT(u), RVEC(s),RMAT(v));
+
+int eigensystemR(KRMAT(x),RVEC(l),RMAT(v));
+int eigensystemC(KCMAT(x),RVEC(l),CMAT(v));
+
+int QR(KRMAT(x),RMAT(q),RMAT(r));
+
+int cholR(KRMAT(x),RMAT(l));
+
+int cholC(KCMAT(x),CMAT(l));
+
+int fft(int code, KCVEC(a), CVEC(b));
+
+int integrate_qng(double f(double, void*), double a, double b, double prec,
+                   double *result, double*error);
+
+int integrate_qags(double f(double,void*), double a, double b, double prec, int w, 
+               double *result, double* error);
+
+int polySolve(KRVEC(a), CVEC(z));
+
+int minimize(double f(int, double*), double tolsize, int maxit, 
+                 KRVEC(xi), KRVEC(sz), RMAT(sol));
+
+int minimizeWithDeriv(double f(int, double*), void df(int, double*, double*),
+                      double initstep, double minimpar, double tolgrad, int maxit, 
+                      KRVEC(xi), RMAT(sol));
+
+int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr);