diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,2 @@
+Copyright Alberto Ruiz 2010
+GPL license
diff --git a/Setup.lhs b/Setup.lhs
new file mode 100644
--- /dev/null
+++ b/Setup.lhs
@@ -0,0 +1,4 @@
+#! /usr/bin/env runhaskell
+
+> import Distribution.Simple
+> main = defaultMain
diff --git a/hmatrix-special.cabal b/hmatrix-special.cabal
new file mode 100644
--- /dev/null
+++ b/hmatrix-special.cabal
@@ -0,0 +1,74 @@
+Name:               hmatrix-special
+Version:            0.1.0
+License:            GPL
+License-file:       LICENSE
+Author:             Alberto Ruiz
+Maintainer:         Alberto Ruiz <aruiz@um.es>
+Stability:          experimental
+Homepage:           http://code.haskell.org/hmatrix
+Synopsis:           Interface to GSL special functions
+Description:
+ Interface to GSL special functions.
+
+Category:           Math
+tested-with:        GHC ==6.10.4
+
+cabal-version:      >=1.2
+build-type:         Simple
+
+extra-source-files: lib/Numeric/GSL/Special/auto.hs,
+                    lib/Numeric/GSL/Special/autoall.sh,
+                    lib/Numeric/GSL/Special/replace.hs
+
+flag safe-cheap
+    description:    use slower non-blocking "safe" foreign calls
+                    to GSL special functions.
+    default:        False
+
+library
+    Build-Depends:  base >= 3 && < 5, hmatrix >= 0.9
+
+    Extensions:     ForeignFunctionInterface,
+                    CPP
+
+    hs-source-dirs:     lib
+
+    Exposed-modules:    Numeric.GSL.Special,
+                        Numeric.GSL.Special.Gamma,
+                        Numeric.GSL.Special.Erf,
+                        Numeric.GSL.Special.Airy,
+                        Numeric.GSL.Special.Exp,
+                        Numeric.GSL.Special.Bessel,
+                        Numeric.GSL.Special.Clausen,
+                        Numeric.GSL.Special.Coulomb,
+                        Numeric.GSL.Special.Coupling,
+                        Numeric.GSL.Special.Dawson,
+                        Numeric.GSL.Special.Debye,
+                        Numeric.GSL.Special.Dilog,
+                        Numeric.GSL.Special.Elementary,
+                        Numeric.GSL.Special.Ellint,
+                        Numeric.GSL.Special.Elljac,
+                        Numeric.GSL.Special.Expint,
+                        Numeric.GSL.Special.Fermi_dirac,
+                        Numeric.GSL.Special.Gegenbauer,
+                        Numeric.GSL.Special.Hyperg,
+                        Numeric.GSL.Special.Laguerre,
+                        Numeric.GSL.Special.Lambert,
+                        Numeric.GSL.Special.Legendre,
+                        Numeric.GSL.Special.Log,
+                        Numeric.GSL.Special.Pow_int,
+                        Numeric.GSL.Special.Psi,
+                        Numeric.GSL.Special.Synchrotron,
+                        Numeric.GSL.Special.Transport,
+                        Numeric.GSL.Special.Trig,
+                        Numeric.GSL.Special.Zeta
+
+    other-modules:      Numeric.GSL.Special.Internal
+
+    ghc-options:        -Wall -fno-warn-unused-binds
+
+    if flag(safe-cheap)
+        cpp-options: -DSAFE_CHEAP=safe
+    else
+        cpp-options: -DSAFE_CHEAP=unsafe
+
diff --git a/lib/Numeric/GSL/Special.hs b/lib/Numeric/GSL/Special.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special.hs
@@ -0,0 +1,76 @@
+-----------------------------------------------------------------------------
+{- |
+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.Elljac
+, 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.Transport
+, module Numeric.GSL.Special.Trig
+, module Numeric.GSL.Special.Zeta
+)
+where
+
+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.Elljac
+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.Transport
+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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Airy.hs
@@ -0,0 +1,141 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Airy
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_airy.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Airy(
+  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
+, Precision(..)
+) where
+
+import Foreign(Ptr)
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Ai :: Double -> Precision -> Double
+airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Bi :: Double -> Precision -> Double
+airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Ai_scaled :: Double -> Precision -> Double
+airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Bi_scaled :: Double -> Precision -> Double
+airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Ai_deriv :: Double -> Precision -> Double
+airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+airy_Bi_deriv :: Double -> Precision -> Double
+airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
+
+airy_zero_Ai_e :: CInt -> (Double,Double)
+airy_zero_Ai_e s = createSFR "airy_zero_Ai_e" $ gsl_sf_airy_zero_Ai_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt
+
+airy_zero_Ai :: CInt -> Double
+airy_zero_Ai = gsl_sf_airy_zero_Ai
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double
+
+airy_zero_Bi_e :: CInt -> (Double,Double)
+airy_zero_Bi_e s = createSFR "airy_zero_Bi_e" $ gsl_sf_airy_zero_Bi_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt
+
+airy_zero_Bi :: CInt -> Double
+airy_zero_Bi = gsl_sf_airy_zero_Bi
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double
+
+airy_zero_Ai_deriv_e :: CInt -> (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 SAFE_CHEAP "gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt
+
+airy_zero_Ai_deriv :: CInt -> Double
+airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double
+
+airy_zero_Bi_deriv_e :: CInt -> (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 SAFE_CHEAP "gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt
+
+airy_zero_Bi_deriv :: CInt -> Double
+airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Bessel.hs b/lib/Numeric/GSL/Special/Bessel.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Bessel.hs
@@ -0,0 +1,508 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Bessel
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+bessel_J0_e :: Double -> (Double,Double)
+bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt
+
+bessel_J0 :: Double -> Double
+bessel_J0 = gsl_sf_bessel_J0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
+
+bessel_J1_e :: Double -> (Double,Double)
+bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt
+
+bessel_J1 :: Double -> Double
+bessel_J1 = gsl_sf_bessel_J1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
+
+bessel_Jn_e :: CInt -> Double -> (Double,Double)
+bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_Jn :: CInt -> Double -> Double
+bessel_Jn = gsl_sf_bessel_Jn
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double
+
+bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_Jn_array = gsl_sf_bessel_Jn_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+bessel_Y0_e :: Double -> (Double,Double)
+bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt
+
+bessel_Y0 :: Double -> Double
+bessel_Y0 = gsl_sf_bessel_Y0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
+
+bessel_Y1_e :: Double -> (Double,Double)
+bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt
+
+bessel_Y1 :: Double -> Double
+bessel_Y1 = gsl_sf_bessel_Y1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
+
+bessel_Yn_e :: CInt -> Double -> (Double,Double)
+bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_Yn :: CInt -> Double -> Double
+bessel_Yn = gsl_sf_bessel_Yn
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double
+
+bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_Yn_array = gsl_sf_bessel_Yn_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+bessel_I0_e :: Double -> (Double,Double)
+bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt
+
+bessel_I0 :: Double -> Double
+bessel_I0 = gsl_sf_bessel_I0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
+
+bessel_I1_e :: Double -> (Double,Double)
+bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt
+
+bessel_I1 :: Double -> Double
+bessel_I1 = gsl_sf_bessel_I1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
+
+bessel_In_e :: CInt -> Double -> (Double,Double)
+bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_In :: CInt -> Double -> Double
+bessel_In = gsl_sf_bessel_In
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double
+
+bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_In_array = gsl_sf_bessel_In_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_I0_scaled :: Double -> Double
+bessel_I0_scaled = gsl_sf_bessel_I0_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_I1_scaled :: Double -> Double
+bessel_I1_scaled = gsl_sf_bessel_I1_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
+
+bessel_In_scaled_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_In_scaled :: CInt -> Double -> Double
+bessel_In_scaled = gsl_sf_bessel_In_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double
+
+bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+bessel_K0_e :: Double -> (Double,Double)
+bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt
+
+bessel_K0 :: Double -> Double
+bessel_K0 = gsl_sf_bessel_K0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
+
+bessel_K1_e :: Double -> (Double,Double)
+bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt
+
+bessel_K1 :: Double -> Double
+bessel_K1 = gsl_sf_bessel_K1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
+
+bessel_Kn_e :: CInt -> Double -> (Double,Double)
+bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_Kn :: CInt -> Double -> Double
+bessel_Kn = gsl_sf_bessel_Kn
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double
+
+bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_Kn_array = gsl_sf_bessel_Kn_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_K0_scaled :: Double -> Double
+bessel_K0_scaled = gsl_sf_bessel_K0_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_K1_scaled :: Double -> Double
+bessel_K1_scaled = gsl_sf_bessel_K1_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
+
+bessel_Kn_scaled_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_Kn_scaled :: CInt -> Double -> Double
+bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double
+
+bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+bessel_j0_e :: Double -> (Double,Double)
+bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt
+
+bessel_j0 :: Double -> Double
+bessel_j0 = gsl_sf_bessel_j0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
+
+bessel_j1_e :: Double -> (Double,Double)
+bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt
+
+bessel_j1 :: Double -> Double
+bessel_j1 = gsl_sf_bessel_j1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
+
+bessel_j2_e :: Double -> (Double,Double)
+bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt
+
+bessel_j2 :: Double -> Double
+bessel_j2 = gsl_sf_bessel_j2
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
+
+bessel_jl_e :: CInt -> Double -> (Double,Double)
+bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_jl :: CInt -> Double -> Double
+bessel_jl = gsl_sf_bessel_jl
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double
+
+bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
+bessel_jl_array = gsl_sf_bessel_jl_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
+
+bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
+bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
+
+bessel_y0_e :: Double -> (Double,Double)
+bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt
+
+bessel_y0 :: Double -> Double
+bessel_y0 = gsl_sf_bessel_y0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
+
+bessel_y1_e :: Double -> (Double,Double)
+bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt
+
+bessel_y1 :: Double -> Double
+bessel_y1 = gsl_sf_bessel_y1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
+
+bessel_y2_e :: Double -> (Double,Double)
+bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt
+
+bessel_y2 :: Double -> Double
+bessel_y2 = gsl_sf_bessel_y2
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
+
+bessel_yl_e :: CInt -> Double -> (Double,Double)
+bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_yl :: CInt -> Double -> Double
+bessel_yl = gsl_sf_bessel_yl
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double
+
+bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
+bessel_yl_array = gsl_sf_bessel_yl_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_i0_scaled :: Double -> Double
+bessel_i0_scaled = gsl_sf_bessel_i0_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_i1_scaled :: Double -> Double
+bessel_i1_scaled = gsl_sf_bessel_i1_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_i2_scaled :: Double -> Double
+bessel_i2_scaled = gsl_sf_bessel_i2_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
+
+bessel_il_scaled_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_il_scaled :: CInt -> Double -> Double
+bessel_il_scaled = gsl_sf_bessel_il_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double
+
+bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_k0_scaled :: Double -> Double
+bessel_k0_scaled = gsl_sf_bessel_k0_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_k1_scaled :: Double -> Double
+bessel_k1_scaled = gsl_sf_bessel_k1_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt
+
+bessel_k2_scaled :: Double -> Double
+bessel_k2_scaled = gsl_sf_bessel_k2_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
+
+bessel_kl_scaled_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+bessel_kl_scaled :: CInt -> Double -> Double
+bessel_kl_scaled = gsl_sf_bessel_kl_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double
+
+bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Jnu :: Double -> Double -> Double
+bessel_Jnu = gsl_sf_bessel_Jnu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Ynu :: Double -> Double -> Double
+bessel_Ynu = gsl_sf_bessel_Ynu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
+
+bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> CInt
+bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Inu_scaled :: Double -> Double -> Double
+bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Inu :: Double -> Double -> Double
+bessel_Inu = gsl_sf_bessel_Inu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Knu_scaled :: Double -> Double -> Double
+bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_Knu :: Double -> Double -> Double
+bessel_Knu = gsl_sf_bessel_Knu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt
+
+bessel_lnKnu :: Double -> Double -> Double
+bessel_lnKnu = gsl_sf_bessel_lnKnu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
+
+bessel_zero_J0_e :: CInt -> (Double,Double)
+bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt
+
+bessel_zero_J0 :: CInt -> Double
+bessel_zero_J0 = gsl_sf_bessel_zero_J0
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double
+
+bessel_zero_J1_e :: CInt -> (Double,Double)
+bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt
+
+bessel_zero_J1 :: CInt -> Double
+bessel_zero_J1 = gsl_sf_bessel_zero_J1
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double
+
+bessel_zero_Jnu_e :: Double -> CInt -> (Double,Double)
+bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt
+
+bessel_zero_Jnu :: Double -> CInt -> Double
+bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Clausen.hs b/lib/Numeric/GSL/Special/Clausen.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Clausen.hs
@@ -0,0 +1,30 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Clausen
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+clausen_e :: Double -> (Double,Double)
+clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt
+
+clausen :: Double -> Double
+clausen = gsl_sf_clausen
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Coulomb.hs
@@ -0,0 +1,69 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Coulomb
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt
+
+hydrogenicR_1 :: Double -> Double -> Double
+hydrogenicR_1 = gsl_sf_hydrogenicR_1
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
+
+hydrogenicR_e :: CInt -> CInt -> Double -> Double -> (Double,Double)
+hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt
+
+hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
+hydrogenicR = gsl_sf_hydrogenicR
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
+
+coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
+coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
+
+coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+
+coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+
+coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+
+coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+
+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 SAFE_CHEAP "gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt
+
+coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
+coulomb_CL_array = gsl_sf_coulomb_CL_array
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Coupling.hs b/lib/Numeric/GSL/Special/Coupling.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Coupling.hs
@@ -0,0 +1,68 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Coupling
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_coupling.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+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
+) where
+
+import Foreign(Ptr)
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (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 SAFE_CHEAP "gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+
+coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+coupling_3j = gsl_sf_coupling_3j
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+
+coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (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 SAFE_CHEAP "gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+
+coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+coupling_6j = gsl_sf_coupling_6j
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+
+coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (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 SAFE_CHEAP "gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+
+coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+coupling_RacahW = gsl_sf_coupling_RacahW
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+
+coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (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 SAFE_CHEAP "gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+
+coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+coupling_9j = gsl_sf_coupling_9j
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+
+coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (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 SAFE_CHEAP "gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+
+coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Dawson.hs b/lib/Numeric/GSL/Special/Dawson.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Dawson.hs
@@ -0,0 +1,30 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Dawson
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+dawson_e :: Double -> (Double,Double)
+dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt
+
+dawson :: Double -> Double
+dawson = gsl_sf_dawson
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Debye.hs
@@ -0,0 +1,80 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Debye
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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
+, debye_5_e
+, debye_5
+, debye_6_e
+, debye_6
+) where
+
+import Foreign(Ptr)
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+debye_1_e :: Double -> (Double,Double)
+debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt
+
+debye_1 :: Double -> Double
+debye_1 = gsl_sf_debye_1
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
+
+debye_2_e :: Double -> (Double,Double)
+debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt
+
+debye_2 :: Double -> Double
+debye_2 = gsl_sf_debye_2
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
+
+debye_3_e :: Double -> (Double,Double)
+debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt
+
+debye_3 :: Double -> Double
+debye_3 = gsl_sf_debye_3
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
+
+debye_4_e :: Double -> (Double,Double)
+debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt
+
+debye_4 :: Double -> Double
+debye_4 = gsl_sf_debye_4
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
+
+debye_5_e :: Double -> (Double,Double)
+debye_5_e x = createSFR "debye_5_e" $ gsl_sf_debye_5_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt
+
+debye_5 :: Double -> Double
+debye_5 = gsl_sf_debye_5
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double
+
+debye_6_e :: Double -> (Double,Double)
+debye_6_e x = createSFR "debye_6_e" $ gsl_sf_debye_6_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt
+
+debye_6 :: Double -> Double
+debye_6 = gsl_sf_debye_6
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_6" gsl_sf_debye_6 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Dilog.hs b/lib/Numeric/GSL/Special/Dilog.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Dilog.hs
@@ -0,0 +1,42 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Dilog
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+dilog_e :: Double -> (Double,Double)
+dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt
+
+dilog :: Double -> Double
+dilog = gsl_sf_dilog
+foreign import ccall SAFE_CHEAP "gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
+
+complex_dilog_xy_e :: Double -> Double -> Ptr () -> (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 SAFE_CHEAP "gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+complex_dilog_e :: Double -> Double -> Ptr () -> (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 SAFE_CHEAP "gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+complex_spence_xy_e :: Double -> Double -> Ptr () -> (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 SAFE_CHEAP "gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Elementary.hs b/lib/Numeric/GSL/Special/Elementary.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Elementary.hs
@@ -0,0 +1,35 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Elementary
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+multiply_e :: Double -> Double -> (Double,Double)
+multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y
+foreign import ccall SAFE_CHEAP "gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt
+
+multiply :: Double -> Double -> Double
+multiply = gsl_sf_multiply
+foreign import ccall SAFE_CHEAP "gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Ellint.hs b/lib/Numeric/GSL/Special/Ellint.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Ellint.hs
@@ -0,0 +1,140 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Ellint
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_Pcomp_e
+, ellint_Pcomp
+, ellint_Dcomp_e
+, ellint_Dcomp
+, 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_Kcomp :: Double -> Precision -> Double
+ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_Ecomp :: Double -> Precision -> Double
+ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
+
+ellint_Pcomp_e :: Double -> Double -> Precision -> (Double,Double)
+ellint_Pcomp_e k n mode = createSFR "ellint_Pcomp_e" $ gsl_sf_ellint_Pcomp_e k n  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_Pcomp :: Double -> Double -> Precision -> Double
+ellint_Pcomp k n mode = gsl_sf_ellint_Pcomp k n  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double
+
+ellint_Dcomp_e :: Double -> Precision -> (Double,Double)
+ellint_Dcomp_e k mode = createSFR "ellint_Dcomp_e" $ gsl_sf_ellint_Dcomp_e k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_Dcomp :: Double -> Precision -> Double
+ellint_Dcomp k mode = gsl_sf_ellint_Dcomp k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_F :: Double -> Double -> Precision -> Double
+ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_E :: Double -> Double -> Precision -> Double
+ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+ellint_RC :: Double -> Double -> Precision -> Double
+ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
+
+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 SAFE_CHEAP "gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
diff --git a/lib/Numeric/GSL/Special/Elljac.hs b/lib/Numeric/GSL/Special/Elljac.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Elljac.hs
@@ -0,0 +1,38 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Elljac
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_elljac.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Elljac(
+elljac_e
+) where
+
+import Foreign
+import Foreign.C.Types(CInt)
+
+elljac_e :: Double -> Double -> (Double,Double,Double)
+elljac_e u m = unsafePerformIO $ do
+    psn <- malloc
+    pcn <- malloc
+    pdn <- malloc
+    res <- gsl_sf_elljac_e u m psn pcn pdn
+    sn <- peek psn
+    cn <- peek pcn
+    dn <- peek pdn
+    free psn
+    free pcn
+    free pdn
+    if res == 0 then return (sn,cn,dn)
+                else error $ "error code "++show res++
+                             " in elljac_e "++show u++" "++show m
+
+foreign import ccall "gsl_sf_elljac_e" gsl_sf_elljac_e :: Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Erf.hs b/lib/Numeric/GSL/Special/Erf.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Erf.hs
@@ -0,0 +1,80 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Erf
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+erfc_e :: Double -> (Double,Double)
+erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt
+
+erfc :: Double -> Double
+erfc = gsl_sf_erfc
+foreign import ccall SAFE_CHEAP "gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
+
+log_erfc_e :: Double -> (Double,Double)
+log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt
+
+log_erfc :: Double -> Double
+log_erfc = gsl_sf_log_erfc
+foreign import ccall SAFE_CHEAP "gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
+
+erf_e :: Double -> (Double,Double)
+erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt
+
+erf :: Double -> Double
+erf = gsl_sf_erf
+foreign import ccall SAFE_CHEAP "gsl_sf_erf" gsl_sf_erf :: Double -> Double
+
+erf_Z_e :: Double -> (Double,Double)
+erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt
+
+erf_Q_e :: Double -> (Double,Double)
+erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt
+
+erf_Z :: Double -> Double
+erf_Z = gsl_sf_erf_Z
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
+
+erf_Q :: Double -> Double
+erf_Q = gsl_sf_erf_Q
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
+
+hazard_e :: Double -> (Double,Double)
+hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt
+
+hazard :: Double -> Double
+hazard = gsl_sf_hazard
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Exp.hs
@@ -0,0 +1,115 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Exp
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_exp.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+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
+-- , exprel_n_CF_e
+, exp_err_e
+, exp_err_e10_e
+, exp_mult_err_e
+, exp_mult_err_e10_e
+) where
+
+import Foreign(Ptr)
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+exp_e :: Double -> (Double,Double)
+exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt
+
+exp :: Double -> Double
+exp = gsl_sf_exp
+foreign import ccall SAFE_CHEAP "gsl_sf_exp" gsl_sf_exp :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt
+
+exp_mult :: Double -> Double -> Double
+exp_mult = gsl_sf_exp_mult
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt
+
+expm1_e :: Double -> (Double,Double)
+expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt
+
+expm1 :: Double -> Double
+expm1 = gsl_sf_expm1
+foreign import ccall SAFE_CHEAP "gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
+
+exprel_e :: Double -> (Double,Double)
+exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt
+
+exprel :: Double -> Double
+exprel = gsl_sf_exprel
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
+
+exprel_2_e :: Double -> (Double,Double)
+exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt
+
+exprel_2 :: Double -> Double
+exprel_2 = gsl_sf_exprel_2
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
+
+exprel_n_e :: CInt -> Double -> (Double,Double)
+exprel_n_e n x = createSFR "exprel_n_e" $ gsl_sf_exprel_n_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt
+
+exprel_n :: CInt -> Double -> Double
+exprel_n = gsl_sf_exprel_n
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double
+
+exprel_n_CF_e :: Double -> Double -> (Double,Double)
+exprel_n_CF_e n x = createSFR "exprel_n_CF_e" $ gsl_sf_exprel_n_CF_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n_CF_e" gsl_sf_exprel_n_CF_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Expint.hs b/lib/Numeric/GSL/Special/Expint.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Expint.hs
@@ -0,0 +1,160 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Expint
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_En_e
+, expint_En
+, expint_E1_scaled_e
+, expint_E1_scaled
+, expint_E2_scaled_e
+, expint_E2_scaled
+, expint_En_scaled_e
+, expint_En_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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+expint_E1_e :: Double -> (Double,Double)
+expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt
+
+expint_E1 :: Double -> Double
+expint_E1 = gsl_sf_expint_E1
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
+
+expint_E2_e :: Double -> (Double,Double)
+expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt
+
+expint_E2 :: Double -> Double
+expint_E2 = gsl_sf_expint_E2
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
+
+expint_En_e :: CInt -> Double -> (Double,Double)
+expint_En_e n x = createSFR "expint_En_e" $ gsl_sf_expint_En_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_e" gsl_sf_expint_En_e :: CInt -> Double -> Ptr () -> IO CInt
+
+expint_En :: CInt -> Double -> Double
+expint_En = gsl_sf_expint_En
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En" gsl_sf_expint_En :: CInt -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt
+
+expint_E1_scaled :: Double -> Double
+expint_E1_scaled = gsl_sf_expint_E1_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt
+
+expint_E2_scaled :: Double -> Double
+expint_E2_scaled = gsl_sf_expint_E2_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
+
+expint_En_scaled_e :: CInt -> Double -> (Double,Double)
+expint_En_scaled_e n x = createSFR "expint_En_scaled_e" $ gsl_sf_expint_En_scaled_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_scaled_e" gsl_sf_expint_En_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+expint_En_scaled :: CInt -> Double -> Double
+expint_En_scaled = gsl_sf_expint_En_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_scaled" gsl_sf_expint_En_scaled :: CInt -> Double -> Double
+
+expint_Ei_e :: Double -> (Double,Double)
+expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt
+
+expint_Ei :: Double -> Double
+expint_Ei = gsl_sf_expint_Ei
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt
+
+expint_Ei_scaled :: Double -> Double
+expint_Ei_scaled = gsl_sf_expint_Ei_scaled
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
+
+shi_e :: Double -> (Double,Double)
+shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt
+
+shi :: Double -> Double
+shi = gsl_sf_Shi
+foreign import ccall SAFE_CHEAP "gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
+
+chi_e :: Double -> (Double,Double)
+chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt
+
+chi :: Double -> Double
+chi = gsl_sf_Chi
+foreign import ccall SAFE_CHEAP "gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
+
+expint_3_e :: Double -> (Double,Double)
+expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt
+
+expint_3 :: Double -> Double
+expint_3 = gsl_sf_expint_3
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
+
+si_e :: Double -> (Double,Double)
+si_e x = createSFR "si_e" $ gsl_sf_Si_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt
+
+si :: Double -> Double
+si = gsl_sf_Si
+foreign import ccall SAFE_CHEAP "gsl_sf_Si" gsl_sf_Si :: Double -> Double
+
+ci_e :: Double -> (Double,Double)
+ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt
+
+ci :: Double -> Double
+ci = gsl_sf_Ci
+foreign import ccall SAFE_CHEAP "gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
+
+atanint_e :: Double -> (Double,Double)
+atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt
+
+atanint :: Double -> Double
+atanint = gsl_sf_atanint
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Fermi_dirac.hs
@@ -0,0 +1,110 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Fermi_dirac
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_m1 :: Double -> Double
+fermi_dirac_m1 = gsl_sf_fermi_dirac_m1
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_0 :: Double -> Double
+fermi_dirac_0 = gsl_sf_fermi_dirac_0
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_1 :: Double -> Double
+fermi_dirac_1 = gsl_sf_fermi_dirac_1
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_2 :: Double -> Double
+fermi_dirac_2 = gsl_sf_fermi_dirac_2
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
+
+fermi_dirac_int_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt
+
+fermi_dirac_int :: CInt -> Double -> Double
+fermi_dirac_int = gsl_sf_fermi_dirac_int
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_mhalf :: Double -> Double
+fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_half :: Double -> Double
+fermi_dirac_half = gsl_sf_fermi_dirac_half
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt
+
+fermi_dirac_3half :: Double -> Double
+fermi_dirac_3half = gsl_sf_fermi_dirac_3half
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt
+
+fermi_dirac_inc_0 :: Double -> Double -> Double
+fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Gamma.hs
@@ -0,0 +1,236 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Gamma
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+lngamma_e :: Double -> (Double,Double)
+lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt
+
+lngamma :: Double -> Double
+lngamma = gsl_sf_lngamma
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
+
+lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
+lngamma_sgn_e = gsl_sf_lngamma_sgn_e
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
+
+gamma_e :: Double -> (Double,Double)
+gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt
+
+gamma :: Double -> Double
+gamma = gsl_sf_gamma
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
+
+gammastar_e :: Double -> (Double,Double)
+gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt
+
+gammastar :: Double -> Double
+gammastar = gsl_sf_gammastar
+foreign import ccall SAFE_CHEAP "gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
+
+gammainv_e :: Double -> (Double,Double)
+gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt
+
+gammainv :: Double -> Double
+gammainv = gsl_sf_gammainv
+foreign import ccall SAFE_CHEAP "gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
+
+lngamma_complex_e :: Double -> Double -> Ptr () -> (Double,Double)
+lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+taylorcoeff_e :: CInt -> Double -> (Double,Double)
+taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt
+
+taylorcoeff :: CInt -> Double -> Double
+taylorcoeff = gsl_sf_taylorcoeff
+foreign import ccall SAFE_CHEAP "gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double
+
+fact_e :: CInt -> (Double,Double)
+fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt
+
+fact :: CInt -> Double
+fact = gsl_sf_fact
+foreign import ccall SAFE_CHEAP "gsl_sf_fact" gsl_sf_fact :: CInt -> Double
+
+doublefact_e :: CInt -> (Double,Double)
+doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt
+
+doublefact :: CInt -> Double
+doublefact = gsl_sf_doublefact
+foreign import ccall SAFE_CHEAP "gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double
+
+lnfact_e :: CInt -> (Double,Double)
+lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt
+
+lnfact :: CInt -> Double
+lnfact = gsl_sf_lnfact
+foreign import ccall SAFE_CHEAP "gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double
+
+lndoublefact_e :: CInt -> (Double,Double)
+lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt
+
+lndoublefact :: CInt -> Double
+lndoublefact = gsl_sf_lndoublefact
+foreign import ccall SAFE_CHEAP "gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double
+
+lnchoose_e :: CInt -> CInt -> (Double,Double)
+lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m
+foreign import ccall SAFE_CHEAP "gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt
+
+lnchoose :: CInt -> CInt -> Double
+lnchoose = gsl_sf_lnchoose
+foreign import ccall SAFE_CHEAP "gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double
+
+choose_e :: CInt -> CInt -> (Double,Double)
+choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m
+foreign import ccall SAFE_CHEAP "gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt
+
+choose :: CInt -> CInt -> Double
+choose = gsl_sf_choose
+foreign import ccall SAFE_CHEAP "gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double
+
+lnpoch_e :: Double -> Double -> (Double,Double)
+lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt
+
+lnpoch :: Double -> Double -> Double
+lnpoch = gsl_sf_lnpoch
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
+
+lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+
+poch_e :: Double -> Double -> (Double,Double)
+poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x
+foreign import ccall SAFE_CHEAP "gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt
+
+poch :: Double -> Double -> Double
+poch = gsl_sf_poch
+foreign import ccall SAFE_CHEAP "gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
+
+pochrel_e :: Double -> Double -> (Double,Double)
+pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x
+foreign import ccall SAFE_CHEAP "gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt
+
+pochrel :: Double -> Double -> Double
+pochrel = gsl_sf_pochrel
+foreign import ccall SAFE_CHEAP "gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt
+
+gamma_inc_Q :: Double -> Double -> Double
+gamma_inc_Q = gsl_sf_gamma_inc_Q
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt
+
+gamma_inc_P :: Double -> Double -> Double
+gamma_inc_P = gsl_sf_gamma_inc_P
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt
+
+gamma_inc :: Double -> Double -> Double
+gamma_inc = gsl_sf_gamma_inc
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
+
+lnbeta_e :: Double -> Double -> (Double,Double)
+lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt
+
+lnbeta :: Double -> Double -> Double
+lnbeta = gsl_sf_lnbeta
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
+
+lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+lnbeta_sgn_e = gsl_sf_lnbeta_sgn_e
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+
+beta_e :: Double -> Double -> (Double,Double)
+beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b
+foreign import ccall SAFE_CHEAP "gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt
+
+beta :: Double -> Double -> Double
+beta = gsl_sf_beta
+foreign import ccall SAFE_CHEAP "gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+
+beta_inc :: Double -> Double -> Double -> Double
+beta_inc = gsl_sf_beta_inc
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Gegenbauer.hs
@@ -0,0 +1,64 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Gegenbauer
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt
+
+gegenpoly_1 :: Double -> Double -> Double
+gegenpoly_1 = gsl_sf_gegenpoly_1
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
+
+gegenpoly_2 :: Double -> Double -> Double
+gegenpoly_2 = gsl_sf_gegenpoly_2
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
+
+gegenpoly_3 :: Double -> Double -> Double
+gegenpoly_3 = gsl_sf_gegenpoly_3
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
+
+gegenpoly_n_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+
+gegenpoly_n :: CInt -> Double -> Double -> Double
+gegenpoly_n = gsl_sf_gegenpoly_n
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double
+
+gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+gegenpoly_array = gsl_sf_gegenpoly_array
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Hyperg.hs b/lib/Numeric/GSL/Special/Hyperg.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Hyperg.hs
@@ -0,0 +1,130 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Hyperg
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt
+
+hyperg_0F1 :: Double -> Double -> Double
+hyperg_0F1 = gsl_sf_hyperg_0F1
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
+
+hyperg_1F1_int_e :: CInt -> CInt -> 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 SAFE_CHEAP "gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+
+hyperg_1F1_int :: CInt -> CInt -> Double -> Double
+hyperg_1F1_int = gsl_sf_hyperg_1F1_int
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_1F1 :: Double -> Double -> Double -> Double
+hyperg_1F1 = gsl_sf_hyperg_1F1
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
+
+hyperg_U_int_e :: CInt -> CInt -> 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 SAFE_CHEAP "gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+
+hyperg_U_int :: CInt -> CInt -> Double -> Double
+hyperg_U_int = gsl_sf_hyperg_U_int
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double
+
+hyperg_U_int_e10_e :: CInt -> CInt -> 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 SAFE_CHEAP "gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_U :: Double -> Double -> Double -> Double
+hyperg_U = gsl_sf_hyperg_U
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1 = gsl_sf_hyperg_2F1
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+
+hyperg_2F0 :: Double -> Double -> Double -> Double
+hyperg_2F0 = gsl_sf_hyperg_2F0
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Internal.hsc b/lib/Numeric/GSL/Special/Internal.hsc
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Internal.hsc
@@ -0,0 +1,102 @@
+ {-# LANGUAGE ForeignFunctionInterface #-}
+-----------------------------------------------------------------------------
+{- |
+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>
+-}
+-----------------------------------------------------------------------------
+
+#include <gsl/gsl_sf_result.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+module Numeric.GSL.Special.Internal (
+    createSFR,
+    createSFR_E10,
+    Precision(..),
+    Gsl_mode_t,
+    Size_t,
+    precCode
+)
+where
+
+import Foreign
+import Data.Packed.Development(check,(//))
+import Foreign.C.Types(CSize,CInt)
+
+
+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 = CSize
+
+---------------------------------------------------
+
+data Gsl_sf_result = SF Double Double
+  deriving (Show)
+
+instance Storable Gsl_sf_result where
+  sizeOf _ = #size gsl_sf_result
+  alignment _ = #alignment gsl_sf_result
+  peek ptr = do
+    val <- (#peek gsl_sf_result, val) ptr
+    err <- (#peek gsl_sf_result, err) ptr
+    return (SF val err)
+  poke ptr (SF val err) = do
+    (#poke gsl_sf_result, val) ptr val
+    (#poke gsl_sf_result, err) ptr err
+
+
+data Gsl_sf_result_e10 = SFE Double Double CInt
+  deriving (Show)
+
+instance Storable Gsl_sf_result_e10 where
+  sizeOf _ = #size gsl_sf_result_e10
+  alignment _ = #alignment gsl_sf_result_e10
+  peek ptr = do
+    val <- (#peek gsl_sf_result_e10, val) ptr
+    err <- (#peek gsl_sf_result_e10, err) ptr
+    e10 <- (#peek gsl_sf_result_e10, e10) ptr
+    return (SFE val err e10)
+  poke ptr (SFE val err e10) = do
+    (#poke gsl_sf_result_e10, val) ptr val
+    (#poke gsl_sf_result_e10, err) ptr err
+    (#poke gsl_sf_result_e10, e10) ptr e10
+
+
+----------------------------------------------------------------
+-- | access to a sf_result
+createSFR :: String -> (Ptr a -> IO CInt) -> (Double, Double)
+createSFR s f = unsafePerformIO $ do
+    p <- malloc :: IO (Ptr Gsl_sf_result)
+    f (castPtr p) // check s
+    SF val err <- peek p
+    free p
+    return (val,err)
+
+
+---------------------------------------------------------------------
+-- the sf_result_e10 contains two doubles and the exponent
+
+-- | access to sf_result_e10
+createSFR_E10 :: String -> (Ptr a -> IO CInt) -> (Double, Int, Double)
+createSFR_E10 s f = unsafePerformIO $ do
+    p <- malloc :: IO (Ptr Gsl_sf_result_e10)
+    f (castPtr p) // check s
+    SFE val err expo  <- peek p
+    free p
+    return (val, fromIntegral expo,err)
diff --git a/lib/Numeric/GSL/Special/Laguerre.hs b/lib/Numeric/GSL/Special/Laguerre.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Laguerre.hs
@@ -0,0 +1,60 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Laguerre
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+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 SAFE_CHEAP "gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt
+
+laguerre_1 :: Double -> Double -> Double
+laguerre_1 = gsl_sf_laguerre_1
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
+
+laguerre_2 :: Double -> Double -> Double
+laguerre_2 = gsl_sf_laguerre_2
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
+
+laguerre_3 :: Double -> Double -> Double
+laguerre_3 = gsl_sf_laguerre_3
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
+
+laguerre_n_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+
+laguerre_n :: CInt -> Double -> Double -> Double
+laguerre_n = gsl_sf_laguerre_n
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_n" gsl_sf_laguerre_n :: CInt -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Lambert.hs b/lib/Numeric/GSL/Special/Lambert.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Lambert.hs
@@ -0,0 +1,40 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Lambert
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+lambert_W0_e :: Double -> (Double,Double)
+lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt
+
+lambert_W0 :: Double -> Double
+lambert_W0 = gsl_sf_lambert_W0
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
+
+lambert_Wm1_e :: Double -> (Double,Double)
+lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt
+
+lambert_Wm1 :: Double -> Double
+lambert_Wm1 = gsl_sf_lambert_Wm1
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Legendre.hs
@@ -0,0 +1,233 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Legendre
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_legendre.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+legendre_Pl_e :: CInt -> Double -> (Double,Double)
+legendre_Pl_e l x = createSFR "legendre_Pl_e" $ gsl_sf_legendre_Pl_e l x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt
+
+legendre_Pl :: CInt -> Double -> Double
+legendre_Pl = gsl_sf_legendre_Pl
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double
+
+legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
+legendre_Pl_array = gsl_sf_legendre_Pl_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
+
+legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+
+legendre_P1_e :: Double -> (Double,Double)
+legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt
+
+legendre_P2_e :: Double -> (Double,Double)
+legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt
+
+legendre_P3_e :: Double -> (Double,Double)
+legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt
+
+legendre_P1 :: Double -> Double
+legendre_P1 = gsl_sf_legendre_P1
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
+
+legendre_P2 :: Double -> Double
+legendre_P2 = gsl_sf_legendre_P2
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
+
+legendre_P3 :: Double -> Double
+legendre_P3 = gsl_sf_legendre_P3
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
+
+legendre_Q0_e :: Double -> (Double,Double)
+legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt
+
+legendre_Q0 :: Double -> Double
+legendre_Q0 = gsl_sf_legendre_Q0
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
+
+legendre_Q1_e :: Double -> (Double,Double)
+legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt
+
+legendre_Q1 :: Double -> Double
+legendre_Q1 = gsl_sf_legendre_Q1
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
+
+legendre_Ql_e :: CInt -> Double -> (Double,Double)
+legendre_Ql_e l x = createSFR "legendre_Ql_e" $ gsl_sf_legendre_Ql_e l x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt
+
+legendre_Ql :: CInt -> Double -> Double
+legendre_Ql = gsl_sf_legendre_Ql
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double
+
+legendre_Plm_e :: CInt -> CInt -> Double -> (Double,Double)
+legendre_Plm_e l m x = createSFR "legendre_Plm_e" $ gsl_sf_legendre_Plm_e l m x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+
+legendre_Plm :: CInt -> CInt -> Double -> Double
+legendre_Plm = gsl_sf_legendre_Plm
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double
+
+legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+legendre_Plm_array = gsl_sf_legendre_Plm_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+legendre_Plm_deriv_array = gsl_sf_legendre_Plm_deriv_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+
+legendre_sphPlm_e :: CInt -> CInt -> Double -> (Double,Double)
+legendre_sphPlm_e l m x = createSFR "legendre_sphPlm_e" $ gsl_sf_legendre_sphPlm_e l m x
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+
+legendre_sphPlm :: CInt -> CInt -> Double -> Double
+legendre_sphPlm = gsl_sf_legendre_sphPlm
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double
+
+legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+
+legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+legendre_sphPlm_deriv_array = gsl_sf_legendre_sphPlm_deriv_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+
+legendre_array_size :: CInt -> CInt -> CInt
+legendre_array_size = gsl_sf_legendre_array_size
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt
+
+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 SAFE_CHEAP "gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt
+
+conicalP_half :: Double -> Double -> Double
+conicalP_half = gsl_sf_conicalP_half
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt
+
+conicalP_mhalf :: Double -> Double -> Double
+conicalP_mhalf = gsl_sf_conicalP_mhalf
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt
+
+conicalP_0 :: Double -> Double -> Double
+conicalP_0 = gsl_sf_conicalP_0
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt
+
+conicalP_1 :: Double -> Double -> Double
+conicalP_1 = gsl_sf_conicalP_1
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
+
+conicalP_sph_reg_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+
+conicalP_sph_reg :: CInt -> Double -> Double -> Double
+conicalP_sph_reg = gsl_sf_conicalP_sph_reg
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double
+
+conicalP_cyl_reg_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+
+conicalP_cyl_reg :: CInt -> Double -> Double -> Double
+conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt
+
+legendre_H3d_0 :: Double -> Double -> Double
+legendre_H3d_0 = gsl_sf_legendre_H3d_0
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt
+
+legendre_H3d_1 :: Double -> Double -> Double
+legendre_H3d_1 = gsl_sf_legendre_H3d_1
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
+
+legendre_H3d_e :: CInt -> 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 SAFE_CHEAP "gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+
+legendre_H3d :: CInt -> Double -> Double -> Double
+legendre_H3d = gsl_sf_legendre_H3d
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double
+
+legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+legendre_H3d_array = gsl_sf_legendre_H3d_array
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Log.hs b/lib/Numeric/GSL/Special/Log.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Log.hs
@@ -0,0 +1,64 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Log
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_log.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+log_e :: Double -> (Double,Double)
+log_e x = createSFR "log_e" $ gsl_sf_log_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt
+
+log :: Double -> Double
+log = gsl_sf_log
+foreign import ccall SAFE_CHEAP "gsl_sf_log" gsl_sf_log :: Double -> Double
+
+log_abs_e :: Double -> (Double,Double)
+log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt
+
+log_abs :: Double -> Double
+log_abs = gsl_sf_log_abs
+foreign import ccall SAFE_CHEAP "gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
+
+complex_log_e :: Double -> Double -> Ptr () -> (Double,Double)
+complex_log_e zr zi lnr = createSFR "complex_log_e" $ gsl_sf_complex_log_e zr zi lnr
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+log_1plusx_e :: Double -> (Double,Double)
+log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt
+
+log_1plusx :: Double -> Double
+log_1plusx = gsl_sf_log_1plusx
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt
+
+log_1plusx_mx :: Double -> Double
+log_1plusx_mx = gsl_sf_log_1plusx_mx
+foreign import ccall SAFE_CHEAP "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
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Pow_int.hs
@@ -0,0 +1,30 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Pow_int
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+pow_int_e :: Double -> CInt -> (Double,Double)
+pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n
+foreign import ccall SAFE_CHEAP "gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt
+
+pow_int :: Double -> CInt -> Double
+pow_int = gsl_sf_pow_int
+foreign import ccall SAFE_CHEAP "gsl_sf_pow_int" gsl_sf_pow_int :: Double -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Psi.hs b/lib/Numeric/GSL/Special/Psi.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Psi.hs
@@ -0,0 +1,84 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Psi
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+psi_int_e :: CInt -> (Double,Double)
+psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt
+
+psi_int :: CInt -> Double
+psi_int = gsl_sf_psi_int
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double
+
+psi_e :: Double -> (Double,Double)
+psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt
+
+psi :: Double -> Double
+psi = gsl_sf_psi
+foreign import ccall SAFE_CHEAP "gsl_sf_psi" gsl_sf_psi :: Double -> Double
+
+psi_1piy_e :: Double -> (Double,Double)
+psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt
+
+psi_1piy :: Double -> Double
+psi_1piy = gsl_sf_psi_1piy
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
+
+complex_psi_e :: Double -> Double -> Ptr () -> (Double,Double)
+complex_psi_e x y result_re = createSFR "complex_psi_e" $ gsl_sf_complex_psi_e x y result_re
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+psi_1_int_e :: CInt -> (Double,Double)
+psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt
+
+psi_1_int :: CInt -> Double
+psi_1_int = gsl_sf_psi_1_int
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double
+
+psi_1_e :: Double -> (Double,Double)
+psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt
+
+psi_1 :: Double -> Double
+psi_1 = gsl_sf_psi_1
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
+
+psi_n_e :: CInt -> Double -> (Double,Double)
+psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt
+
+psi_n :: CInt -> Double -> Double
+psi_n = gsl_sf_psi_n
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_n" gsl_sf_psi_n :: CInt -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Synchrotron.hs b/lib/Numeric/GSL/Special/Synchrotron.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Synchrotron.hs
@@ -0,0 +1,40 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Synchrotron
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+synchrotron_1_e :: Double -> (Double,Double)
+synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt
+
+synchrotron_1 :: Double -> Double
+synchrotron_1 = gsl_sf_synchrotron_1
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
+
+synchrotron_2_e :: Double -> (Double,Double)
+synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt
+
+synchrotron_2 :: Double -> Double
+synchrotron_2 = gsl_sf_synchrotron_2
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Transport.hs b/lib/Numeric/GSL/Special/Transport.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Transport.hs
@@ -0,0 +1,60 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Transport
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_transport.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+module Numeric.GSL.Special.Transport(
+  transport_2_e
+, transport_2
+, transport_3_e
+, transport_3
+, transport_4_e
+, transport_4
+, transport_5_e
+, transport_5
+) where
+
+import Foreign(Ptr)
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+transport_2_e :: Double -> (Double,Double)
+transport_2_e x = createSFR "transport_2_e" $ gsl_sf_transport_2_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_2_e" gsl_sf_transport_2_e :: Double -> Ptr () -> IO CInt
+
+transport_2 :: Double -> Double
+transport_2 = gsl_sf_transport_2
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_2" gsl_sf_transport_2 :: Double -> Double
+
+transport_3_e :: Double -> (Double,Double)
+transport_3_e x = createSFR "transport_3_e" $ gsl_sf_transport_3_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_3_e" gsl_sf_transport_3_e :: Double -> Ptr () -> IO CInt
+
+transport_3 :: Double -> Double
+transport_3 = gsl_sf_transport_3
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_3" gsl_sf_transport_3 :: Double -> Double
+
+transport_4_e :: Double -> (Double,Double)
+transport_4_e x = createSFR "transport_4_e" $ gsl_sf_transport_4_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_4_e" gsl_sf_transport_4_e :: Double -> Ptr () -> IO CInt
+
+transport_4 :: Double -> Double
+transport_4 = gsl_sf_transport_4
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_4" gsl_sf_transport_4 :: Double -> Double
+
+transport_5_e :: Double -> (Double,Double)
+transport_5_e x = createSFR "transport_5_e" $ gsl_sf_transport_5_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_5_e" gsl_sf_transport_5_e :: Double -> Ptr () -> IO CInt
+
+transport_5 :: Double -> Double
+transport_5 = gsl_sf_transport_5
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_5" gsl_sf_transport_5 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Trig.hs b/lib/Numeric/GSL/Special/Trig.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Trig.hs
@@ -0,0 +1,138 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Trig
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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_trig.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+------------------------------------------------------------
+
+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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+sin_e :: Double -> (Double,Double)
+sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt
+
+sin :: Double -> Double
+sin = gsl_sf_sin
+foreign import ccall SAFE_CHEAP "gsl_sf_sin" gsl_sf_sin :: Double -> Double
+
+cos_e :: Double -> (Double,Double)
+cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt
+
+cos :: Double -> Double
+cos = gsl_sf_cos
+foreign import ccall SAFE_CHEAP "gsl_sf_cos" gsl_sf_cos :: Double -> Double
+
+hypot_e :: Double -> Double -> (Double,Double)
+hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y
+foreign import ccall SAFE_CHEAP "gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt
+
+hypot :: Double -> Double -> Double
+hypot = gsl_sf_hypot
+foreign import ccall SAFE_CHEAP "gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
+
+complex_sin_e :: Double -> Double -> Ptr () -> (Double,Double)
+complex_sin_e zr zi szr = createSFR "complex_sin_e" $ gsl_sf_complex_sin_e zr zi szr
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+complex_cos_e :: Double -> Double -> Ptr () -> (Double,Double)
+complex_cos_e zr zi czr = createSFR "complex_cos_e" $ gsl_sf_complex_cos_e zr zi czr
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+complex_logsin_e :: Double -> Double -> Ptr () -> (Double,Double)
+complex_logsin_e zr zi lszr = createSFR "complex_logsin_e" $ gsl_sf_complex_logsin_e zr zi lszr
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+sinc_e :: Double -> (Double,Double)
+sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt
+
+sinc :: Double -> Double
+sinc = gsl_sf_sinc
+foreign import ccall SAFE_CHEAP "gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
+
+lnsinh_e :: Double -> (Double,Double)
+lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt
+
+lnsinh :: Double -> Double
+lnsinh = gsl_sf_lnsinh
+foreign import ccall SAFE_CHEAP "gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
+
+lncosh_e :: Double -> (Double,Double)
+lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x
+foreign import ccall SAFE_CHEAP "gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt
+
+lncosh :: Double -> Double
+lncosh = gsl_sf_lncosh
+foreign import ccall SAFE_CHEAP "gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
+
+polar_to_rect :: Double -> Double -> Ptr () -> (Double,Double)
+polar_to_rect r theta x = createSFR "polar_to_rect" $ gsl_sf_polar_to_rect r theta x
+foreign import ccall SAFE_CHEAP "gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+rect_to_polar :: Double -> Double -> Ptr () -> (Double,Double)
+rect_to_polar x y r = createSFR "rect_to_polar" $ gsl_sf_rect_to_polar x y r
+foreign import ccall SAFE_CHEAP "gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt
+
+angle_restrict_symm_e :: Ptr Double -> CInt
+angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt
+
+angle_restrict_symm :: Double -> Double
+angle_restrict_symm = gsl_sf_angle_restrict_symm
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
+
+angle_restrict_pos_e :: Ptr Double -> CInt
+angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt
+
+angle_restrict_pos :: Double -> Double
+angle_restrict_pos = gsl_sf_angle_restrict_pos
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
+
+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 SAFE_CHEAP "gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt
+
+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 SAFE_CHEAP "gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Zeta.hs b/lib/Numeric/GSL/Special/Zeta.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/Zeta.hs
@@ -0,0 +1,90 @@
+------------------------------------------------------------
+-- |
+-- Module      :  Numeric.GSL.Special.Zeta
+-- Copyright   :  (c) Alberto Ruiz 2006
+-- License     :  GPL
+-- 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 Foreign.C.Types(CInt)
+import Numeric.GSL.Special.Internal
+
+zeta_int_e :: CInt -> (Double,Double)
+zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt
+
+zeta_int :: CInt -> Double
+zeta_int = gsl_sf_zeta_int
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double
+
+zeta_e :: Double -> (Double,Double)
+zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt
+
+zeta :: Double -> Double
+zeta = gsl_sf_zeta
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
+
+zetam1_e :: Double -> (Double,Double)
+zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt
+
+zetam1 :: Double -> Double
+zetam1 = gsl_sf_zetam1
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
+
+zetam1_int_e :: CInt -> (Double,Double)
+zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt
+
+zetam1_int :: CInt -> Double
+zetam1_int = gsl_sf_zetam1_int
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double
+
+hzeta_e :: Double -> Double -> (Double,Double)
+hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q
+foreign import ccall SAFE_CHEAP "gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt
+
+hzeta :: Double -> Double -> Double
+hzeta = gsl_sf_hzeta
+foreign import ccall SAFE_CHEAP "gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
+
+eta_int_e :: CInt -> (Double,Double)
+eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt
+
+eta_int :: CInt -> Double
+eta_int = gsl_sf_eta_int
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double
+
+eta_e :: Double -> (Double,Double)
+eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt
+
+eta :: Double -> Double
+eta = gsl_sf_eta
+foreign import ccall SAFE_CHEAP "gsl_sf_eta" gsl_sf_eta :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/auto.hs b/lib/Numeric/GSL/Special/auto.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/auto.hs
@@ -0,0 +1,244 @@
+#!/usr/bin/env runhaskell
+
+-- 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)\n"
+                ++"import Foreign.C.Types(CInt)\n"
+                ++"import Numeric.GSL.Special.Internal\n"
+    let mod = modhead name ++ "module Numeric.GSL.Special."++ upperFirst name++exports++imports++defs
+    writeFile (upperFirst name ++ ".hs") mod
+--     appendFile "funs.txt" $ rep ("(\n ","-- * "
+--                                      ++map toUpper name
+--                                 --   ++"\n"++google ( "gsl_sf_"++name++".h")++"\n"
+--                                      ++"\n,") $ rep (") where","") $ exports
+
+
+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\n"
+             ++"-- Maintainer  :  Alberto Ruiz (aruiz at um dot es)\n"
+             ++"-- Stability   :  provisional\n"
+             ++"-- Portability :  uses ffi\n"
+             ++"--\n"
+             ++"-- Wrappers for selected functions described at:\n--\n-- "
+             ++ google ( "gsl_sf_"++name++".h")++"\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 SAFE_CHEAP \""++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
+    where t' | pure h = showHt t
+             | otherwise = "IO "++showHt t
+
+ht "int" = "CInt"
+ht (s:ss) = toUpper s : ss
+
+showHt (Normal t) = ht t
+showHt (Pointer "gsl_sf_result") = "Ptr ()"
+showHt (Pointer "gsl_sf_result_e10") = "Ptr ()"
+showHt (Pointer t) = "Ptr "++ht t
+
+showHa (t,a) = showHt t
+
+showFull hc h@(Header t n args) = -- "\n-- | wrapper for "++showC h
+                                  --   ++"\n--\n--   "++google n ++"\n"++
+                                  -- ++ "\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))
diff --git a/lib/Numeric/GSL/Special/autoall.sh b/lib/Numeric/GSL/Special/autoall.sh
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/autoall.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+
+function rep {
+    ./replace.hs "$1" "$2" < $3 > /tmp/tmp-rep
+    cp /tmp/tmp-rep $3
+}
+
+rm -f funs.txt
+
+./auto.hs airy
+rep ') where' ', Precision(..)\n) where' Airy.hs
+./auto.hs bessel
+./auto.hs clausen
+./auto.hs coulomb
+./auto.hs coupling
+rep ', coupling_6j_INCORRECT_e\n, coupling_6j_INCORRECT\n' '' Coupling.hs
+./auto.hs dawson
+./auto.hs debye
+./auto.hs dilog
+./auto.hs elementary
+./auto.hs ellint
+#./auto.hs elljac
+./auto.hs erf
+./auto.hs exp
+rep ', exp\n' ', Numeric.GSL.Special.Exp.exp\n' Exp.hs
+rep ', exprel_n_CF_e' '-- , exprel_n_CF_e' Exp.hs
+./auto.hs expint
+./auto.hs fermi_dirac
+./auto.hs gamma
+./auto.hs gegenbauer
+./auto.hs hyperg
+./auto.hs laguerre
+./auto.hs lambert
+./auto.hs legendre
+./auto.hs log
+rep ', log\n' ', Numeric.GSL.Special.Log.log\n' Log.hs
+#./auto.hs mathieu
+./auto.hs pow_int
+./auto.hs psi
+./auto.hs synchrotron
+./auto.hs transport
+./auto.hs trig
+rep ', sin\n' ', Numeric.GSL.Special.Trig.sin\n' Trig.hs
+rep ', cos\n' ', Numeric.GSL.Special.Trig.cos\n' Trig.hs
+./auto.hs zeta
diff --git a/lib/Numeric/GSL/Special/replace.hs b/lib/Numeric/GSL/Special/replace.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Special/replace.hs
@@ -0,0 +1,14 @@
+#!/usr/bin/env runhaskell
+
+import Data.List(isPrefixOf)
+import System(getArgs)
+
+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)
+
+main = do
+    args <- getArgs
+    let [p',r'] = map (rep ("\\n","\n")) args
+    interact $ rep (p',r')