diff --git a/INSTALL b/INSTALL
--- a/INSTALL
+++ b/INSTALL
@@ -13,46 +13,45 @@
 
 INSTALLATION ON WINDOWS ----------------------------------------
 
-1) Download the developer files gsl-1.8-lib.zip from
-   http://gnuwin32.sourceforge.net/packages/gsl.htm
-   and copy the gsl headers folder (under include) to:
-       C:\ghc\ghc.6.x.1\include
-   These headers are also available from:
-       http://perception.inf.um.es/~aruiz/darcs/hmatrix/gsl.zip
+1) Install a recent ghc (e.g. ghc-6.10.3)
 
-2) Copy libgsl.dll, libcblas.dll (from the binaries package gsl-1.8.bin.zip)
-   and liblapack.dll (borrowed from the R system) to the ghc folder, e.g.:
-       C:\ghc\ghc-6.x.x.
-   Rename libcblas.dll to libblas.dll.
-   They are needed to compile programs.
-   These three dlls are available from:
-       http://perception.inf.um.es/~aruiz/darcs/hmatrix/dll1.zip
+2) Install cabal-install. A binary for windows can be obtained from:
 
-2.5) Remove the following functions from the export list of
-     lib/Numeric/GSL/Special/Ellint.hs:
-     ellint_Pcomp_e, ellint_Pcomp, ellint_Dcomp_e, ellint_Dcomp
+   http://www.haskell.org/cabal/release/cabal-install-0.6.2/cabal.exe
 
-3) Install the package as usual:
-       runhaskell Setup.lhs configure
-       runhaskell Setup.lhs build
-       runhaskell Setup.lhs install
+   Put it somewhere in the path, for instance in c:\ghc\ghc-6.10.3\bin
 
-3.5) If configure cannot find ld please see:
-       http://article.gmane.org/gmane.comp.lang.haskell.cafe/32025
+3) Download and uncompress in a temporary location the following file:
 
-4) Copy the dlls available from:
-       http://perception.inf.um.es/~aruiz/darcs/hmatrix/dll2.zip
-   to the working directory or C:\windows\system
-   They are required to run the programs and ghci.
+   http://code.haskell.org/hmatrix/gsl-lapack-windows.zip
 
-5) run the tests
+   It contains a folder, gsl, and four DLL's.
 
-Unfortunately the lapack dll supplied by the R system does not include
-zgels_, zgelss_, and zgees_, so the functions depending on them
-(linearSolveLS, linearSolveSVD, and schur for complex data)
-will produce a "non supported in this OS" runtime error.
+4) Move the gsl folder to C:\ghc\ghc-6.10.3\include
 
-If you find an alternative free and complete lapack.dll which works well
-for this system please let me know.
+5) Move the four DLL's to C:\ghc\ghc-6.10.3\bin
 
-The examples using graphics do not yet work in windows.
+6) Download and uncompress hmatrix-x.y.z.tar.gz from Hackage:
+
+   http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hmatrix
+
+7) Edit hmatrix.cabal:
+
+     line 17:      build-type:         Custom
+     change to:    build-type:         Simple
+
+     line 162:     extra-libraries:
+     add:          extra-libraries: libgsl-0 blas lapack
+
+     line 163:     extra-lib-dirs:
+     add:          extra-lib-dirs: c:\ghc\ghc-6.10.3\bin
+
+8) Open a terminal, cd to the hmatrix folder, and run
+
+   > cabal install
+
+9) If everything is ok we can run the tests:
+
+   > runhaskell examples\tests.hs
+
+NOTE: The examples using graphics do not yet work in windows.
diff --git a/README b/README
--- a/README
+++ b/README
@@ -111,3 +111,7 @@
 - Daniel Schüssler added compatibility with QuickCheck 2 as well
   as QuickCheck 1 using the C preprocessor. He also added some
   implementations for the new "shrink" method of class Arbitrary.
+
+- Tracy Wadleigh improved the definitions of (|>) and (><), which now
+  apply an appropriate 'take' to the given lists so that they may be
+  safely used on lists that are too long (or infinite).
diff --git a/Setup.lhs b/Setup.lhs
--- a/Setup.lhs
+++ b/Setup.lhs
@@ -1,4 +1,8 @@
 #! /usr/bin/env runhaskell
 
 > import Distribution.Simple
-> main = defaultMain
+> import System(system)
+
+> main = defaultMainWithHooks autoconfUserHooks {runTests = t}
+
+> t _ _ _ _ = system ( "runhaskell examples/tests.hs") >> return()
diff --git a/configure b/configure
new file mode 100644
--- /dev/null
+++ b/configure
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+runhaskell configure.hs $*
diff --git a/configure.hs b/configure.hs
new file mode 100644
--- /dev/null
+++ b/configure.hs
@@ -0,0 +1,101 @@
+#! /usr/bin/env runhaskell
+{- configure.hs for hmatrix
+   ------------------------
+
+    GSL and LAPACK may require auxiliary libraries which depend on OS,
+    distribution, and implementation. This script tries to to find out
+    the correct link command for your system.
+    Suggestions and contributions are welcome.
+
+    By default we try to link -lgsl -llapack. This works in ubuntu/debian,
+    both with and without ATLAS.
+    If this fails we try different sets of additional libraries which are
+    known to work in some systems.
+
+    The desired libraries can also be explicitly given by the user using cabal
+    flags (e.g., -fmkl, -faccelerate) or --configure-option=link:lib1,lib2,lib3,...
+
+-}
+
+import System
+import Data.List(isPrefixOf)
+import Distribution.Simple.LocalBuildInfo
+import Distribution.Simple.Configure
+import Distribution.PackageDescription
+
+-- possible additional dependencies for the desired libs (by default gsl lapack)
+
+opts = [ ""                              -- Ubuntu/Debian
+       , "blas"
+       , "blas cblas"
+       , "cblas"
+       , "gslcblas"
+       , "blas gslcblas"
+       , "f77blas cblas atlas gcc_s"     -- Arch Linux (older version of atlas-lapack)
+       , "blas gslcblas gfortran"        -- Arch Linux with normal blas and lapack
+       ]
+
+-- compile a simple program with symbols from GSL and LAPACK with the given libs
+testprog libs fmks = "echo \"#include <gsl/gsl_sf_gamma.h>\nint main(){zgesvd_(); gsl_sf_gamma(5);}\""
+                     ++" > /tmp/dummy.c; gcc /tmp/dummy.c -o /tmp/dummy "
+                     ++ f1 libs ++ " " ++ f2 fmks ++ " > /dev/null 2> /dev/null"
+
+f1 = unwords . map ("-l"++) . words
+f2 = unwords . map ("-framework "++) . words
+
+check libs fmks = (ExitSuccess ==) `fmap` system (testprog libs fmks)
+
+-- simple test for GSL
+testGSL = "echo \"#include <gsl/gsl_sf_gamma.h>\nint main(){gsl_sf_gamma(5);}\""
+           ++" > /tmp/dummy.c; gcc /tmp/dummy.c -o /tmp/dummy -lgsl -lgslcblas"
+           ++ " > /dev/null 2> /dev/null"
+
+checkGSL = (ExitSuccess ==) `fmap` system (testGSL)
+
+-- test different configurations until the first one works
+try _ _ [] = return Nothing
+try b f (opt:rest) = do
+    ok <- check (b ++ " " ++ opt) f
+    if ok then return (Just opt)
+          else try b f rest
+
+-- read --configure-option=link:lib1,lib2,lib3,etc
+linkop = "link:"
+getUserLink = concatMap (g . drop (length linkop)) . filter (isPrefixOf linkop)
+    where g = map cs
+          cs ',' = ' '
+          cs x   = x
+
+main = do
+    putStr "Checking foreign libraries..."
+
+    args <- getArgs
+    Just bInfo <- maybeGetPersistBuildConfig "dist"
+
+    let Just lib = library . localPkgDescr $ bInfo
+        base = unwords . extraLibs . libBuildInfo $ lib
+        fwks = unwords . frameworks . libBuildInfo $ lib
+        auxpref = getUserLink args
+
+    -- We extract the desired libs from hmatrix.cabal (using a cabal flags)
+    -- and from a posible --configure-option=link:lib1,lib2,lib3
+    -- by default the desired libs are gsl lapack.
+
+    let pref = if null (words (base ++ " " ++ auxpref)) then "gsl lapack" else auxpref
+        fullOpts = map ((pref++" ")++) opts
+
+    r <- try base fwks fullOpts
+    case r of
+        Nothing -> do
+            putStrLn " FAIL"
+            g <- checkGSL
+            if g
+                then putStrLn " *** Sorry, I can't link LAPACK."
+                else putStrLn " *** Sorry, I can't link GSL."
+            putStrLn " *** Please make sure that the appropriate -dev packages are installed."
+            putStrLn " *** You can also specify the required libraries using"
+            putStrLn " *** cabal install hmatrix --configure-option=link:lib1,lib2,lib3,etc."
+            writeFile "hmatrix.buildinfo" ("buildable: False\n")
+        Just ops -> do
+            putStrLn " OK"
+            writeFile "hmatrix.buildinfo" ("extra-libraries: " ++ ops++"\n")
diff --git a/examples/devel/functions.c b/examples/devel/functions.c
new file mode 100644
--- /dev/null
+++ b/examples/devel/functions.c
@@ -0,0 +1,34 @@
+typedef struct { double r, i; } doublecomplex;
+
+#define DVEC(A) int A##n, double*A##p
+#define CVEC(A) int A##n, doublecomplex*A##p
+#define DMAT(A) int A##r, int A##c, double*A##p
+#define CMAT(A) int A##r, int A##c, doublecomplex*A##p
+
+#define AT(M,r,c) (M##p[(r)*sr+(c)*sc])
+
+/*-----------------------------------------------------*/
+
+int c_scale_vector(double s, DVEC(x), DVEC(y)) {
+    int k;
+    for (k=0; k<=yn; k++) {
+        yp[k] = s*xp[k];
+    }
+    return 0;
+}
+
+/*-----------------------------------------------------*/
+
+int c_diag(int ro, DMAT(m),DVEC(y),DMAT(z)) {
+    int i,j,sr,sc;
+    if (ro==1) { sr = mc; sc = 1;} else { sr = 1; sc = mr;}
+    for (j=0; j<yn; j++) {
+        yp[j] = AT(m,j,j);
+    }
+    for (i=0; i<mr; i++) {
+        for (j=0; j<mc; j++) {
+            AT(z,i,j) = i==j?yp[i]:0;
+        }
+    }
+    return 0;
+}
diff --git a/examples/devel/wrappers.hs b/examples/devel/wrappers.hs
new file mode 100644
--- /dev/null
+++ b/examples/devel/wrappers.hs
@@ -0,0 +1,45 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+
+-- $ ghc -O2 --make wrappers.hs functions.c
+
+import Numeric.LinearAlgebra
+import Data.Packed.Development
+import Foreign(Ptr,unsafePerformIO)
+import Foreign.C.Types(CInt)
+
+-----------------------------------------------------
+
+main = do
+    print $ myScale 3.0 (fromList [1..10])
+    print $ myDiag $ (3><5) [1..]
+
+-----------------------------------------------------
+
+foreign import ccall "c_scale_vector"
+    cScaleVector :: Double                -- scale
+                 -> CInt -> Ptr Double    -- argument
+                 -> CInt -> Ptr Double    -- result
+                 -> IO CInt               -- exit code
+
+myScale s x = unsafePerformIO $ do
+    y <- createVector (dim x)
+    app2 (cScaleVector s) vec x vec y "cScaleVector"
+    return y
+
+-----------------------------------------------------
+
+foreign import ccall "c_diag"
+    cDiag :: CInt                        -- matrix order
+          -> CInt -> CInt -> Ptr Double  -- argument
+          -> CInt -> Ptr Double          -- result1
+          -> CInt -> CInt -> Ptr Double  -- result2
+          -> IO CInt                     -- exit code
+
+myDiag m = unsafePerformIO $ do
+    y <- createVector (min r c)
+    z <- createMatrix (orderOf m) r c
+    app3 (cDiag o) mat m vec y mat z "cDiag"
+    return (y,z)
+  where r = rows m
+        c = cols m
+        o = if orderOf m == RowMajor then 1 else 0
diff --git a/examples/error.hs b/examples/error.hs
new file mode 100644
--- /dev/null
+++ b/examples/error.hs
@@ -0,0 +1,20 @@
+import Numeric.GSL
+import Numeric.LinearAlgebra
+import Prelude hiding (catch)
+import Control.Exception
+
+test x = catch
+       (print x)
+       (\e -> putStrLn $ "captured ["++ show (e :: SomeException) ++"]")
+
+main = do
+    setErrorHandlerOff
+
+    test $ log_e (-1)
+    test $ 5 + (fst.exp_e) 1000
+    test $ bessel_zero_Jnu_e (-0.3) 2
+
+    test $ (linearSolve 0 4 :: Matrix Double)
+    test $ (linearSolve 5 (sqrt (-1)) :: Matrix Double)
+
+    putStrLn "Bye"
diff --git a/examples/experiments/bigtests.hs b/examples/experiments/bigtests.hs
deleted file mode 100644
--- a/examples/experiments/bigtests.hs
+++ /dev/null
@@ -1,60 +0,0 @@
-module Main where
-
-import Numeric.LinearAlgebra
-import Numeric.LinearAlgebra.Tests
-import System.Random(randomRs,mkStdGen)
-import Test.HUnit hiding (test)
-import System(getArgs)
-
-
-pseudorandomR seed (n,m) = reshape m $ fromList $ take (n*m) $ randomRs (-100,100) $ mkStdGen seed
-
-pseudorandomC seed (n,m) = toComplex (pseudorandomR seed (n,m), pseudorandomR (seed+1) (n,m))
-
-bigmat = m + trans m
-    where m = pseudorandomR 18 (1000,1000) :: Matrix Double
-bigmatc = mc + ctrans mc
-    where mc = pseudorandomC 19 (1000,1000) :: Matrix (Complex Double)
-
-utest str b = TestCase $ assertBool str b
-
-feye n = flipud (ident n) :: Matrix Double
-
-infixl 4 |~|
-a |~| b = dist a b < 10^^(-10)
-
-dist a b = r
-    where norm = pnorm Infinity
-          na = norm a
-          nb = norm b
-          nab = norm (a-b)
-          mx = max na nb
-          mn = min na nb
-          r = if mn < eps
-                then mx
-                else nab/mx
-
-square m = rows m == cols m
-
-unitary m = square m && m <> ctrans m |~| ident (rows m)
-
-eigProp m = complex m <> v |~| v <> diag s
-    where (s, v) = eig m
-
-eigSHProp m = m <> v |~| v <> real (diag s)
-              && unitary v
-              && m |~| v <> real (diag s) <> ctrans v
-    where (s, v) = eigSH m
-
-bigtests = do
-    putStrLn "--------- big matrices -----"
-    runTestTT $ TestList
-     [ utest "eigS" $ eigSHProp bigmat
-     , utest "eigH" $ eigSHProp bigmatc
-     , utest "eigR" $ eigProp   bigmat
-     , utest "eigC" $ eigProp   bigmatc
-     , utest "det"  $ det (feye 1000) == 1 && det (feye 1002) == -1
-     ]
-    return ()
-
-main = bigtests
diff --git a/examples/experiments/error.hs b/examples/experiments/error.hs
deleted file mode 100644
--- a/examples/experiments/error.hs
+++ /dev/null
@@ -1,16 +0,0 @@
-import Numeric.GSL
-import Prelude hiding (catch)
-import Control.Exception
-
-test x = catch
-       (print x)
-       (\e -> putStrLn $ "captured ["++ show e++"]")
-
-main = do
-    setErrorHandlerOff
-
-    test $ log_e (-1)
-    test $ 5 + (fst.exp_e) 1000
-    test $ bessel_zero_Jnu_e (-0.3) 2
-
-    putStrLn "Bye"
diff --git a/examples/experiments/listlike.hs b/examples/experiments/listlike.hs
deleted file mode 100644
--- a/examples/experiments/listlike.hs
+++ /dev/null
@@ -1,24 +0,0 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
-
-import qualified Data.ListLike as LL
-import Numeric.LinearAlgebra
-import Data.Monoid
-import Foreign
-
-instance Storable a => LL.FoldableLL (Vector a) a where
-    foldl f x v = foldl f x (toList v)
-    foldr f x v = foldr f x (toList v)
-
-instance Storable a => LL.ListLike (Vector a) a where
-    singleton a = fromList [a]
-    head a = a @> 0
-    tail a | dim a == 1 = mempty
-           | otherwise  = subVector 1 (dim a -1) a
-    genericLength = fromIntegral.dim
-
-
-v k = fromList [1..k] :: Vector Double
-
-f k = k+(3::Double)
-
-main = print $ (LL.map f [1..5] :: Vector Double)
diff --git a/examples/experiments/parallel.hs b/examples/experiments/parallel.hs
deleted file mode 100644
--- a/examples/experiments/parallel.hs
+++ /dev/null
@@ -1,36 +0,0 @@
-import System(getArgs)
-import Numeric.LinearAlgebra
-import Control.Parallel.Strategies
-import System.Time
-
-inParallel = parMap rwhnf id
-
-parMul p x y = fromBlocks [ inParallel ( map (x <>) ys ) ]
-    where ys = splitColumns p y
-
-
-main = do
-    n <- (read . head) `fmap` getArgs
-    let m = ident n :: Matrix Double
-    time $ print $ vectorMax $ takeDiag $ m <> m
-    time $ print $ vectorMax $ takeDiag $ parMul 2 m m
-    time $ print $ vectorMax $ takeDiag $ parMul 4 m m
-    time $ print $ vectorMax $ takeDiag $ parMul 8 m m
-
-time act = do
-    t0 <- getClockTime
-    act
-    t1 <- getClockTime
-    print $ tdSec $ normalizeTimeDiff $ diffClockTimes t1 t0
-
-splitColumns n m = splitColumns' (f n (cols m)) m
-    where
-    splitColumns' [] m = []
-    splitColumns' ((a,b):rest) m = subMatrix (0,a) (rows m, b-a+1) m : splitColumns' rest m
-
-    f :: Int -> Int -> [(Int,Int)]
-    f n c = zip ks (map pred $ tail ks)
-        where ks = map round $ toList $ linspace (fromIntegral n+1) (0,fromIntegral c)
-
-splitRowsAt p m    = (takeRows p m, dropRows p m)
-splitColumnsAt p m = (takeColumns p m, dropColumns p m)
diff --git a/examples/experiments/speed.hs b/examples/experiments/speed.hs
deleted file mode 100644
--- a/examples/experiments/speed.hs
+++ /dev/null
@@ -1,90 +0,0 @@
-{- speed tests
-
-GNU-Octave (see speed.m in this folder):
-
-./speed.m
-  -0.017877255967426   0.000000000000000  -0.999840189089781
-   0.000000000000000   1.000000000000000   0.000000000000000
-   0.999840189089763   0.000000000000000  -0.017877255967417
-9.69 seconds
-
-Mathematica:
-
-rot[a_]:={{ Cos[a], 0, Sin[a]},
-          { 0,      1,      0},
-          { -Sin[a],0,Cos[a]}}//N
-
-test := Timing[
-    n = 100000;
-    angles = Range[0.,n-1]/(n-1);
-    Fold[Dot,IdentityMatrix[3],rot/@angles] // MatrixForm
-]
-
-2.08013 Second
-     {{\(-0.017877255967432837`\), "0.`", \(-0.9998401890898042`\)},
-      {"0.`", "1.`", "0.`"},
-      {"0.9998401890898042`", "0.`", \(-0.017877255967432837`\)}}
-
-$ ghc --make -O speed
-
-$ ./speed 5 100000 1
-(3><3)
- [ -1.7877255967425523e-2, 0.0,    -0.9998401890897632
- ,                    0.0, 1.0,                    0.0
- ,      0.999840189089781, 0.0, -1.7877255967416586e-2 ]
-0.33 CPU seconds
-
-cos 50000 = -0.0178772559665563
-sin 50000 = -0.999840189089790
-
--}
-
-import Numeric.LinearAlgebra
-import System
-import Data.List(foldl1')
-import System.CPUTime
-import Text.Printf
-import Debug.Trace
-
-debug x = trace (show x) x
-
-timing act = do
-    t0 <- getCPUTime
-    act
-    t1 <- getCPUTime
-    printf "%.2f CPU seconds\n" $ (fromIntegral ((t1 - t0) `div` (10^10)) / 100 :: Double) :: IO ()
-
-op a b = trans $ (trans a) <> (trans b)
-
-op2 a b = trans $ (trans a) + (trans b)
-
-rot' :: Double -> Matrix Double
-rot' a = matrix [[ c,0,s],
-                 [ 0,1,0],
-                 [-s,0,c]]
-    where c = cos a
-          s = sin a
-          matrix = fromLists
-
-rot :: Double -> Matrix Double
-rot a = (3><3) [ c,0,s
-               , 0,1,0
-               ,-s,0,c ]
-    where c = cos a
-          s = sin a
-
-fun n r = foldl1' (<>) (map r angles)
-    where angles = toList $ linspace n (0,1)
-
-main = do
-    args <- getArgs
-    let [p,n,d] = map read args
-    let ms = replicate n ((ident d :: Matrix Double))
-    let mz = replicate n (diag (constant (0::Double) d))
-    timing $ case p of
-        0 -> print $ foldl1' (<>) ms
-        1 -> print $ foldl1' (<>) (map trans ms)
-        2 -> print $ foldl1' op ms
-        3 -> print $ foldl1' op2 mz
-        4 -> print $ fun n rot'
-        5 -> print $ fun n rot
diff --git a/examples/experiments/speed.m b/examples/experiments/speed.m
deleted file mode 100644
--- a/examples/experiments/speed.m
+++ /dev/null
@@ -1,21 +0,0 @@
-#! /usr/bin/octave -qf
-1; % measuring Octave computing times
-
-function r = rot(a)
-    c = cos(a);
-    s = sin(a);
-    r = [ c , 0, s;
-          0,  1, 0;
-         -s,  0, c];
-end
-
-t0=time();
-x = linspace(0,1,1E5);
-ac = eye(3);
-for a = x
-    ac = ac*rot(a);
-end
-
-format long
-disp(ac);
-printf("%.2f seconds\n",time()-t0)
diff --git a/examples/experiments/testmnist.m b/examples/experiments/testmnist.m
deleted file mode 100644
--- a/examples/experiments/testmnist.m
+++ /dev/null
@@ -1,29 +0,0 @@
-#! /usr/bin/octave -qf
-% measuring Octave computing times
-
-t0=time();
-load mnist.txt
-disp("load");
-disp(time()-t0)
-
-
-x = mnist(:,1:784);
-d = mnist(:,785);
-
-
-t0=time();
-xc = x - repmat(mean(x),rows(x),1);
-disp("x - repmat(mean(x),rows(x),1)");
-disp(time()-t0)
-
-t0=time();
-mc = (xc'*xc)/rows(x);
-disp("(xc'*xc)/rows(x)");
-disp(time()-t0)
-
-t0=time();
-[v,l]=eig(mc);
-disp("eig");
-disp(time()-t0)
-
-disp(flipud(diag(l))(1:10));
diff --git a/examples/minimize.hs b/examples/minimize.hs
--- a/examples/minimize.hs
+++ b/examples/minimize.hs
@@ -4,20 +4,14 @@
 import Graphics.Plot
 import Text.Printf(printf)
 
--- the function to be minimized 
+-- the function to be minimized
 f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
 
--- its gradient
+-- exact gradient
 df [x,y] = [20*(x-1), 40*(y-2)]
 
--- the conjugate gradient method
-minimizeCG = minimizeConjugateGradient 1E-2 1E-4 1E-3 30
-
--- the BFGS2 method
-minimizeBFGS2 = minimizeVectorBFGS2 1E-2 1E-2 1E-3 30
-
 -- a minimization algorithm which does not require the gradient
-minimizeS f xi = minimizeNMSimplex f xi (replicate (length xi) 1) 1E-2 100
+minimizeS f xi = minimize NMSimplex2 1E-2 100 (replicate (length xi) 1) f xi
 
 -- Numerical estimation of the gradient
 gradient f v = [partialDerivative k f v | k <- [0 .. length v -1]]
@@ -26,31 +20,31 @@
     g x = f (concat [a,x:b])
     (a,_:b) = splitAt n v
 
-main = do
-    putStrLn "BFGS2 with true gradient"
-    let (s,p) = minimizeBFGS2 f df [5,7]
-    print s -- solution
-    disp p -- evolution of the algorithm
-    let [x,y] = drop 2 (toColumns p)
-    mplot [x,y]  -- path from the starting point to the solution
+disp = putStrLn . format "  " (printf "%.3f")
 
-    putStrLn "conjugate gradient with true gradient"
-    let (s,p) = minimizeCG f df [5,7]
+allMethods :: (Enum a, Bounded a) => [a]
+allMethods = [minBound .. maxBound]
+
+test method = do
+    print method
+    let (s,p) = minimize method 1E-2 30 [1,1] f [5,7]
     print s
     disp p
-    let [x,y] = drop 2 (toColumns p)
-    mplot [x,y]
 
-    putStrLn "conjugate gradient with estimated gradient"
-    let (s,p) = minimizeCG f (gradient f) [5,7]
+testD method = do
+    print method
+    let (s,p) = minimizeD method 1E-3 30 1E-2 1E-4 f df [5,7]
     print s
     disp p
-    mplot $ drop 2 (toColumns p)
 
-    putStrLn "without gradient, using the NM Simplex method"
-    let (s,p) = minimizeS f [5,7]
+testD' method = do
+    putStrLn $ show method ++ " with estimated gradient"
+    let (s,p) = minimizeD method 1E-3 30 1E-2 1E-4 f (gradient f) [5,7]
     print s
     disp p
-    mplot $ drop 3 (toColumns p)
 
-disp = putStrLn . format "  " (printf "%.2f")
+main = do
+    mapM_ test [NMSimplex, NMSimplex2]
+    mapM_ testD allMethods
+    testD' ConjugateFR
+    mplot $ drop 3 . toColumns . snd $ minimizeS f [5,7]
diff --git a/examples/parallel.hs b/examples/parallel.hs
new file mode 100644
--- /dev/null
+++ b/examples/parallel.hs
@@ -0,0 +1,36 @@
+import System(getArgs)
+import Numeric.LinearAlgebra
+import Control.Parallel.Strategies
+import System.Time
+
+inParallel = parMap rwhnf id
+
+parMul p x y = fromBlocks [ inParallel ( map (x <>) ys ) ]
+    where ys = splitColumns p y
+
+
+main = do
+    n <- (read . head) `fmap` getArgs
+    let m = ident n :: Matrix Double
+    time $ print $ vectorMax $ takeDiag $ m <> m
+    time $ print $ vectorMax $ takeDiag $ parMul 2 m m
+    time $ print $ vectorMax $ takeDiag $ parMul 4 m m
+    time $ print $ vectorMax $ takeDiag $ parMul 8 m m
+
+time act = do
+    t0 <- getClockTime
+    act
+    t1 <- getClockTime
+    print $ tdSec $ normalizeTimeDiff $ diffClockTimes t1 t0
+
+splitColumns n m = splitColumns' (f n (cols m)) m
+    where
+    splitColumns' [] m = []
+    splitColumns' ((a,b):rest) m = subMatrix (0,a) (rows m, b-a+1) m : splitColumns' rest m
+
+    f :: Int -> Int -> [(Int,Int)]
+    f n c = zip ks (map pred $ tail ks)
+        where ks = map round $ toList $ linspace (fromIntegral n+1) (0,fromIntegral c)
+
+splitRowsAt p m    = (takeRows p m, dropRows p m)
+splitColumnsAt p m = (takeColumns p m, dropColumns p m)
diff --git a/examples/root.hs b/examples/root.hs
new file mode 100644
--- /dev/null
+++ b/examples/root.hs
@@ -0,0 +1,31 @@
+-- root finding examples
+import Numeric.GSL
+import Numeric.LinearAlgebra
+import Text.Printf(printf)
+
+rosenbrock a b [x,y] = [ a*(1-x), b*(y-x^2) ]
+
+test method = do
+    print method
+    let (s,p) = root method 1E-7 30 (rosenbrock 1 10) [-10,-5]
+    print s -- solution
+    disp p -- evolution of the algorithm
+
+jacobian a b [x,y] = [ [-a    , 0]
+                     , [-2*b*x, b] ]
+
+testJ method = do
+    print method
+    let (s,p) = rootJ method 1E-7 30 (rosenbrock 1 10) (jacobian 1 10) [-10,-5]
+    print s
+    disp p
+
+disp = putStrLn . format "  " (printf "%.3f")
+
+main = do
+    test Hybrids
+    test Hybrid
+    test DNewton
+    test Broyden
+
+    mapM_ testJ [HybridsJ .. GNewton]
diff --git a/hmatrix.cabal b/hmatrix.cabal
--- a/hmatrix.cabal
+++ b/hmatrix.cabal
@@ -1,5 +1,5 @@
 Name:               hmatrix
-Version:            0.5.1.1
+Version:            0.5.2.0
 License:            GPL
 License-file:       LICENSE
 Author:             Alberto Ruiz
@@ -11,13 +11,43 @@
                     and other numerical computations, internally implemented using
                     GSL, BLAS and LAPACK.
 Category:           Math
-tested-with:        GHC ==6.10.2
+tested-with:        GHC ==6.10.3
 
 cabal-version:      >=1.2
-build-type:         Simple
+build-type:         Custom
 extra-source-files: lib/Numeric/LinearAlgebra/Tests/quickCheckCompat.h
 
+extra-source-files: configure configure.hs README INSTALL
+extra-tmp-files:    hmatrix.buildinfo
 
+extra-source-files: examples/tests.hs
+                    examples/deriv.hs
+                    examples/integrate.hs
+                    examples/minimize.hs
+                    examples/root.hs
+                    examples/pca1.hs
+                    examples/pca2.hs
+                    examples/pinv.hs
+                    examples/data.txt
+                    examples/lie.hs
+                    examples/kalman.hs
+                    examples/parallel.hs
+                    examples/plot.hs
+                    examples/latexmat.hs
+                    examples/inplace.hs
+                    examples/benchmarks.hs
+                    examples/error.hs
+                    examples/devel/wrappers.hs
+                    examples/devel/functions.hs
+
+extra-source-files: lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.h,
+                    lib/Numeric/LinearAlgebra/LAPACK/clapack.h,
+                    lib/Numeric/GSL/gsl-aux.h
+
+extra-source-files: lib/Numeric/GSL/Special/auto.hs,
+                    lib/Numeric/GSL/Special/autoall.sh,
+                    lib/Numeric/GSL/Special/replace.hs
+
 flag splitBase
     description:    Choose the new smaller, split-up base package.
 
@@ -30,15 +60,14 @@
     default:        False
 
 flag unsafe
-    description: Compile the library with bound checking disabled.
-    default: False
-
+    description:    Compile the library with bound checking disabled.
+    default:        False
 
 library
     if flag(splitBase)
-      build-depends:    base >= 3, array, QuickCheck, HUnit, storable-complex
+      build-depends:    base >= 3 && < 5, array, QuickCheck, HUnit, storable-complex, process
     else
-      build-depends:    base < 3, QuickCheck, HUnit, storable-complex
+      build-depends:    base < 3, QuickCheck, HUnit, storable-complex, process
 
     Build-Depends:      haskell98
     Extensions:         ForeignFunctionInterface,
@@ -53,6 +82,7 @@
                         Numeric.GSL.Fourier,
                         Numeric.GSL.Polynomials,
                         Numeric.GSL.Minimization,
+                        Numeric.GSL.Root,
                         Numeric.GSL.Vector,
                         Numeric.GSL.Special,
                         Numeric.GSL.Special.Gamma,
@@ -89,13 +119,15 @@
                         Numeric.LinearAlgebra.Interface,
                         Numeric.LinearAlgebra.Algorithms,
                         Graphics.Plot,
-                        Numeric.LinearAlgebra.Tests
-                        Data.Packed.Convert
-                        Data.Packed.ST
+                        Numeric.LinearAlgebra.Tests,
+                        Data.Packed.Convert,
+                        Data.Packed.ST,
+                        Data.Packed.Development
     other-modules:      Data.Packed.Internal,
                         Data.Packed.Internal.Common,
                         Data.Packed.Internal.Vector,
                         Data.Packed.Internal.Matrix,
+                        Numeric.GSL.Internal,
                         Numeric.GSL.Special.Internal,
                         Numeric.LinearAlgebra.Tests.Instances,
                         Numeric.LinearAlgebra.Tests.Properties
@@ -104,7 +136,9 @@
 
     ghc-prof-options:   -auto-all
 
-    ghc-options:        -Wall -fno-warn-missing-signatures -fno-warn-orphans -fno-warn-unused-binds
+    ghc-options:        -Wall -fno-warn-missing-signatures
+                              -fno-warn-orphans
+                              -fno-warn-unused-binds
 
     if flag(unsafe)
         cpp-options: -DUNSAFE
@@ -117,30 +151,13 @@
         extra-libraries:   gsl mkl_lapack mkl_intel_lp64 mkl_sequential mkl_core
       else
         extra-libraries:   gsl mkl_lapack mkl_intel mkl_sequential mkl_core
-    else
-      if flag(accelerate)
+
+    if flag(accelerate)
         frameworks: Accelerate
         extra-libraries: gsl
-      else
 
-        extra-libraries: gsl lapack
-
-        -- Include additional libraries if they are
-        -- required by your system to link -lgsl -llapack
-
-        -- (In ubuntu/debian cblas is included in blas,
-        --  which is automatically linked by lapack, so
-        -- nothing more is required.)
-
-        -- Examples:
-
-            -------- if blas/cblas are not automatically linked by lapack:
-            -- blas cblas
-
-            -------- Nonoptimized cblas included in gsl:
-            -- gslcblas
+-- The extra-libraries required for GSL and LAPACK
+-- should now be automatically detected by configure(.hs)
 
-            -------- Arch Linux with atlas-lapack:
-            -- f77blas cblas atlas gcc_s
-            -------- Arch Linux with normal blas and lapack:
-            -- blas gslcblas gfortran
+    extra-libraries:
+    extra-lib-dirs:
diff --git a/lib/Data/Packed/Development.hs b/lib/Data/Packed/Development.hs
new file mode 100644
--- /dev/null
+++ b/lib/Data/Packed/Development.hs
@@ -0,0 +1,27 @@
+
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Packed.Development
+-- Copyright   :  (c) Alberto Ruiz 2009
+-- License     :  GPL
+--
+-- Maintainer  :  Alberto Ruiz <aruiz@um.es>
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- The implementation of the 'Vector' and 'Matrix' types is not exposed,
+-- but the library can be easily extended with additional foreign functions
+-- using the tools in this module. Illustrative usage examples can be found
+-- in the @examples\/devel@ folder included in the package.
+--
+-----------------------------------------------------------------------------
+
+module Data.Packed.Development (
+    createVector, createMatrix,
+    Adapt,
+    vec, mat,
+    app1, app2, app3, app4,
+    MatrixOrder(..), orderOf, cmat, fmat,
+) where
+
+import Data.Packed.Internal
diff --git a/lib/Data/Packed/Internal/Common.hs b/lib/Data/Packed/Internal/Common.hs
--- a/lib/Data/Packed/Internal/Common.hs
+++ b/lib/Data/Packed/Internal/Common.hs
@@ -60,6 +60,44 @@
 ww3 w1 o1 w2 o2 w3 o3 f = w1 o1 $ \a1 -> ww2 w2 o2 w3 o3 (f a1)
 ww4 w1 o1 w2 o2 w3 o3 w4 o4 f = w1 o1 $ \a1 -> ww3 w2 o2 w3 o3 w4 o4 (f a1)
 
+type Adapt f t r = t -> ((f -> r) -> IO()) -> IO()
+
+app1 :: f
+     -> Adapt f t (IO CInt)
+     -> t
+     -> String
+     -> IO()
+
+app2 :: f
+     -> Adapt f t1 r
+     -> t1
+     -> Adapt r t2 (IO CInt)
+     -> t2
+     -> String
+     -> IO()
+
+app3 :: f
+     -> Adapt f t1 r1
+     -> t1
+     -> Adapt r1 t2 r2
+     -> t2
+     -> Adapt r2 t3 (IO CInt)
+     -> t3
+     -> String
+     -> IO()
+
+app4 :: f
+     -> Adapt f t1 r1
+     -> t1
+     -> Adapt r1 t2 r2
+     -> t2
+     -> Adapt r2 t3 r3
+     -> t3
+     -> Adapt r3 t4 (IO CInt)
+     -> t4
+     -> String
+     -> IO()
+
 app1 f w1 o1 s = w1 o1 $ \a1 -> f // a1 // check s
 app2 f w1 o1 w2 o2 s = ww2 w1 o1 w2 o2 $ \a1 a2 -> f // a1 // a2 // check s
 app3 f w1 o1 w2 o2 w3 o3 s = ww3 w1 o1 w2 o2 w3 o3 $
diff --git a/lib/Data/Packed/Internal/Matrix.hs b/lib/Data/Packed/Internal/Matrix.hs
--- a/lib/Data/Packed/Internal/Matrix.hs
+++ b/lib/Data/Packed/Internal/Matrix.hs
@@ -74,6 +74,7 @@
 xdat MC {cdat = d } = d
 xdat MF {fdat = d } = d
 
+orderOf :: Matrix t -> MatrixOrder
 orderOf MF{} = ColumnMajor
 orderOf MC{} = RowMajor
 
@@ -82,12 +83,16 @@
 trans MC {rows = r, cols = c, cdat = d } = MF {rows = c, cols = r, fdat = d }
 trans MF {rows = r, cols = c, fdat = d } = MC {rows = c, cols = r, cdat = d }
 
+cmat :: (Element t) => Matrix t -> Matrix t
 cmat m@MC{} = m
 cmat MF {rows = r, cols = c, fdat = d } = MC {rows = r, cols = c, cdat = transdata r d c}
 
+fmat :: (Element t) => Matrix t -> Matrix t
 fmat m@MF{} = m
 fmat MC {rows = r, cols = c, cdat = d } = MF {rows = r, cols = c, fdat = transdata c d r}
 
+-- C-Haskell matrix adapter
+mat :: Adapt (CInt -> CInt -> Ptr t -> r) (Matrix t) r
 mat = withMatrix
 
 withMatrix a f =
@@ -156,7 +161,7 @@
     | otherwise = v `at` (j*r+i)
 {-# INLINE (@@>) #-}
 
--- | Unsafe matrix access without range checking
+--  Unsafe matrix access without range checking
 atM' MC {cols = c, cdat = v} i j = v `at'` (i*c+j)
 atM' MF {rows = r, fdat = v} i j = v `at'` (j*r+i)
 {-# INLINE atM' #-}
@@ -173,6 +178,8 @@
           r | m==0 = d
             | otherwise = error "matrixFromVector"
 
+-- allocates memory for a new matrix
+createMatrix :: (Storable a) => MatrixOrder -> Int -> Int -> IO (Matrix a)
 createMatrix order r c = do
     p <- createVector (r*c)
     return (matrixFromVector order c p)
@@ -344,12 +351,12 @@
 fromComplex z = (r,i) where
     [r,i] = toColumns $ reshape 2 $ asReal z
 
--- | loads a matrix efficiently from formatted ASCII text file (the number of rows and columns must be known in advance).
+-- | loads a matrix from an ASCII file (the number of rows and columns must be known in advance).
 fromFile :: FilePath -> (Int,Int) -> IO (Matrix Double)
 fromFile filename (r,c) = do
     charname <- newCString filename
     res <- createMatrix RowMajor r c
     app1 (c_gslReadMatrix charname) mat res "gslReadMatrix"
-    --free charname  -- TO DO: free the auxiliary CString
+    free charname
     return res
 foreign import ccall "matrix_fscanf" c_gslReadMatrix:: Ptr CChar -> TM
diff --git a/lib/Data/Packed/Internal/Vector.hs b/lib/Data/Packed/Internal/Vector.hs
--- a/lib/Data/Packed/Internal/Vector.hs
+++ b/lib/Data/Packed/Internal/Vector.hs
@@ -18,6 +18,7 @@
 
 import Data.Packed.Internal.Common
 import Foreign
+import Foreign.C.Types(CInt)
 import Complex
 import Control.Monad(when)
 
@@ -36,6 +37,8 @@
       , fptr :: {-# UNPACK #-} !(ForeignPtr t)    -- ^ foreign pointer to the memory block
       }
 
+-- C-Haskell vector adapter
+vec :: Adapt (CInt -> Ptr t -> r) (Vector t) r
 vec = withVector
 
 withVector (V n fp) f = withForeignPtr fp $ \p -> do
@@ -43,7 +46,7 @@
         g (fi n) p
     f v
 
--- | allocates memory for a new vector
+-- allocates memory for a new vector
 createVector :: Storable a => Int -> IO (Vector a)
 createVector n = do
     when (n <= 0) $ error ("trying to createVector of dim "++show n)
@@ -91,10 +94,19 @@
 toList :: Storable a => Vector a -> [a]
 toList v = safeRead v $ peekArray (dim v)
 
--- | an alternative to 'fromList' with explicit dimension, used also in the instances for Show (Vector a).
+{- | An alternative to 'fromList' with explicit dimension. The input
+     list is explicitly truncated if it is too long, so it may safely
+     be used, for instance, with infinite lists.
+
+     This is the format used in the instances for Show (Vector a).
+-}
 (|>) :: (Storable a) => Int -> [a] -> Vector a
 infixl 9 |>
-n |> l = if length l == n then fromList l else error "|> with wrong size"
+n |> l = if length l' == n
+            then fromList l'
+            else error "list too short for |>"
+  where l' = take n l
+
 
 -- | access to Vector elements without range checking
 at' :: Storable a => Vector a -> Int -> a
diff --git a/lib/Data/Packed/Matrix.hs b/lib/Data/Packed/Matrix.hs
--- a/lib/Data/Packed/Matrix.hs
+++ b/lib/Data/Packed/Matrix.hs
@@ -29,7 +29,9 @@
     extractRows,
     ident, diag, diagRect, takeDiag,
     liftMatrix, liftMatrix2,
-    format, readMatrix, fromFile, fromArray2D
+    format,
+    loadMatrix, fromFile, fileDimensions,
+    readMatrix, fromArray2D
 ) where
 
 import Data.Packed.Internal
@@ -37,6 +39,7 @@
 import Data.Packed.Vector
 import Data.List(transpose,intersperse)
 import Data.Array
+import System.Process(readProcess)
 
 -- | creates a matrix from a vertical list of matrices
 joinVert :: Element t => [Matrix t] -> Matrix t
@@ -118,13 +121,24 @@
 
 This is the format produced by the instances of Show (Matrix a), which
 can also be used for input.
+
+The input list is explicitly truncated, so that it can
+safely be used with lists that are too long (like infinite lists).
+
+Example:
+
+@\> (2>|<3)[1..]
+(2><3)
+ [ 1.0, 2.0, 3.0
+ , 4.0, 5.0, 6.0 ]@
+
 -}
 (><) :: (Element a) => Int -> Int -> [a] -> Matrix a
 r >< c = f where
     f l | dim v == r*c = matrixFromVector RowMajor c v
         | otherwise    = error $ "inconsistent list size = "
                                  ++show (dim v) ++" in ("++show r++"><"++show c++")"
-        where v = fromList l
+        where v = fromList $ take (r*c) l
 
 ----------------------------------------------------------------
 
@@ -216,9 +230,27 @@
 dispC d m = disp m (shfc d)
 -}
 
--- | creates a matrix from a table of numbers.
+-- | reads a matrix from a string containing a table of numbers.
 readMatrix :: String -> Matrix Double
 readMatrix = fromLists . map (map read). map words . filter (not.null) . lines
+
+{- |  obtains the number of rows and columns in an ASCII data file
+      (provisionally using unix's wc).
+-}
+fileDimensions :: FilePath -> IO (Int,Int)
+fileDimensions fname = do
+    wcres <- readProcess "wc" ["-w",fname] ""
+    contents <- readFile fname
+    let tot = read . head . words $ wcres
+        c   = length . head . dropWhile null . map words . lines $ contents
+    if tot > 0
+        then return (tot `div` c, c)
+        else return (0,0)
+
+{- | loads a matrix from a formatted ASCII file.
+-}
+loadMatrix :: FilePath -> IO (Matrix Double)
+loadMatrix file = fromFile file =<< fileDimensions file
 
 -- | rearranges the rows of a matrix according to the order given in a list of integers. 
 extractRows :: Element t => [Int] -> Matrix t -> Matrix t
diff --git a/lib/Numeric/GSL.hs b/lib/Numeric/GSL.hs
--- a/lib/Numeric/GSL.hs
+++ b/lib/Numeric/GSL.hs
@@ -18,6 +18,7 @@
 , module Numeric.GSL.Fourier
 , module Numeric.GSL.Polynomials
 , module Numeric.GSL.Minimization
+, module Numeric.GSL.Root
 , module Numeric.GSL.Special
 , module Complex
 , setErrorHandlerOff
@@ -29,6 +30,7 @@
 import Numeric.GSL.Fourier
 import Numeric.GSL.Polynomials
 import Numeric.GSL.Minimization
+import Numeric.GSL.Root
 import Complex
 import Numeric.GSL.Special
 
diff --git a/lib/Numeric/GSL/Internal.hs b/lib/Numeric/GSL/Internal.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Internal.hs
@@ -0,0 +1,64 @@
+-- Module      :  Numeric.GSL.Internal
+-- Copyright   :  (c) Alberto Ruiz 2009
+-- License     :  GPL
+--
+-- Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+-- Stability   :  provisional
+-- Portability :  uses ffi
+--
+-- Auxiliary functions.
+--
+-- #hide
+
+module Numeric.GSL.Internal where
+
+import Data.Packed.Internal
+import Foreign
+import Foreign.C.Types(CInt)
+
+iv :: (Vector Double -> Double) -> (CInt -> Ptr Double -> Double)
+iv f n p = f (createV (fromIntegral n) copy "iv") where
+    copy n' q = do
+        copyArray q p (fromIntegral n')
+        return 0
+
+-- | conversion of Haskell functions into function pointers that can be used in the C side
+foreign import ccall "wrapper"
+    mkVecfun :: (CInt -> Ptr Double -> Double)
+             -> IO( FunPtr (CInt -> Ptr Double -> Double))
+
+foreign import ccall "wrapper"
+    mkVecVecfun :: TVV -> IO (FunPtr TVV)
+
+aux_vTov :: (Vector Double -> Vector Double) -> TVV
+aux_vTov f n p nr r = g where
+    V {fptr = pr} = f x
+    x = createV (fromIntegral n) copy "aux_vTov"
+    copy n' q = do
+        copyArray q p (fromIntegral n')
+        return 0
+    g = do withForeignPtr pr $ \p' -> copyArray r p' (fromIntegral nr)
+           return 0
+
+foreign import ccall "wrapper"
+    mkVecMatfun :: TVM -> IO (FunPtr TVM)
+
+aux_vTom :: (Vector Double -> Matrix Double) -> TVM
+aux_vTom f n p rr cr r = g where
+    V {fptr = pr} = flatten $ f x
+    x = createV (fromIntegral n) copy "aux_vTov"
+    copy n' q = do
+        copyArray q p (fromIntegral n')
+        return 0
+    g = do withForeignPtr pr $ \p' -> copyArray r p' (fromIntegral $ rr*cr)
+           return 0
+
+createV n fun msg = unsafePerformIO $ do
+    r <- createVector n
+    app1 fun vec r msg
+    return r
+
+createMIO r c fun msg = do
+    res <- createMatrix RowMajor r c
+    app1 fun mat res msg
+    return res
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
--- a/lib/Numeric/GSL/Minimization.hs
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -13,12 +13,49 @@
 
 <http://www.gnu.org/software/gsl/manual/html_node/Multidimensional-Minimization.html>
 
+The example in the GSL manual:
+
+@
+
+f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
+
+main = do
+    let (s,p) = minimize NMSimplex2 1E-2 30 [1,1] f [5,7]
+    print s
+    print p
+
+\> main
+[0.9920430849306288,1.9969168063253182]
+ 0.000  512.500  1.130  6.500  5.000
+ 1.000  290.625  1.409  5.250  4.000
+ 2.000  290.625  1.409  5.250  4.000
+ 3.000  252.500  1.409  5.500  1.000
+ ...
+22.000   30.001  0.013  0.992  1.997
+23.000   30.001  0.008  0.992  1.997
+@
+
+The path to the solution can be graphically shown by means of:
+
+@'Graphics.Plot.mplot' $ drop 3 ('toColumns' p)@
+
+Taken from the GSL manual:
+
+The vector Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm is a quasi-Newton method which builds up an approximation to the second derivatives of the function f using the difference between successive gradient vectors. By combining the first and second derivatives the algorithm is able to take Newton-type steps towards the function minimum, assuming quadratic behavior in that region.
+
+The bfgs2 version of this minimizer is the most efficient version available, and is a faithful implementation of the line minimization scheme described in Fletcher's Practical Methods of Optimization, Algorithms 2.6.2 and 2.6.4. It supercedes the original bfgs routine and requires substantially fewer function and gradient evaluations. The user-supplied tolerance tol corresponds to the parameter \sigma used by Fletcher. A value of 0.1 is recommended for typical use (larger values correspond to less accurate line searches).
+
+The nmsimplex2 version is a new O(N) implementation of the earlier O(N^2) nmsimplex minimiser. It calculates the size of simplex as the rms distance of each vertex from the center rather than the mean distance, which has the advantage of allowing a linear update.
+
 -}
+
 -----------------------------------------------------------------------------
 module Numeric.GSL.Minimization (
+    minimize, MinimizeMethod(..),
+    minimizeD, MinimizeMethodD(..),
+    minimizeNMSimplex,
     minimizeConjugateGradient,
-    minimizeVectorBFGS2,
-    minimizeNMSimplex
+    minimizeVectorBFGS2
 ) where
 
 
@@ -26,69 +63,69 @@
 import Data.Packed.Matrix
 import Foreign
 import Foreign.C.Types(CInt)
+import Numeric.GSL.Internal
 
+------------------------------------------------------------------------
+
+{-# DEPRECATED minimizeNMSimplex "use minimize NMSimplex2 eps maxit sizes f xi" #-}
+minimizeNMSimplex f xi szs eps maxit = minimize NMSimplex eps maxit szs f xi
+
+{-# DEPRECATED minimizeConjugateGradient "use minimizeD ConjugateFR eps maxit step tol f g xi" #-}
+minimizeConjugateGradient step tol eps maxit f g xi = minimizeD ConjugateFR eps maxit step tol f g xi
+
+{-# DEPRECATED minimizeVectorBFGS2 "use minimizeD VectorBFGS2 eps maxit step tol f g xi" #-}
+minimizeVectorBFGS2 step tol eps maxit f g xi = minimizeD VectorBFGS2 eps maxit step tol f g xi
+
 -------------------------------------------------------------------------
 
-{- | The method of Nelder and Mead, implemented by /gsl_multimin_fminimizer_nmsimplex/. The gradient of the function is not required. This is the example in the GSL manual:
+data MinimizeMethod = NMSimplex
+                    | NMSimplex2
+                    deriving (Enum,Eq,Show,Bounded)
 
-@minimize f xi = minimizeNMSimplex f xi (replicate (length xi) 1) 1e-2 100
-\  -- 
-f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
-\  --
-main = do
-    let (s,p) = minimize f [5,7]
-    print s
-    print p
-\  --
-\> main
-[0.9920430849306285,1.9969168063253164]
-0. 512.500    1.082 6.500    5.
- 1. 290.625    1.372 5.250    4.
- 2. 290.625    1.372 5.250    4.
- 3. 252.500    1.372 5.500    1.
- 4. 101.406    1.823 2.625 3.500
- 5. 101.406    1.823 2.625 3.500
- 6.     60.    1.823    0.    3.
- 7.  42.275    1.303 2.094 1.875
- 8.  42.275    1.303 2.094 1.875
- 9.  35.684    1.026 0.258 1.906
-10.  35.664    0.804 0.588 2.445
-11.  30.680    0.467 1.258 2.025
-12.  30.680    0.356 1.258 2.025
-13.  30.539    0.285 1.093 1.849
-14.  30.137    0.168 0.883 2.004
-15.  30.137    0.123 0.883 2.004
-16.  30.090    0.100 0.958 2.060
-17.  30.005 6.051e-2 1.022 2.004
-18.  30.005 4.249e-2 1.022 2.004
-19.  30.005 4.249e-2 1.022 2.004
-20.  30.005 2.742e-2 1.022 2.004
-21.  30.005 2.119e-2 1.022 2.004
-22.  30.001 1.530e-2 0.992 1.997
-23.  30.001 1.259e-2 0.992 1.997
-24.  30.001 7.663e-3 0.992 1.997@
+-- | Minimization without derivatives.
+minimize :: MinimizeMethod
+         -> Double              -- ^ desired precision of the solution (size test)
+         -> Int                 -- ^ maximum number of iterations allowed
+         -> [Double]            -- ^ sizes of the initial search box
+         -> ([Double] -> Double) -- ^ function to minimize
+         -> [Double]            -- ^ starting point
+         -> ([Double], Matrix Double) -- ^ solution vector and optimization path
 
-The path to the solution can be graphically shown by means of:
+minimize method = minimizeGen (fi (fromEnum method))
 
-@'Graphics.Plot.mplot' $ drop 3 ('toColumns' p)@
+data MinimizeMethodD = ConjugateFR
+                     | ConjugatePR
+                     | VectorBFGS
+                     | VectorBFGS2
+                     | SteepestDescent
+                     deriving (Enum,Eq,Show,Bounded)
 
--}
-minimizeNMSimplex :: ([Double] -> Double) -- ^ function to minimize
-          -> [Double]            -- ^ starting point
-          -> [Double]            -- ^ sizes of the initial search box
-          -> Double              -- ^ desired precision of the solution
-          -> Int                 -- ^ maximum number of iterations allowed
-          -> ([Double], Matrix Double)
-          -- ^ solution vector, and the optimization trajectory followed by the algorithm
-minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do
+-- | Minimization with derivatives.
+minimizeD :: MinimizeMethodD
+    -> Double                 -- ^ desired precision of the solution (gradient test)
+    -> Int                    -- ^ maximum number of iterations allowed
+    -> Double                 -- ^ size of the first trial step
+    -> Double                 -- ^ tol (precise meaning depends on method)
+    -> ([Double] -> Double)   -- ^ function to minimize
+    -> ([Double] -> [Double]) -- ^ gradient
+    -> [Double]               -- ^ starting point
+    -> ([Double], Matrix Double) -- ^ solution vector and optimization path
+
+minimizeD method = minimizeDGen (fi (fromEnum method))
+
+-------------------------------------------------------------------------
+
+
+
+minimizeGen method eps maxit sz f xi = unsafePerformIO $ do
     let xiv = fromList xi
         szv = fromList sz
         n   = dim xiv
     fp <- mkVecfun (iv (f.toList))
     rawpath <- ww2 withVector xiv withVector szv $ \xiv' szv' ->
                    createMIO maxit (n+3)
-                         (c_minimizeNMSimplex fp tol (fi maxit) // xiv' // szv')
-                         "minimizeNMSimplex"
+                         (c_minimize method fp eps (fi maxit) // xiv' // szv')
+                         "minimize"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
         [sol] = toLists $ dropRows (it-1) path
@@ -97,83 +134,23 @@
 
 
 foreign import ccall "gsl-aux.h minimize"
-    c_minimizeNMSimplex:: FunPtr (CInt -> Ptr Double -> Double) -> Double -> CInt -> TVVM
+    c_minimize:: CInt -> FunPtr (CInt -> Ptr Double -> Double) -> Double -> CInt -> TVVM
 
 ----------------------------------------------------------------------------------
 
-{- | The Fletcher-Reeves conjugate gradient algorithm /gsl_multimin_fminimizer_conjugate_fr/. This is the example in the GSL manual:
 
-@minimize = minimizeConjugateGradient 1E-2 1E-4 1E-3 30
-f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
-\  --
-df [x,y] = [20*(x-1), 40*(y-2)]
-\   --
-main = do
-    let (s,p) = minimize f df [5,7]
-    print s
-    print p
-\  --
-\> main
-[1.0,2.0]
- 0. 687.848 4.996 6.991
- 1. 683.555 4.989 6.972
- 2. 675.013 4.974 6.935
- 3. 658.108 4.944 6.861
- 4. 625.013 4.885 6.712
- 5. 561.684 4.766 6.415
- 6. 446.467 4.528 5.821
- 7. 261.794 4.053 4.632
- 8.  75.498 3.102 2.255
- 9.  67.037 2.852 1.630
-10.  45.316 2.191 1.762
-11.  30.186 0.869 2.026
-12.     30.    1.    2.@
 
-The path to the solution can be graphically shown by means of:
-
-@'Graphics.Plot.mplot' $ drop 2 ('toColumns' p)@
-
--}
-minimizeConjugateGradient ::
-       Double        -- ^ initial step size
-    -> Double        -- ^ minimization parameter   
-    -> Double        -- ^ desired precision of the solution (gradient test)
-    -> Int           -- ^ maximum number of iterations allowed
-    -> ([Double] -> Double) -- ^ function to minimize
-    -> ([Double] -> [Double])      -- ^ gradient
-    -> [Double]             -- ^ starting point
-    -> ([Double], Matrix Double)        -- ^ solution vector, and the optimization trajectory followed by the algorithm
-minimizeConjugateGradient = minimizeWithDeriv 0
-
-{- | Taken from the GSL manual:
-
-The vector Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm. This is a quasi-Newton method which builds up an approximation to the second derivatives of the function f using the difference between successive gradient vectors. By combining the first and second derivatives the algorithm is able to take Newton-type steps towards the function minimum, assuming quadratic behavior in that region.
-
-The bfgs2 version of this minimizer is the most efficient version available, and is a faithful implementation of the line minimization scheme described in Fletcher's Practical Methods of Optimization, Algorithms 2.6.2 and 2.6.4. It supercedes the original bfgs routine and requires substantially fewer function and gradient evaluations. The user-supplied tolerance tol corresponds to the parameter \sigma used by Fletcher. A value of 0.1 is recommended for typical use (larger values correspond to less accurate line searches).
--}
-minimizeVectorBFGS2 ::
-       Double        -- ^ initial step size
-    -> Double        -- ^ minimization parameter tol
-    -> Double        -- ^ desired precision of the solution (gradient test)
-    -> Int           -- ^ maximum number of iterations allowed
-    -> ([Double] -> Double) -- ^ function to minimize
-    -> ([Double] -> [Double])      -- ^ gradient
-    -> [Double]             -- ^ starting point
-    -> ([Double], Matrix Double)        -- ^ solution vector, and the optimization trajectory followed by the algorithm
-minimizeVectorBFGS2 = minimizeWithDeriv 1
-
-
-minimizeWithDeriv method istep minimpar tol maxit f df xi = unsafePerformIO $ do
+minimizeDGen method eps maxit istep tol f df xi = unsafePerformIO $ do
     let xiv = fromList xi
         n = dim xiv
         f' = f . toList
-        df' = (fromList . df . toList)
+        df' = (checkdim1 n .fromList . df . toList)
     fp <- mkVecfun (iv f')
     dfp <- mkVecVecfun (aux_vTov df')
     rawpath <- withVector xiv $ \xiv' ->
                     createMIO maxit (n+2)
-                         (c_minimizeWithDeriv method fp dfp istep minimpar tol (fi maxit) // xiv')
-                         "minimizeDerivV"
+                         (c_minimizeD method fp dfp istep tol eps (fi maxit) // xiv')
+                         "minimizeD"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
         sol = toList $ cdat $ dropColumns 2 $ dropRows (it-1) path
@@ -181,46 +158,16 @@
     freeHaskellFunPtr dfp
     return (sol,path)
 
-foreign import ccall "gsl-aux.h minimizeWithDeriv"
-    c_minimizeWithDeriv :: CInt -> FunPtr (CInt -> Ptr Double -> Double)
-                                -> FunPtr (CInt -> Ptr Double -> Ptr Double -> IO ())
-                                -> Double -> Double -> Double -> CInt
-                                -> TVM
+foreign import ccall "gsl-aux.h minimizeD"
+    c_minimizeD :: CInt
+                -> FunPtr (CInt -> Ptr Double -> Double)
+                -> FunPtr TVV
+                -> Double -> Double -> Double -> CInt
+                -> TVM
 
 ---------------------------------------------------------------------
-iv :: (Vector Double -> Double) -> (CInt -> Ptr Double -> Double)
-iv f n p = f (createV (fromIntegral n) copy "iv") where
-    copy n' q = do
-        copyArray q p (fromIntegral n')
-        return 0
 
--- | conversion of Haskell functions into function pointers that can be used in the C side
-foreign import ccall "wrapper"
-    mkVecfun :: (CInt -> Ptr Double -> Double)
-             -> IO( FunPtr (CInt -> Ptr Double -> Double))
-
--- | another required conversion
-foreign import ccall "wrapper"
-    mkVecVecfun :: (CInt -> Ptr Double -> Ptr Double -> IO ())
-                -> IO (FunPtr (CInt -> Ptr Double -> Ptr Double->IO()))
-
-aux_vTov :: (Vector Double -> Vector Double) -> (CInt -> Ptr Double -> Ptr Double -> IO())
-aux_vTov f n p r = g where
-    V {fptr = pr} = f x
-    x = createV (fromIntegral n) copy "aux_vTov"
-    copy n' q = do
-        copyArray q p (fromIntegral n')
-        return 0
-    g = withForeignPtr pr $ \p' -> copyArray r p' (fromIntegral n)
-
---------------------------------------------------------------------
-
-createV n fun msg = unsafePerformIO $ do
-    r <- createVector n
-    app1 fun vec r msg
-    return r
-
-createMIO r c fun msg = do
-    res <- createMatrix RowMajor r c
-    app1 fun mat res msg
-    return res
+checkdim1 n v
+    | dim v == n = v
+    | otherwise = error $ "Error: "++ show n
+                        ++ " components expected in the result of the gradient supplied to minimizeD"
diff --git a/lib/Numeric/GSL/Root.hs b/lib/Numeric/GSL/Root.hs
new file mode 100644
--- /dev/null
+++ b/lib/Numeric/GSL/Root.hs
@@ -0,0 +1,145 @@
+{- |
+Module      :  Numeric.GSL.Root
+Copyright   :  (c) Alberto Ruiz 2009
+License     :  GPL
+
+Maintainer  :  Alberto Ruiz (aruiz at um dot es)
+Stability   :  provisional
+Portability :  uses ffi
+
+Multidimensional root finding.
+
+<http://www.gnu.org/software/gsl/manual/html_node/Multidimensional-Root_002dFinding.html>
+
+The example in the GSL manual:
+
+@import Numeric.GSL
+import Numeric.LinearAlgebra(format)
+import Text.Printf(printf)
+
+rosenbrock a b [x,y] = [ a*(1-x), b*(y-x^2) ]
+
+disp = putStrLn . format \"  \" (printf \"%.3f\")
+
+main = do
+    let (sol,path) = root Hybrids 1E-7 30 (rosenbrock 1 10) [-10,-5]
+    print sol
+    disp path
+
+\> main
+[1.0,1.0]
+ 0.000  -10.000  -5.000  11.000  -1050.000
+ 1.000   -3.976  24.827   4.976     90.203
+ 2.000   -3.976  24.827   4.976     90.203
+ 3.000   -3.976  24.827   4.976     90.203
+ 4.000   -1.274  -5.680   2.274    -73.018
+ 5.000   -1.274  -5.680   2.274    -73.018
+ 6.000    0.249   0.298   0.751      2.359
+ 7.000    0.249   0.298   0.751      2.359
+ 8.000    1.000   0.878  -0.000     -1.218
+ 9.000    1.000   0.989  -0.000     -0.108
+10.000    1.000   1.000   0.000      0.000
+@
+
+-}
+-----------------------------------------------------------------------------
+
+module Numeric.GSL.Root (
+    root, RootMethod(..),
+    rootJ, RootMethodJ(..),
+) where
+
+import Data.Packed.Internal
+import Data.Packed.Matrix
+import Foreign
+import Foreign.C.Types(CInt)
+import Numeric.GSL.Internal
+
+-------------------------------------------------------------------------
+
+data RootMethod = Hybrids
+                | Hybrid
+                | DNewton
+                | Broyden
+                deriving (Enum,Eq,Show,Bounded)
+
+-- | Nonlinear multidimensional root finding using algorithms that do not require 
+-- any derivative information to be supplied by the user.
+-- Any derivatives needed are approximated by finite differences.
+root :: RootMethod
+     -> Double                     -- ^ maximum residual
+     -> Int                        -- ^ maximum number of iterations allowed
+     -> ([Double] -> [Double])     -- ^ function to minimize
+     -> [Double]                   -- ^ starting point
+     -> ([Double], Matrix Double)  -- ^ solution vector and optimization path
+
+root method epsabs maxit fun xinit = rootGen (fi (fromEnum method)) fun xinit epsabs maxit
+
+rootGen m f xi epsabs maxit = unsafePerformIO $ do
+    let xiv = fromList xi
+        n   = dim xiv
+    fp <- mkVecVecfun (aux_vTov (checkdim1 n . fromList . f . toList))
+    rawpath <- withVector xiv $ \xiv' ->
+                   createMIO maxit (2*n+1)
+                         (c_root m fp epsabs (fi maxit) // xiv')
+                         "root"
+    let it = round (rawpath @@> (maxit-1,0))
+        path = takeRows it rawpath
+        [sol] = toLists $ dropRows (it-1) path
+    freeHaskellFunPtr fp
+    return (take n $ drop 1 sol, path)
+
+
+foreign import ccall "root"
+    c_root:: CInt -> FunPtr TVV -> Double -> CInt -> TVM
+
+-------------------------------------------------------------------------
+
+data RootMethodJ = HybridsJ
+                 | HybridJ
+                 | Newton
+                 | GNewton
+                deriving (Enum,Eq,Show,Bounded)
+
+-- | Nonlinear multidimensional root finding using both the function and its derivatives.
+rootJ :: RootMethodJ
+      -> Double                     -- ^ maximum residual
+      -> Int                        -- ^ maximum number of iterations allowed
+      -> ([Double] -> [Double])     -- ^ function to minimize
+      -> ([Double] -> [[Double]])   -- ^ Jacobian
+      -> [Double]                   -- ^ starting point
+      -> ([Double], Matrix Double)  -- ^ solution vector and optimization path
+
+rootJ method epsabs maxit fun jac xinit = rootJGen (fi (fromEnum method)) fun jac xinit epsabs maxit
+
+rootJGen m f jac xi epsabs maxit = unsafePerformIO $ do
+    let xiv = fromList xi
+        n   = dim xiv
+    fp <- mkVecVecfun (aux_vTov (checkdim1 n . fromList . f . toList))
+    jp <- mkVecMatfun (aux_vTom (checkdim2 n . fromLists . jac . toList))
+    rawpath <- withVector xiv $ \xiv' ->
+                   createMIO maxit (2*n+1)
+                         (c_rootj m fp jp epsabs (fi maxit) // xiv')
+                         "root"
+    let it = round (rawpath @@> (maxit-1,0))
+        path = takeRows it rawpath
+        [sol] = toLists $ dropRows (it-1) path
+    freeHaskellFunPtr fp
+    freeHaskellFunPtr jp
+    return (take n $ drop 1 sol, path)
+
+
+foreign import ccall "rootj"
+    c_rootj:: CInt -> FunPtr TVV -> FunPtr TVM -> Double -> CInt -> TVM
+
+-------------------------------------------------------
+
+checkdim1 n v
+    | dim v == n = v
+    | otherwise = error $ "Error: "++ show n
+                        ++ " components expected in the result of the function supplied to root"
+
+checkdim2 n m
+    | rows m == n && cols m == n = m
+    | otherwise = error $ "Error: "++ show n ++ "x" ++ show n
+                        ++ " Jacobian expected in rootJ"
diff --git a/lib/Numeric/GSL/Special/Airy.hs b/lib/Numeric/GSL/Special/Airy.hs
--- a/lib/Numeric/GSL/Special/Airy.hs
+++ b/lib/Numeric/GSL/Special/Airy.hs
@@ -51,165 +51,165 @@
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_e :: Double -> Precision -> (Double,Double)
 airy_Ai_e x mode = createSFR "airy_Ai_e" $ gsl_sf_airy_Ai_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Ai(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai :: Double -> Precision -> Double
 airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Bi_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_e :: Double -> Precision -> (Double,Double)
 airy_Bi_e x mode = createSFR "airy_Bi_e" $ gsl_sf_airy_Bi_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Bi(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi :: Double -> Precision -> Double
 airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Ai_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Ai_scaled_e x mode = createSFR "airy_Ai_scaled_e" $ gsl_sf_airy_Ai_scaled_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Ai_scaled(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_scaled :: Double -> Precision -> Double
 airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Bi_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Bi_scaled_e x mode = createSFR "airy_Bi_scaled_e" $ gsl_sf_airy_Bi_scaled_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Bi_scaled(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_scaled :: Double -> Precision -> Double
 airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Ai_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_deriv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_deriv_e :: Double -> Precision -> (Double,Double)
 airy_Ai_deriv_e x mode = createSFR "airy_Ai_deriv_e" $ gsl_sf_airy_Ai_deriv_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Ai_deriv(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_deriv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_deriv :: Double -> Precision -> Double
 airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Bi_deriv_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_deriv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_deriv_e :: Double -> Precision -> (Double,Double)
 airy_Bi_deriv_e x mode = createSFR "airy_Bi_deriv_e" $ gsl_sf_airy_Bi_deriv_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Bi_deriv(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_deriv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_deriv :: Double -> Precision -> Double
 airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Ai_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_deriv_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_deriv_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Ai_deriv_scaled_e x mode = createSFR "airy_Ai_deriv_scaled_e" $ gsl_sf_airy_Ai_deriv_scaled_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Ai_deriv_scaled(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Ai_deriv_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Ai_deriv_scaled :: Double -> Precision -> Double
 airy_Ai_deriv_scaled x mode = gsl_sf_airy_Ai_deriv_scaled x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_Bi_deriv_scaled_e(double x,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_deriv_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_deriv_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Bi_deriv_scaled_e x mode = createSFR "airy_Bi_deriv_scaled_e" $ gsl_sf_airy_Bi_deriv_scaled_e x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_Bi_deriv_scaled(double x,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_Bi_deriv_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_Bi_deriv_scaled :: Double -> Precision -> Double
 airy_Bi_deriv_scaled x mode = gsl_sf_airy_Bi_deriv_scaled x  (precCode mode)
-foreign import ccall "airy.h gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_airy_zero_Ai_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Ai_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "airy.h gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_zero_Ai(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Ai&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_zero_Ai :: CInt -> Double
 airy_zero_Ai = gsl_sf_airy_zero_Ai
-foreign import ccall "airy.h gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double
+foreign import ccall "gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double
 
 -- | wrapper for int gsl_sf_airy_zero_Bi_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Bi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "airy.h gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_zero_Bi(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Bi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_zero_Bi :: CInt -> Double
 airy_zero_Bi = gsl_sf_airy_zero_Bi
-foreign import ccall "airy.h gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double
+foreign import ccall "gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double
 
 -- | wrapper for int gsl_sf_airy_zero_Ai_deriv_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Ai_deriv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "airy.h gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_zero_Ai_deriv(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Ai_deriv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_zero_Ai_deriv :: CInt -> Double
 airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv
-foreign import ccall "airy.h gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double
+foreign import ccall "gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double
 
 -- | wrapper for int gsl_sf_airy_zero_Bi_deriv_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Bi_deriv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "airy.h gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_airy_zero_Bi_deriv(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_airy_zero_Bi_deriv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 airy_zero_Bi_deriv :: CInt -> Double
 airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv
-foreign import ccall "airy.h gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: CInt -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Bessel.hs
+++ b/lib/Numeric/GSL/Special/Bessel.hs
@@ -114,697 +114,697 @@
 --   <http://www.google.com/search?q=gsl_sf_bessel_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_J0_e :: Double -> (Double,Double)
 bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_J0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_J0 :: Double -> Double
 bessel_J0 = gsl_sf_bessel_J0
-foreign import ccall "bessel.h gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_J1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_J1_e :: Double -> (Double,Double)
 bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_J1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_J1 :: Double -> Double
 bessel_J1 = gsl_sf_bessel_J1
-foreign import ccall "bessel.h gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Jn_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Jn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Jn_e :: CInt -> Double -> (Double,Double)
 bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x
-foreign import ccall "bessel.h gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Jn(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Jn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Jn :: CInt -> Double -> Double
 bessel_Jn = gsl_sf_bessel_Jn
-foreign import ccall "bessel.h gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Jn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Jn_array = gsl_sf_bessel_Jn_array
-foreign import ccall "bessel.h gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_Y0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Y0_e :: Double -> (Double,Double)
 bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Y0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Y0 :: Double -> Double
 bessel_Y0 = gsl_sf_bessel_Y0
-foreign import ccall "bessel.h gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Y1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Y1_e :: Double -> (Double,Double)
 bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Y1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Y1 :: Double -> Double
 bessel_Y1 = gsl_sf_bessel_Y1
-foreign import ccall "bessel.h gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Yn_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Yn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Yn_e :: CInt -> Double -> (Double,Double)
 bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x
-foreign import ccall "bessel.h gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Yn(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Yn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Yn :: CInt -> Double -> Double
 bessel_Yn = gsl_sf_bessel_Yn
-foreign import ccall "bessel.h gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Yn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Yn_array = gsl_sf_bessel_Yn_array
-foreign import ccall "bessel.h gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_I0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I0_e :: Double -> (Double,Double)
 bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_I0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I0 :: Double -> Double
 bessel_I0 = gsl_sf_bessel_I0
-foreign import ccall "bessel.h gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_I1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I1_e :: Double -> (Double,Double)
 bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_I1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I1 :: Double -> Double
 bessel_I1 = gsl_sf_bessel_I1
-foreign import ccall "bessel.h gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_In_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In_e :: CInt -> Double -> (Double,Double)
 bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x
-foreign import ccall "bessel.h gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_In(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In :: CInt -> Double -> Double
 bessel_In = gsl_sf_bessel_In
-foreign import ccall "bessel.h gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_In_array = gsl_sf_bessel_In_array
-foreign import ccall "bessel.h gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_I0_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I0_scaled_e :: Double -> (Double,Double)
 bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_I0_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I0_scaled :: Double -> Double
 bessel_I0_scaled = gsl_sf_bessel_I0_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_I1_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I1_scaled_e :: Double -> (Double,Double)
 bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_I1_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_I1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_I1_scaled :: Double -> Double
 bessel_I1_scaled = gsl_sf_bessel_I1_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_In_scaled_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In_scaled_e :: 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 "bessel.h gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_In_scaled(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In_scaled :: CInt -> Double -> Double
 bessel_In_scaled = gsl_sf_bessel_In_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_In_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array
-foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_K0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K0_e :: Double -> (Double,Double)
 bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_K0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K0 :: Double -> Double
 bessel_K0 = gsl_sf_bessel_K0
-foreign import ccall "bessel.h gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_K1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K1_e :: Double -> (Double,Double)
 bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_K1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K1 :: Double -> Double
 bessel_K1 = gsl_sf_bessel_K1
-foreign import ccall "bessel.h gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Kn_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn_e :: CInt -> Double -> (Double,Double)
 bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x
-foreign import ccall "bessel.h gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Kn(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn :: CInt -> Double -> Double
 bessel_Kn = gsl_sf_bessel_Kn
-foreign import ccall "bessel.h gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Kn_array = gsl_sf_bessel_Kn_array
-foreign import ccall "bessel.h gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_K0_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K0_scaled_e :: Double -> (Double,Double)
 bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_K0_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K0_scaled :: Double -> Double
 bessel_K0_scaled = gsl_sf_bessel_K0_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_K1_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K1_scaled_e :: Double -> (Double,Double)
 bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_K1_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_K1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_K1_scaled :: Double -> Double
 bessel_K1_scaled = gsl_sf_bessel_K1_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Kn_scaled_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn_scaled_e :: 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 "bessel.h gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Kn_scaled(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn_scaled :: CInt -> Double -> Double
 bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Kn_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array
-foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_j0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j0_e :: Double -> (Double,Double)
 bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_j0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j0 :: Double -> Double
 bessel_j0 = gsl_sf_bessel_j0
-foreign import ccall "bessel.h gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_j1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j1_e :: Double -> (Double,Double)
 bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_j1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j1 :: Double -> Double
 bessel_j1 = gsl_sf_bessel_j1
-foreign import ccall "bessel.h gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_j2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j2_e :: Double -> (Double,Double)
 bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x
-foreign import ccall "bessel.h gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_j2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_j2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_j2 :: Double -> Double
 bessel_j2 = gsl_sf_bessel_j2
-foreign import ccall "bessel.h gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_jl_e(int l,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_jl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_jl_e :: CInt -> Double -> (Double,Double)
 bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x
-foreign import ccall "bessel.h gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_jl(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_jl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_jl :: CInt -> Double -> Double
 bessel_jl = gsl_sf_bessel_jl
-foreign import ccall "bessel.h gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_jl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_jl_array = gsl_sf_bessel_jl_array
-foreign import ccall "bessel.h gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_jl_steed_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array
-foreign import ccall "bessel.h gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_y0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y0_e :: Double -> (Double,Double)
 bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x
-foreign import ccall "bessel.h gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_y0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y0 :: Double -> Double
 bessel_y0 = gsl_sf_bessel_y0
-foreign import ccall "bessel.h gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_y1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y1_e :: Double -> (Double,Double)
 bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x
-foreign import ccall "bessel.h gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_y1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y1 :: Double -> Double
 bessel_y1 = gsl_sf_bessel_y1
-foreign import ccall "bessel.h gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_y2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y2_e :: Double -> (Double,Double)
 bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x
-foreign import ccall "bessel.h gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_y2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_y2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_y2 :: Double -> Double
 bessel_y2 = gsl_sf_bessel_y2
-foreign import ccall "bessel.h gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
+foreign import ccall "gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_yl_e(int l,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_yl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_yl_e :: CInt -> Double -> (Double,Double)
 bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x
-foreign import ccall "bessel.h gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_yl(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_yl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_yl :: CInt -> Double -> Double
 bessel_yl = gsl_sf_bessel_yl
-foreign import ccall "bessel.h gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_yl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_yl_array = gsl_sf_bessel_yl_array
-foreign import ccall "bessel.h gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_i0_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i0_scaled_e :: Double -> (Double,Double)
 bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_i0_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i0_scaled :: Double -> Double
 bessel_i0_scaled = gsl_sf_bessel_i0_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_i1_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i1_scaled_e :: Double -> (Double,Double)
 bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_i1_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i1_scaled :: Double -> Double
 bessel_i1_scaled = gsl_sf_bessel_i1_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_i2_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i2_scaled_e :: Double -> (Double,Double)
 bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_i2_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_i2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_i2_scaled :: Double -> Double
 bessel_i2_scaled = gsl_sf_bessel_i2_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_il_scaled_e(int l,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_il_scaled_e :: 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 "bessel.h gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_il_scaled(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_il_scaled :: CInt -> Double -> Double
 bessel_il_scaled = gsl_sf_bessel_il_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_il_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array
-foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_k0_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k0_scaled_e :: Double -> (Double,Double)
 bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_k0_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k0_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k0_scaled :: Double -> Double
 bessel_k0_scaled = gsl_sf_bessel_k0_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_k1_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k1_scaled_e :: Double -> (Double,Double)
 bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_k1_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k1_scaled :: Double -> Double
 bessel_k1_scaled = gsl_sf_bessel_k1_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_k2_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k2_scaled_e :: Double -> (Double,Double)
 bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x
-foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_k2_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_k2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_k2_scaled :: Double -> Double
 bessel_k2_scaled = gsl_sf_bessel_k2_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
+foreign import ccall "gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_kl_scaled_e(int l,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_kl_scaled_e :: 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 "bessel.h gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_kl_scaled(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_kl_scaled :: CInt -> Double -> Double
 bessel_kl_scaled = gsl_sf_bessel_kl_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_kl_scaled_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array
-foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_Jnu_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Jnu_e :: Double -> Double -> (Double,Double)
 bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Jnu(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Jnu :: Double -> Double -> Double
 bessel_Jnu = gsl_sf_bessel_Jnu
-foreign import ccall "bessel.h gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Ynu_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Ynu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Ynu_e :: Double -> Double -> (Double,Double)
 bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Ynu(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Ynu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Ynu :: Double -> Double -> Double
 bessel_Ynu = gsl_sf_bessel_Ynu
-foreign import ccall "bessel.h gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_sequence_Jnu_e(double nu,gsl_mode_t mode,size_t size,double* v);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_sequence_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> CInt
 bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v
-foreign import ccall "bessel.h gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_bessel_Inu_scaled_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Inu_scaled_e :: Double -> Double -> (Double,Double)
 bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Inu_scaled(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Inu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Inu_scaled :: Double -> Double -> Double
 bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Inu_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Inu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Inu_e :: Double -> Double -> (Double,Double)
 bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Inu(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Inu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Inu :: Double -> Double -> Double
 bessel_Inu = gsl_sf_bessel_Inu
-foreign import ccall "bessel.h gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Knu_scaled_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Knu_scaled_e :: Double -> Double -> (Double,Double)
 bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Knu_scaled(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Knu_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Knu_scaled :: Double -> Double -> Double
 bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled
-foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_Knu_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Knu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Knu_e :: Double -> Double -> (Double,Double)
 bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_Knu(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_Knu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_Knu :: Double -> Double -> Double
 bessel_Knu = gsl_sf_bessel_Knu
-foreign import ccall "bessel.h gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_lnKnu_e(double nu,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_lnKnu_e :: Double -> Double -> (Double,Double)
 bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x
-foreign import ccall "bessel.h gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_lnKnu(double nu,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_lnKnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_lnKnu :: Double -> Double -> Double
 bessel_lnKnu = gsl_sf_bessel_lnKnu
-foreign import ccall "bessel.h gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
+foreign import ccall "gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_bessel_zero_J0_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_J0_e :: CInt -> (Double,Double)
 bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s
-foreign import ccall "bessel.h gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_zero_J0(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_J0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_J0 :: CInt -> Double
 bessel_zero_J0 = gsl_sf_bessel_zero_J0
-foreign import ccall "bessel.h gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double
+foreign import ccall "gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double
 
 -- | wrapper for int gsl_sf_bessel_zero_J1_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_J1_e :: CInt -> (Double,Double)
 bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s
-foreign import ccall "bessel.h gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_zero_J1(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_J1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_J1 :: CInt -> Double
 bessel_zero_J1 = gsl_sf_bessel_zero_J1
-foreign import ccall "bessel.h gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double
+foreign import ccall "gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double
 
 -- | wrapper for int gsl_sf_bessel_zero_Jnu_e(double nu,int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_Jnu_e :: Double -> 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 "bessel.h gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_bessel_zero_Jnu(double nu,int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_bessel_zero_Jnu&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 bessel_zero_Jnu :: Double -> CInt -> Double
 bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu
-foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> CInt -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Clausen.hs
+++ b/lib/Numeric/GSL/Special/Clausen.hs
@@ -28,11 +28,11 @@
 --   <http://www.google.com/search?q=gsl_sf_clausen_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 clausen_e :: Double -> (Double,Double)
 clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x
-foreign import ccall "clausen.h gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_clausen(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_clausen&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 clausen :: Double -> Double
 clausen = gsl_sf_clausen
-foreign import ccall "clausen.h gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
+foreign import ccall "gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Coulomb.hs b/lib/Numeric/GSL/Special/Coulomb.hs
--- a/lib/Numeric/GSL/Special/Coulomb.hs
+++ b/lib/Numeric/GSL/Special/Coulomb.hs
@@ -31,74 +31,74 @@
 --   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hydrogenicR_1_e :: Double -> Double -> (Double,Double)
 hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r
-foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hydrogenicR_1(double Z,double r);
 --
 --   <http://www.google.com/search?q=gsl_sf_hydrogenicR_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hydrogenicR_1 :: Double -> Double -> Double
 hydrogenicR_1 = gsl_sf_hydrogenicR_1
-foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hydrogenicR_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hydrogenicR_e :: 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 "coulomb.h gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hydrogenicR(int n,int l,double Z,double r);
 --
 --   <http://www.google.com/search?q=gsl_sf_hydrogenicR&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
 hydrogenicR = gsl_sf_hydrogenicR
-foreign import ccall "coulomb.h gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,gsl_sf_result* F,gsl_sf_result* Fp,gsl_sf_result* G,gsl_sf_result* Gp,double* exp_F,double* exp_G);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e
-foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "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
 
 -- | wrapper for int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_wave_F_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array
-foreign import ccall "coulomb.h gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FG_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_wave_FG_array :: Double -> 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 "coulomb.h 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
+foreign import ccall "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
 
 -- | wrapper for int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_wave_FGp_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_wave_FGp_array :: Double -> 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 "coulomb.h 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
+foreign import ccall "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
 
 -- | wrapper for int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_wave_sphF_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array
-foreign import ccall "coulomb.h gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_coulomb_CL_e(double L,double eta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_CL_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_CL_e :: Double -> Double -> (Double,Double)
 coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta
-foreign import ccall "coulomb.h gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);
 --
 --   <http://www.google.com/search?q=gsl_sf_coulomb_CL_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
 coulomb_CL_array = gsl_sf_coulomb_CL_array
-foreign import ccall "coulomb.h gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Coupling.hs
+++ b/lib/Numeric/GSL/Special/Coupling.hs
@@ -34,67 +34,67 @@
 --   <http://www.google.com/search?q=gsl_sf_coupling_3j_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "coupling.h gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_3j&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_3j = gsl_sf_coupling_3j
-foreign import ccall "coupling.h gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall "gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_6j_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "coupling.h gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_6j&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_6j = gsl_sf_coupling_6j
-foreign import ccall "coupling.h gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall "gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_RacahW_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "coupling.h gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_RacahW&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_RacahW = gsl_sf_coupling_RacahW
-foreign import ccall "coupling.h gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall "gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_9j_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "coupling.h gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_9j&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_9j = gsl_sf_coupling_9j
-foreign import ccall "coupling.h gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall "gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_6j_INCORRECT_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "coupling.h gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
 --
 --   <http://www.google.com/search?q=gsl_sf_coupling_6j_INCORRECT&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT
-foreign import ccall "coupling.h gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Dawson.hs
+++ b/lib/Numeric/GSL/Special/Dawson.hs
@@ -28,11 +28,11 @@
 --   <http://www.google.com/search?q=gsl_sf_dawson_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 dawson_e :: Double -> (Double,Double)
 dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x
-foreign import ccall "dawson.h gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_dawson(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_dawson&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 dawson :: Double -> Double
 dawson = gsl_sf_dawson
-foreign import ccall "dawson.h gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
+foreign import ccall "gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Debye.hs b/lib/Numeric/GSL/Special/Debye.hs
--- a/lib/Numeric/GSL/Special/Debye.hs
+++ b/lib/Numeric/GSL/Special/Debye.hs
@@ -38,81 +38,81 @@
 --   <http://www.google.com/search?q=gsl_sf_debye_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_1_e :: Double -> (Double,Double)
 debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x
-foreign import ccall "debye.h gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_1 :: Double -> Double
 debye_1 = gsl_sf_debye_1
-foreign import ccall "debye.h gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
+foreign import ccall "gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_debye_2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_2_e :: Double -> (Double,Double)
 debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x
-foreign import ccall "debye.h gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_2 :: Double -> Double
 debye_2 = gsl_sf_debye_2
-foreign import ccall "debye.h gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
+foreign import ccall "gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
 
 -- | wrapper for int gsl_sf_debye_3_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_3_e :: Double -> (Double,Double)
 debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x
-foreign import ccall "debye.h gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_3(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_3 :: Double -> Double
 debye_3 = gsl_sf_debye_3
-foreign import ccall "debye.h gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
+foreign import ccall "gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
 
 -- | wrapper for int gsl_sf_debye_4_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_4_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_4_e :: Double -> (Double,Double)
 debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x
-foreign import ccall "debye.h gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_4(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_4&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_4 :: Double -> Double
 debye_4 = gsl_sf_debye_4
-foreign import ccall "debye.h gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
+foreign import ccall "gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
 
 -- | wrapper for int gsl_sf_debye_5_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_5_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_5_e :: Double -> (Double,Double)
 debye_5_e x = createSFR "debye_5_e" $ gsl_sf_debye_5_e x
-foreign import ccall "debye.h gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_5(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_5&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_5 :: Double -> Double
 debye_5 = gsl_sf_debye_5
-foreign import ccall "debye.h gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double
+foreign import ccall "gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double
 
 -- | wrapper for int gsl_sf_debye_6_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_6_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_6_e :: Double -> (Double,Double)
 debye_6_e x = createSFR "debye_6_e" $ gsl_sf_debye_6_e x
-foreign import ccall "debye.h gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_debye_6(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_debye_6&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 debye_6 :: Double -> Double
 debye_6 = gsl_sf_debye_6
-foreign import ccall "debye.h gsl_sf_debye_6" gsl_sf_debye_6 :: Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Dilog.hs
+++ b/lib/Numeric/GSL/Special/Dilog.hs
@@ -28,32 +28,32 @@
 --   <http://www.google.com/search?q=gsl_sf_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 dilog_e :: Double -> (Double,Double)
 dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x
-foreign import ccall "dilog.h gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_dilog(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_dilog&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 dilog :: Double -> Double
 dilog = gsl_sf_dilog
-foreign import ccall "dilog.h gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
+foreign import ccall "gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
 
 -- | wrapper for int gsl_sf_complex_dilog_xy_e(double x,double y,gsl_sf_result* result_re,gsl_sf_result* result_im);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_dilog_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 complex_dilog_xy_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re
-foreign import ccall "dilog.h gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_complex_dilog_e(double r,double theta,gsl_sf_result* result_re,gsl_sf_result* result_im);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_dilog_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 complex_dilog_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re
-foreign import ccall "dilog.h gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_complex_spence_xy_e(double x,double y,gsl_sf_result* real_sp,gsl_sf_result* imag_sp);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_spence_xy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 complex_spence_xy_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp
-foreign import ccall "dilog.h gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Elementary.hs
+++ b/lib/Numeric/GSL/Special/Elementary.hs
@@ -29,18 +29,18 @@
 --   <http://www.google.com/search?q=gsl_sf_multiply_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 multiply_e :: Double -> Double -> (Double,Double)
 multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y
-foreign import ccall "elementary.h gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_multiply(double x,double y);
 --
 --   <http://www.google.com/search?q=gsl_sf_multiply&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 multiply :: Double -> Double -> Double
 multiply = gsl_sf_multiply
-foreign import ccall "elementary.h gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
+foreign import ccall "gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_multiply_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
 multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy
-foreign import ccall "elementary.h gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Ellint.hs
+++ b/lib/Numeric/GSL/Special/Ellint.hs
@@ -50,165 +50,165 @@
 --   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Kcomp_e :: Double -> Precision -> (Double,Double)
 ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_Kcomp(double k,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Kcomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Kcomp :: Double -> Precision -> Double
 ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_Ecomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Ecomp_e :: Double -> Precision -> (Double,Double)
 ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_Ecomp(double k,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Ecomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Ecomp :: Double -> Precision -> Double
 ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_Pcomp_e(double k,double n,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Pcomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "ellint.h gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_Pcomp(double k,double n,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Pcomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Pcomp :: Double -> Double -> Precision -> Double
 ellint_Pcomp k n mode = gsl_sf_ellint_Pcomp k n  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_Dcomp_e(double k,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Dcomp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "ellint.h gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_Dcomp(double k,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_Dcomp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_Dcomp :: Double -> Precision -> Double
 ellint_Dcomp k mode = gsl_sf_ellint_Dcomp k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_F_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_F_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_F_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_F(double phi,double k,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_F&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_F :: Double -> Double -> Precision -> Double
 ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_E_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_E_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_E_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_E(double phi,double k,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_E&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_E :: Double -> Double -> Precision -> Double
 ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_P_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_P(double phi,double k,double n,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_P :: Double -> Double -> Double -> Precision -> Double
 ellint_P phi k n mode = gsl_sf_ellint_P phi k n  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_D_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_D_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_D(double phi,double k,double n,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_D&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_D :: Double -> Double -> Double -> Precision -> Double
 ellint_D phi k n mode = gsl_sf_ellint_D phi k n  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_RC_e(double x,double y,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RC_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RC_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_RC(double x,double y,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RC&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RC :: Double -> Double -> Precision -> Double
 ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_RD_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RD_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_RD(double x,double y,double z,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RD&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RD :: Double -> Double -> Double -> Precision -> Double
 ellint_RD x y z mode = gsl_sf_ellint_RD x y z  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_RF_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RF_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_RF(double x,double y,double z,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RF&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RF :: Double -> Double -> Double -> Precision -> Double
 ellint_RF x y z mode = gsl_sf_ellint_RF x y z  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 -- | wrapper for int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,gsl_mode_t mode,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RJ_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_ellint_RJ(double x,double y,double z,double p,gsl_mode_t mode);
 --
 --   <http://www.google.com/search?q=gsl_sf_ellint_RJ&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double
 ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p  (precCode mode)
-foreign import ccall "ellint.h gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall "gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
diff --git a/lib/Numeric/GSL/Special/Erf.hs b/lib/Numeric/GSL/Special/Erf.hs
--- a/lib/Numeric/GSL/Special/Erf.hs
+++ b/lib/Numeric/GSL/Special/Erf.hs
@@ -38,81 +38,81 @@
 --   <http://www.google.com/search?q=gsl_sf_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erfc_e :: Double -> (Double,Double)
 erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x
-foreign import ccall "erf.h gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_erfc(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erfc :: Double -> Double
 erfc = gsl_sf_erfc
-foreign import ccall "erf.h gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
+foreign import ccall "gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
 
 -- | wrapper for int gsl_sf_log_erfc_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_erfc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_erfc_e :: Double -> (Double,Double)
 log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x
-foreign import ccall "erf.h gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_log_erfc(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_erfc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_erfc :: Double -> Double
 log_erfc = gsl_sf_log_erfc
-foreign import ccall "erf.h gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
+foreign import ccall "gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
 
 -- | wrapper for int gsl_sf_erf_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf_e :: Double -> (Double,Double)
 erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x
-foreign import ccall "erf.h gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_erf(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf :: Double -> Double
 erf = gsl_sf_erf
-foreign import ccall "erf.h gsl_sf_erf" gsl_sf_erf :: Double -> Double
+foreign import ccall "gsl_sf_erf" gsl_sf_erf :: Double -> Double
 
 -- | wrapper for int gsl_sf_erf_Z_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf_Z_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf_Z_e :: Double -> (Double,Double)
 erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x
-foreign import ccall "erf.h gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_erf_Q_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf_Q_e :: Double -> (Double,Double)
 erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x
-foreign import ccall "erf.h gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_erf_Z(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf_Z&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf_Z :: Double -> Double
 erf_Z = gsl_sf_erf_Z
-foreign import ccall "erf.h gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
+foreign import ccall "gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
 
 -- | wrapper for double gsl_sf_erf_Q(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_erf_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 erf_Q :: Double -> Double
 erf_Q = gsl_sf_erf_Q
-foreign import ccall "erf.h gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
+foreign import ccall "gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
 
 -- | wrapper for int gsl_sf_hazard_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hazard_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hazard_e :: Double -> (Double,Double)
 hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x
-foreign import ccall "erf.h gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hazard(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hazard&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hazard :: Double -> Double
 hazard = gsl_sf_hazard
-foreign import ccall "erf.h gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
+foreign import ccall "gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Exp.hs b/lib/Numeric/GSL/Special/Exp.hs
--- a/lib/Numeric/GSL/Special/Exp.hs
+++ b/lib/Numeric/GSL/Special/Exp.hs
@@ -29,6 +29,7 @@
 , exprel_2
 , exprel_n_e
 , exprel_n
+, exprel_n_CF_e
 , exp_err_e
 , exp_err_e10_e
 , exp_mult_err_e
@@ -44,123 +45,130 @@
 --   <http://www.google.com/search?q=gsl_sf_exp_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_e :: Double -> (Double,Double)
 exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x
-foreign import ccall "exp.h gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_exp(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp :: Double -> Double
 exp = gsl_sf_exp
-foreign import ccall "exp.h gsl_sf_exp" gsl_sf_exp :: Double -> Double
+foreign import ccall "gsl_sf_exp" gsl_sf_exp :: Double -> Double
 
 -- | wrapper for int gsl_sf_exp_e10_e(double x,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_e10_e :: Double -> (Double,Int,Double)
 exp_e10_e x = createSFR_E10 "exp_e10_e" $ gsl_sf_exp_e10_e x
-foreign import ccall "exp.h gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_exp_mult_e(double x,double y,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_mult_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_mult_e :: Double -> Double -> (Double,Double)
 exp_mult_e x y = createSFR "exp_mult_e" $ gsl_sf_exp_mult_e x y
-foreign import ccall "exp.h gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_exp_mult(double x,double y);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_mult&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_mult :: Double -> Double -> Double
 exp_mult = gsl_sf_exp_mult
-foreign import ccall "exp.h gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
+foreign import ccall "gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_exp_mult_e10_e(double x,double y,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_mult_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_mult_e10_e :: Double -> Double -> (Double,Int,Double)
 exp_mult_e10_e x y = createSFR_E10 "exp_mult_e10_e" $ gsl_sf_exp_mult_e10_e x y
-foreign import ccall "exp.h gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_expm1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expm1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expm1_e :: Double -> (Double,Double)
 expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x
-foreign import ccall "exp.h gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expm1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expm1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expm1 :: Double -> Double
 expm1 = gsl_sf_expm1
-foreign import ccall "exp.h gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
+foreign import ccall "gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_exprel_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exprel_e :: Double -> (Double,Double)
 exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x
-foreign import ccall "exp.h gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_exprel(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exprel :: Double -> Double
 exprel = gsl_sf_exprel
-foreign import ccall "exp.h gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
+foreign import ccall "gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
 
 -- | wrapper for int gsl_sf_exprel_2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exprel_2_e :: Double -> (Double,Double)
 exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x
-foreign import ccall "exp.h gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_exprel_2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exprel_2 :: Double -> Double
 exprel_2 = gsl_sf_exprel_2
-foreign import ccall "exp.h gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
+foreign import ccall "gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
 
 -- | wrapper for int gsl_sf_exprel_n_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "exp.h gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_exprel_n(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_exprel_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exprel_n :: CInt -> Double -> Double
 exprel_n = gsl_sf_exprel_n
-foreign import ccall "exp.h gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double
 
+-- | wrapper for int gsl_sf_exprel_n_CF_e(double n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_exprel_n_CF_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+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 "gsl_sf_exprel_n_CF_e" gsl_sf_exprel_n_CF_e :: Double -> Double -> Ptr () -> IO CInt
+
 -- | wrapper for int gsl_sf_exp_err_e(double x,double dx,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_err_e :: Double -> Double -> (Double,Double)
 exp_err_e x dx = createSFR "exp_err_e" $ gsl_sf_exp_err_e x dx
-foreign import ccall "exp.h gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_exp_err_e10_e(double x,double dx,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_err_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_err_e10_e :: Double -> Double -> (Double,Int,Double)
 exp_err_e10_e x dx = createSFR_E10 "exp_err_e10_e" $ gsl_sf_exp_err_e10_e x dx
-foreign import ccall "exp.h gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_mult_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_mult_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
 exp_mult_err_e x dx y dy = createSFR "exp_mult_err_e" $ gsl_sf_exp_mult_err_e x dx y dy
-foreign import ccall "exp.h gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_exp_mult_err_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> (Double,Int,Double)
 exp_mult_err_e10_e x dx y dy = createSFR_E10 "exp_mult_err_e10_e" $ gsl_sf_exp_mult_err_e10_e x dx y dy
-foreign import ccall "exp.h gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Expint.hs
+++ b/lib/Numeric/GSL/Special/Expint.hs
@@ -19,10 +19,14 @@
 , 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
@@ -50,165 +54,193 @@
 --   <http://www.google.com/search?q=gsl_sf_expint_E1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E1_e :: Double -> (Double,Double)
 expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x
-foreign import ccall "expint.h gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_E1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E1 :: Double -> Double
 expint_E1 = gsl_sf_expint_E1
-foreign import ccall "expint.h gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
+foreign import ccall "gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_expint_E2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E2_e :: Double -> (Double,Double)
 expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x
-foreign import ccall "expint.h gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_E2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E2 :: Double -> Double
 expint_E2 = gsl_sf_expint_E2
-foreign import ccall "expint.h gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
+foreign import ccall "gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
 
+-- | wrapper for int gsl_sf_expint_En_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_En_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+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 "gsl_sf_expint_En_e" gsl_sf_expint_En_e :: CInt -> Double -> Ptr () -> IO CInt
+
+-- | wrapper for double gsl_sf_expint_En(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_En&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_En :: CInt -> Double -> Double
+expint_En = gsl_sf_expint_En
+foreign import ccall "gsl_sf_expint_En" gsl_sf_expint_En :: CInt -> Double -> Double
+
 -- | wrapper for int gsl_sf_expint_E1_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E1_scaled_e :: Double -> (Double,Double)
 expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x
-foreign import ccall "expint.h gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_E1_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E1_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E1_scaled :: Double -> Double
 expint_E1_scaled = gsl_sf_expint_E1_scaled
-foreign import ccall "expint.h gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
+foreign import ccall "gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_expint_E2_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E2_scaled_e :: Double -> (Double,Double)
 expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x
-foreign import ccall "expint.h gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_E2_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_E2_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_E2_scaled :: Double -> Double
 expint_E2_scaled = gsl_sf_expint_E2_scaled
-foreign import ccall "expint.h gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
+foreign import ccall "gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
 
+-- | wrapper for int gsl_sf_expint_En_scaled_e(int n,double x,gsl_sf_result* result);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_En_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+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 "gsl_sf_expint_En_scaled_e" gsl_sf_expint_En_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+
+-- | wrapper for double gsl_sf_expint_En_scaled(int n,double x);
+--
+--   <http://www.google.com/search?q=gsl_sf_expint_En_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
+expint_En_scaled :: CInt -> Double -> Double
+expint_En_scaled = gsl_sf_expint_En_scaled
+foreign import ccall "gsl_sf_expint_En_scaled" gsl_sf_expint_En_scaled :: CInt -> Double -> Double
+
 -- | wrapper for int gsl_sf_expint_Ei_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_Ei_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_Ei_e :: Double -> (Double,Double)
 expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x
-foreign import ccall "expint.h gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_Ei(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_Ei&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_Ei :: Double -> Double
 expint_Ei = gsl_sf_expint_Ei
-foreign import ccall "expint.h gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
+foreign import ccall "gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
 
 -- | wrapper for int gsl_sf_expint_Ei_scaled_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_Ei_scaled_e :: Double -> (Double,Double)
 expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x
-foreign import ccall "expint.h gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_Ei_scaled(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_Ei_scaled&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_Ei_scaled :: Double -> Double
 expint_Ei_scaled = gsl_sf_expint_Ei_scaled
-foreign import ccall "expint.h gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
+foreign import ccall "gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
 
 -- | wrapper for int gsl_sf_Shi_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_Shi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 shi_e :: Double -> (Double,Double)
 shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x
-foreign import ccall "expint.h gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_Shi(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_Shi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 shi :: Double -> Double
 shi = gsl_sf_Shi
-foreign import ccall "expint.h gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
+foreign import ccall "gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
 
 -- | wrapper for int gsl_sf_Chi_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_Chi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 chi_e :: Double -> (Double,Double)
 chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x
-foreign import ccall "expint.h gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_Chi(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_Chi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 chi :: Double -> Double
 chi = gsl_sf_Chi
-foreign import ccall "expint.h gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
+foreign import ccall "gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
 
 -- | wrapper for int gsl_sf_expint_3_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_3_e :: Double -> (Double,Double)
 expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x
-foreign import ccall "expint.h gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_expint_3(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_expint_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 expint_3 :: Double -> Double
 expint_3 = gsl_sf_expint_3
-foreign import ccall "expint.h gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
+foreign import ccall "gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
 
 -- | wrapper for int gsl_sf_Si_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_Si_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 si_e :: Double -> (Double,Double)
 si_e x = createSFR "si_e" $ gsl_sf_Si_e x
-foreign import ccall "expint.h gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_Si(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_Si&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 si :: Double -> Double
 si = gsl_sf_Si
-foreign import ccall "expint.h gsl_sf_Si" gsl_sf_Si :: Double -> Double
+foreign import ccall "gsl_sf_Si" gsl_sf_Si :: Double -> Double
 
 -- | wrapper for int gsl_sf_Ci_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_Ci_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ci_e :: Double -> (Double,Double)
 ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x
-foreign import ccall "expint.h gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_Ci(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_Ci&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 ci :: Double -> Double
 ci = gsl_sf_Ci
-foreign import ccall "expint.h gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
+foreign import ccall "gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
 
 -- | wrapper for int gsl_sf_atanint_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_atanint_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 atanint_e :: Double -> (Double,Double)
 atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x
-foreign import ccall "expint.h gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_atanint(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_atanint&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 atanint :: Double -> Double
 atanint = gsl_sf_atanint
-foreign import ccall "expint.h gsl_sf_atanint" gsl_sf_atanint :: Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Fermi_dirac.hs
+++ b/lib/Numeric/GSL/Special/Fermi_dirac.hs
@@ -44,123 +44,123 @@
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_m1_e :: Double -> (Double,Double)
 fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_m1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_m1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_m1 :: Double -> Double
 fermi_dirac_m1 = gsl_sf_fermi_dirac_m1
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_0_e :: Double -> (Double,Double)
 fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_0 :: Double -> Double
 fermi_dirac_0 = gsl_sf_fermi_dirac_0
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_1_e :: Double -> (Double,Double)
 fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_1 :: Double -> Double
 fermi_dirac_1 = gsl_sf_fermi_dirac_1
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_2_e :: Double -> (Double,Double)
 fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_2 :: Double -> Double
 fermi_dirac_2 = gsl_sf_fermi_dirac_2
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_int_e(int j,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_int_e :: 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 "fermi_dirac.h gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_int(int j,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_int :: CInt -> Double -> Double
 fermi_dirac_int = gsl_sf_fermi_dirac_int
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_mhalf_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_mhalf_e :: Double -> (Double,Double)
 fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_mhalf(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_mhalf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_mhalf :: Double -> Double
 fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_half_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_half_e :: Double -> (Double,Double)
 fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_half(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_half :: Double -> Double
 fermi_dirac_half = gsl_sf_fermi_dirac_half
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_3half_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_3half_e :: Double -> (Double,Double)
 fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_3half(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_3half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_3half :: Double -> Double
 fermi_dirac_3half = gsl_sf_fermi_dirac_3half
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
+foreign import ccall "gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
 
 -- | wrapper for int gsl_sf_fermi_dirac_inc_0_e(double x,double b,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double)
 fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fermi_dirac_inc_0(double x,double b);
 --
 --   <http://www.google.com/search?q=gsl_sf_fermi_dirac_inc_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fermi_dirac_inc_0 :: Double -> Double -> Double
 fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0
-foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Gamma.hs
+++ b/lib/Numeric/GSL/Special/Gamma.hs
@@ -66,305 +66,305 @@
 --   <http://www.google.com/search?q=gsl_sf_lngamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lngamma_e :: Double -> (Double,Double)
 lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x
-foreign import ccall "gamma.h gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lngamma(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lngamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lngamma :: Double -> Double
 lngamma = gsl_sf_lngamma
-foreign import ccall "gamma.h gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
+foreign import ccall "gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
 
 -- | wrapper for int gsl_sf_lngamma_sgn_e(double x,gsl_sf_result* result_lg,double* sgn);
 --
 --   <http://www.google.com/search?q=gsl_sf_lngamma_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
 lngamma_sgn_e = gsl_sf_lngamma_sgn_e
-foreign import ccall "gamma.h gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_gamma_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_e :: Double -> (Double,Double)
 gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x
-foreign import ccall "gamma.h gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gamma(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma :: Double -> Double
 gamma = gsl_sf_gamma
-foreign import ccall "gamma.h gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
+foreign import ccall "gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
 
 -- | wrapper for int gsl_sf_gammastar_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gammastar_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gammastar_e :: Double -> (Double,Double)
 gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x
-foreign import ccall "gamma.h gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gammastar(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gammastar&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gammastar :: Double -> Double
 gammastar = gsl_sf_gammastar
-foreign import ccall "gamma.h gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
+foreign import ccall "gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
 
 -- | wrapper for int gsl_sf_gammainv_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gammainv_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gammainv_e :: Double -> (Double,Double)
 gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x
-foreign import ccall "gamma.h gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gammainv(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gammainv&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gammainv :: Double -> Double
 gammainv = gsl_sf_gammainv
-foreign import ccall "gamma.h gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
+foreign import ccall "gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
 
 -- | wrapper for int gsl_sf_lngamma_complex_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* arg);
 --
 --   <http://www.google.com/search?q=gsl_sf_lngamma_complex_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lngamma_complex_e :: Double -> Double -> Ptr () -> (Double,Double)
 lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr
-foreign import ccall "gamma.h gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_taylorcoeff_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_taylorcoeff_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 taylorcoeff_e :: CInt -> Double -> (Double,Double)
 taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x
-foreign import ccall "gamma.h gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_taylorcoeff(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_taylorcoeff&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 taylorcoeff :: CInt -> Double -> Double
 taylorcoeff = gsl_sf_taylorcoeff
-foreign import ccall "gamma.h gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_fact_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_fact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fact_e :: CInt -> (Double,Double)
 fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n
-foreign import ccall "gamma.h gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_fact(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_fact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 fact :: CInt -> Double
 fact = gsl_sf_fact
-foreign import ccall "gamma.h gsl_sf_fact" gsl_sf_fact :: CInt -> Double
+foreign import ccall "gsl_sf_fact" gsl_sf_fact :: CInt -> Double
 
 -- | wrapper for int gsl_sf_doublefact_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_doublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 doublefact_e :: CInt -> (Double,Double)
 doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n
-foreign import ccall "gamma.h gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_doublefact(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_doublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 doublefact :: CInt -> Double
 doublefact = gsl_sf_doublefact
-foreign import ccall "gamma.h gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double
+foreign import ccall "gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double
 
 -- | wrapper for int gsl_sf_lnfact_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnfact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnfact_e :: CInt -> (Double,Double)
 lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n
-foreign import ccall "gamma.h gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lnfact(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnfact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnfact :: CInt -> Double
 lnfact = gsl_sf_lnfact
-foreign import ccall "gamma.h gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double
+foreign import ccall "gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double
 
 -- | wrapper for int gsl_sf_lndoublefact_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lndoublefact_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lndoublefact_e :: CInt -> (Double,Double)
 lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n
-foreign import ccall "gamma.h gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lndoublefact(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_lndoublefact&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lndoublefact :: CInt -> Double
 lndoublefact = gsl_sf_lndoublefact
-foreign import ccall "gamma.h gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double
+foreign import ccall "gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double
 
 -- | wrapper for int gsl_sf_lnchoose_e(int n,int m,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnchoose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnchoose_e :: CInt -> CInt -> (Double,Double)
 lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m
-foreign import ccall "gamma.h gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lnchoose(int n,int m);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnchoose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnchoose :: CInt -> CInt -> Double
 lnchoose = gsl_sf_lnchoose
-foreign import ccall "gamma.h gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double
+foreign import ccall "gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_choose_e(int n,int m,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_choose_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 choose_e :: CInt -> CInt -> (Double,Double)
 choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m
-foreign import ccall "gamma.h gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_choose(int n,int m);
 --
 --   <http://www.google.com/search?q=gsl_sf_choose&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 choose :: CInt -> CInt -> Double
 choose = gsl_sf_choose
-foreign import ccall "gamma.h gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double
+foreign import ccall "gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double
 
 -- | wrapper for int gsl_sf_lnpoch_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnpoch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnpoch_e :: Double -> Double -> (Double,Double)
 lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x
-foreign import ccall "gamma.h gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lnpoch(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnpoch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnpoch :: Double -> Double -> Double
 lnpoch = gsl_sf_lnpoch
-foreign import ccall "gamma.h gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
+foreign import ccall "gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_lnpoch_sgn_e(double a,double x,gsl_sf_result* result,double* sgn);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnpoch_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e
-foreign import ccall "gamma.h gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_poch_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_poch_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 poch_e :: Double -> Double -> (Double,Double)
 poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x
-foreign import ccall "gamma.h gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_poch(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_poch&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 poch :: Double -> Double -> Double
 poch = gsl_sf_poch
-foreign import ccall "gamma.h gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
+foreign import ccall "gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_pochrel_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_pochrel_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 pochrel_e :: Double -> Double -> (Double,Double)
 pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x
-foreign import ccall "gamma.h gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_pochrel(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_pochrel&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 pochrel :: Double -> Double -> Double
 pochrel = gsl_sf_pochrel
-foreign import ccall "gamma.h gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
+foreign import ccall "gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_gamma_inc_Q_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc_Q_e :: Double -> Double -> (Double,Double)
 gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x
-foreign import ccall "gamma.h gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gamma_inc_Q(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc_Q&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc_Q :: Double -> Double -> Double
 gamma_inc_Q = gsl_sf_gamma_inc_Q
-foreign import ccall "gamma.h gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_gamma_inc_P_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc_P_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc_P_e :: Double -> Double -> (Double,Double)
 gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x
-foreign import ccall "gamma.h gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gamma_inc_P(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc_P&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc_P :: Double -> Double -> Double
 gamma_inc_P = gsl_sf_gamma_inc_P
-foreign import ccall "gamma.h gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_gamma_inc_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc_e :: Double -> Double -> (Double,Double)
 gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x
-foreign import ccall "gamma.h gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gamma_inc(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gamma_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gamma_inc :: Double -> Double -> Double
 gamma_inc = gsl_sf_gamma_inc
-foreign import ccall "gamma.h gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_lnbeta_e(double a,double b,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnbeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnbeta_e :: Double -> Double -> (Double,Double)
 lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b
-foreign import ccall "gamma.h gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lnbeta(double a,double b);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnbeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnbeta :: Double -> Double -> Double
 lnbeta = gsl_sf_lnbeta
-foreign import ccall "gamma.h gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
+foreign import ccall "gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_lnbeta_sgn_e(double x,double y,gsl_sf_result* result,double* sgn);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnbeta_sgn_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 lnbeta_sgn_e = gsl_sf_lnbeta_sgn_e
-foreign import ccall "gamma.h gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_beta_e(double a,double b,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_beta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 beta_e :: Double -> Double -> (Double,Double)
 beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b
-foreign import ccall "gamma.h gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_beta(double a,double b);
 --
 --   <http://www.google.com/search?q=gsl_sf_beta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 beta :: Double -> Double -> Double
 beta = gsl_sf_beta
-foreign import ccall "gamma.h gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
+foreign import ccall "gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_beta_inc_e(double a,double b,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_beta_inc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 beta_inc_e :: Double -> Double -> Double -> (Double,Double)
 beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x
-foreign import ccall "gamma.h gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_beta_inc(double a,double b,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_beta_inc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 beta_inc :: Double -> Double -> Double -> Double
 beta_inc = gsl_sf_beta_inc
-foreign import ccall "gamma.h gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Gegenbauer.hs
+++ b/lib/Numeric/GSL/Special/Gegenbauer.hs
@@ -34,60 +34,60 @@
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_1_e :: Double -> Double -> (Double,Double)
 gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_gegenpoly_2_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_2_e :: Double -> Double -> (Double,Double)
 gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_gegenpoly_3_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_3_e :: Double -> Double -> (Double,Double)
 gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gegenpoly_1(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_1 :: Double -> Double -> Double
 gegenpoly_1 = gsl_sf_gegenpoly_1
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
 
 -- | wrapper for double gsl_sf_gegenpoly_2(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_2 :: Double -> Double -> Double
 gegenpoly_2 = gsl_sf_gegenpoly_2
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
 
 -- | wrapper for double gsl_sf_gegenpoly_3(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_3 :: Double -> Double -> Double
 gegenpoly_3 = gsl_sf_gegenpoly_3
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_n_e :: 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 "gegenbauer.h gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_gegenpoly_n(int n,double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_n :: CInt -> Double -> Double -> Double
 gegenpoly_n = gsl_sf_gegenpoly_n
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double
+foreign import ccall "gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_gegenpoly_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
 gegenpoly_array = gsl_sf_gegenpoly_array
-foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Hyperg.hs
+++ b/lib/Numeric/GSL/Special/Hyperg.hs
@@ -48,151 +48,151 @@
 --   <http://www.google.com/search?q=gsl_sf_hyperg_0F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_0F1_e :: Double -> Double -> (Double,Double)
 hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x
-foreign import ccall "hyperg.h gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_0F1(double c,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_0F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_0F1 :: Double -> Double -> Double
 hyperg_0F1 = gsl_sf_hyperg_0F1
-foreign import ccall "hyperg.h gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_1F1_int_e :: 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 "hyperg.h gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_1F1_int(int m,int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_1F1_int :: CInt -> CInt -> Double -> Double
 hyperg_1F1_int = gsl_sf_hyperg_1F1_int
-foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_1F1_e(double a,double b,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_1F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x
-foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_1F1(double a,double b,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_1F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_1F1 :: Double -> Double -> Double -> Double
 hyperg_1F1 = gsl_sf_hyperg_1F1
-foreign import ccall "hyperg.h gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_U_int_e(int m,int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U_int_e :: 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 "hyperg.h gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_U_int(int m,int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U_int :: CInt -> CInt -> Double -> Double
 hyperg_U_int = gsl_sf_hyperg_U_int
-foreign import ccall "hyperg.h gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U_int_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U_int_e10_e :: 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 "hyperg.h gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_hyperg_U_e(double a,double b,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x
-foreign import ccall "hyperg.h gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_U(double a,double b,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U :: Double -> Double -> Double -> Double
 hyperg_U = gsl_sf_hyperg_U
-foreign import ccall "hyperg.h gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_U_e10_e(double a,double b,double x,gsl_sf_result_e10* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_U_e10_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double)
 hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x
-foreign import ccall "hyperg.h gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_2F1(double a,double b,double c,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1 = gsl_sf_hyperg_2F1
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F1_conj_renorm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_hyperg_2F0_e(double a,double b,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hyperg_2F0(double a,double b,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_hyperg_2F0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hyperg_2F0 :: Double -> Double -> Double -> Double
 hyperg_2F0 = gsl_sf_hyperg_2F0
-foreign import ccall "hyperg.h gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
+foreign import ccall "gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Laguerre.hs b/lib/Numeric/GSL/Special/Laguerre.hs
--- a/lib/Numeric/GSL/Special/Laguerre.hs
+++ b/lib/Numeric/GSL/Special/Laguerre.hs
@@ -34,53 +34,53 @@
 --   <http://www.google.com/search?q=gsl_sf_laguerre_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_1_e :: Double -> Double -> (Double,Double)
 laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x
-foreign import ccall "laguerre.h gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_laguerre_2_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_2_e :: Double -> Double -> (Double,Double)
 laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x
-foreign import ccall "laguerre.h gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_laguerre_3_e(double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_3_e :: Double -> Double -> (Double,Double)
 laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x
-foreign import ccall "laguerre.h gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_laguerre_1(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_1 :: Double -> Double -> Double
 laguerre_1 = gsl_sf_laguerre_1
-foreign import ccall "laguerre.h gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
 
 -- | wrapper for double gsl_sf_laguerre_2(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_2 :: Double -> Double -> Double
 laguerre_2 = gsl_sf_laguerre_2
-foreign import ccall "laguerre.h gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
 
 -- | wrapper for double gsl_sf_laguerre_3(double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_3 :: Double -> Double -> Double
 laguerre_3 = gsl_sf_laguerre_3
-foreign import ccall "laguerre.h gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_laguerre_n_e(int n,double a,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_n_e :: 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 "laguerre.h gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_laguerre_n(int n,double a,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_laguerre_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 laguerre_n :: CInt -> Double -> Double -> Double
 laguerre_n = gsl_sf_laguerre_n
-foreign import ccall "laguerre.h gsl_sf_laguerre_n" gsl_sf_laguerre_n :: CInt -> Double -> Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Lambert.hs
+++ b/lib/Numeric/GSL/Special/Lambert.hs
@@ -30,25 +30,25 @@
 --   <http://www.google.com/search?q=gsl_sf_lambert_W0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lambert_W0_e :: Double -> (Double,Double)
 lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x
-foreign import ccall "lambert.h gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lambert_W0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lambert_W0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lambert_W0 :: Double -> Double
 lambert_W0 = gsl_sf_lambert_W0
-foreign import ccall "lambert.h gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
+foreign import ccall "gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_lambert_Wm1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lambert_Wm1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lambert_Wm1_e :: Double -> (Double,Double)
 lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x
-foreign import ccall "lambert.h gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lambert_Wm1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lambert_Wm1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lambert_Wm1 :: Double -> Double
 lambert_Wm1 = gsl_sf_lambert_Wm1
-foreign import ccall "lambert.h gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Legendre.hs
+++ b/lib/Numeric/GSL/Special/Legendre.hs
@@ -63,305 +63,305 @@
 --   <http://www.google.com/search?q=gsl_sf_legendre_Pl_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_Pl(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Pl&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Pl :: CInt -> Double -> Double
 legendre_Pl = gsl_sf_legendre_Pl
-foreign import ccall "legendre.h gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Pl_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
 legendre_Pl_array = gsl_sf_legendre_Pl_array
-foreign import ccall "legendre.h gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Pl_deriv_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array
-foreign import ccall "legendre.h gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_P1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P1_e :: Double -> (Double,Double)
 legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x
-foreign import ccall "legendre.h gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_legendre_P2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P2_e :: Double -> (Double,Double)
 legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x
-foreign import ccall "legendre.h gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_legendre_P3_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P3_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P3_e :: Double -> (Double,Double)
 legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x
-foreign import ccall "legendre.h gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_P1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P1 :: Double -> Double
 legendre_P1 = gsl_sf_legendre_P1
-foreign import ccall "legendre.h gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
+foreign import ccall "gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
 
 -- | wrapper for double gsl_sf_legendre_P2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P2 :: Double -> Double
 legendre_P2 = gsl_sf_legendre_P2
-foreign import ccall "legendre.h gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
+foreign import ccall "gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
 
 -- | wrapper for double gsl_sf_legendre_P3(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_P3&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_P3 :: Double -> Double
 legendre_P3 = gsl_sf_legendre_P3
-foreign import ccall "legendre.h gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
+foreign import ccall "gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Q0_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Q0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Q0_e :: Double -> (Double,Double)
 legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x
-foreign import ccall "legendre.h gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_Q0(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Q0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Q0 :: Double -> Double
 legendre_Q0 = gsl_sf_legendre_Q0
-foreign import ccall "legendre.h gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
+foreign import ccall "gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Q1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Q1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Q1_e :: Double -> (Double,Double)
 legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x
-foreign import ccall "legendre.h gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_Q1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Q1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Q1 :: Double -> Double
 legendre_Q1 = gsl_sf_legendre_Q1
-foreign import ccall "legendre.h gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
+foreign import ccall "gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Ql_e(int l,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Ql_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_Ql(int l,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Ql&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Ql :: CInt -> Double -> Double
 legendre_Ql = gsl_sf_legendre_Ql
-foreign import ccall "legendre.h gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double
+foreign import ccall "gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Plm_e(int l,int m,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Plm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_Plm(int l,int m,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Plm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Plm :: CInt -> CInt -> Double -> Double
 legendre_Plm = gsl_sf_legendre_Plm
-foreign import ccall "legendre.h gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double
+foreign import ccall "gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Plm_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 legendre_Plm_array = gsl_sf_legendre_Plm_array
-foreign import ccall "legendre.h gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_Plm_deriv_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_sphPlm_e(int l,int m,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_sphPlm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_sphPlm(int l,int m,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_sphPlm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_sphPlm :: CInt -> CInt -> Double -> Double
 legendre_sphPlm = gsl_sf_legendre_sphPlm
-foreign import ccall "legendre.h gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double
+foreign import ccall "gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_sphPlm_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array
-foreign import ccall "legendre.h gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_sphPlm_deriv_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall "gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 -- | wrapper for int gsl_sf_legendre_array_size(int lmax,int m);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_array_size&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_array_size :: CInt -> CInt -> CInt
 legendre_array_size = gsl_sf_legendre_array_size
-foreign import ccall "legendre.h gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt
+foreign import ccall "gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt
 
 -- | wrapper for int gsl_sf_conicalP_half_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_half_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_half_e :: Double -> Double -> (Double,Double)
 conicalP_half_e lambda x = createSFR "conicalP_half_e" $ gsl_sf_conicalP_half_e lambda x
-foreign import ccall "legendre.h gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_half(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_half&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_half :: Double -> Double -> Double
 conicalP_half = gsl_sf_conicalP_half
-foreign import ccall "legendre.h gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_conicalP_mhalf_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_mhalf_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_mhalf_e :: Double -> Double -> (Double,Double)
 conicalP_mhalf_e lambda x = createSFR "conicalP_mhalf_e" $ gsl_sf_conicalP_mhalf_e lambda x
-foreign import ccall "legendre.h gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_mhalf(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_mhalf&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_mhalf :: Double -> Double -> Double
 conicalP_mhalf = gsl_sf_conicalP_mhalf
-foreign import ccall "legendre.h gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_conicalP_0_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_0_e :: Double -> Double -> (Double,Double)
 conicalP_0_e lambda x = createSFR "conicalP_0_e" $ gsl_sf_conicalP_0_e lambda x
-foreign import ccall "legendre.h gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_0(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_0 :: Double -> Double -> Double
 conicalP_0 = gsl_sf_conicalP_0
-foreign import ccall "legendre.h gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_conicalP_1_e(double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_1_e :: Double -> Double -> (Double,Double)
 conicalP_1_e lambda x = createSFR "conicalP_1_e" $ gsl_sf_conicalP_1_e lambda x
-foreign import ccall "legendre.h gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_1(double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_1 :: Double -> Double -> Double
 conicalP_1 = gsl_sf_conicalP_1
-foreign import ccall "legendre.h gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_sph_reg_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_sph_reg&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_sph_reg :: CInt -> Double -> Double -> Double
 conicalP_sph_reg = gsl_sf_conicalP_sph_reg
-foreign import ccall "legendre.h gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_cyl_reg_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_conicalP_cyl_reg&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 conicalP_cyl_reg :: CInt -> Double -> Double -> Double
 conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg
-foreign import ccall "legendre.h gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double
+foreign import ccall "gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_H3d_0_e(double lambda,double eta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_0_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d_0_e :: Double -> Double -> (Double,Double)
 legendre_H3d_0_e lambda eta = createSFR "legendre_H3d_0_e" $ gsl_sf_legendre_H3d_0_e lambda eta
-foreign import ccall "legendre.h gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_H3d_0(double lambda,double eta);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_0&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d_0 :: Double -> Double -> Double
 legendre_H3d_0 = gsl_sf_legendre_H3d_0
-foreign import ccall "legendre.h gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_H3d_1_e(double lambda,double eta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d_1_e :: Double -> Double -> (Double,Double)
 legendre_H3d_1_e lambda eta = createSFR "legendre_H3d_1_e" $ gsl_sf_legendre_H3d_1_e lambda eta
-foreign import ccall "legendre.h gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_H3d_1(double lambda,double eta);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d_1 :: Double -> Double -> Double
 legendre_H3d_1 = gsl_sf_legendre_H3d_1
-foreign import ccall "legendre.h gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
+foreign import ccall "gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "legendre.h gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_legendre_H3d(int l,double lambda,double eta);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d :: CInt -> Double -> Double -> Double
 legendre_H3d = gsl_sf_legendre_H3d
-foreign import ccall "legendre.h gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double
+foreign import ccall "gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);
 --
 --   <http://www.google.com/search?q=gsl_sf_legendre_H3d_array&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
 legendre_H3d_array = gsl_sf_legendre_H3d_array
-foreign import ccall "legendre.h gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Log.hs
+++ b/lib/Numeric/GSL/Special/Log.hs
@@ -34,60 +34,60 @@
 --   <http://www.google.com/search?q=gsl_sf_log_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_e :: Double -> (Double,Double)
 log_e x = createSFR "log_e" $ gsl_sf_log_e x
-foreign import ccall "log.h gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_log(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_log&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log :: Double -> Double
 log = gsl_sf_log
-foreign import ccall "log.h gsl_sf_log" gsl_sf_log :: Double -> Double
+foreign import ccall "gsl_sf_log" gsl_sf_log :: Double -> Double
 
 -- | wrapper for int gsl_sf_log_abs_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_abs_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_abs_e :: Double -> (Double,Double)
 log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x
-foreign import ccall "log.h gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_log_abs(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_abs&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_abs :: Double -> Double
 log_abs = gsl_sf_log_abs
-foreign import ccall "log.h gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
+foreign import ccall "gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
 
 -- | wrapper for int gsl_sf_complex_log_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_log_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "log.h gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_log_1plusx_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_1plusx_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_1plusx_e :: Double -> (Double,Double)
 log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x
-foreign import ccall "log.h gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_log_1plusx(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_1plusx&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_1plusx :: Double -> Double
 log_1plusx = gsl_sf_log_1plusx
-foreign import ccall "log.h gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
+foreign import ccall "gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
 
 -- | wrapper for int gsl_sf_log_1plusx_mx_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_1plusx_mx_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_1plusx_mx_e :: Double -> (Double,Double)
 log_1plusx_mx_e x = createSFR "log_1plusx_mx_e" $ gsl_sf_log_1plusx_mx_e x
-foreign import ccall "log.h gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_log_1plusx_mx(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_log_1plusx_mx&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 log_1plusx_mx :: Double -> Double
 log_1plusx_mx = gsl_sf_log_1plusx_mx
-foreign import ccall "log.h gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Pow_int.hs
+++ b/lib/Numeric/GSL/Special/Pow_int.hs
@@ -28,11 +28,11 @@
 --   <http://www.google.com/search?q=gsl_sf_pow_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 pow_int_e :: Double -> CInt -> (Double,Double)
 pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n
-foreign import ccall "pow_int.h gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_pow_int(double x,int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_pow_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 pow_int :: Double -> CInt -> Double
 pow_int = gsl_sf_pow_int
-foreign import ccall "pow_int.h gsl_sf_pow_int" gsl_sf_pow_int :: Double -> CInt -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Psi.hs
+++ b/lib/Numeric/GSL/Special/Psi.hs
@@ -38,88 +38,88 @@
 --   <http://www.google.com/search?q=gsl_sf_psi_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_int_e :: CInt -> (Double,Double)
 psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n
-foreign import ccall "psi.h gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi_int(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_int :: CInt -> Double
 psi_int = gsl_sf_psi_int
-foreign import ccall "psi.h gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double
+foreign import ccall "gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double
 
 -- | wrapper for int gsl_sf_psi_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_e :: Double -> (Double,Double)
 psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x
-foreign import ccall "psi.h gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi :: Double -> Double
 psi = gsl_sf_psi
-foreign import ccall "psi.h gsl_sf_psi" gsl_sf_psi :: Double -> Double
+foreign import ccall "gsl_sf_psi" gsl_sf_psi :: Double -> Double
 
 -- | wrapper for int gsl_sf_psi_1piy_e(double y,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1piy_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1piy_e :: Double -> (Double,Double)
 psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y
-foreign import ccall "psi.h gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi_1piy(double y);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1piy&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1piy :: Double -> Double
 psi_1piy = gsl_sf_psi_1piy
-foreign import ccall "psi.h gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
+foreign import ccall "gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
 
 -- | wrapper for int gsl_sf_complex_psi_e(double x,double y,gsl_sf_result* result_re,gsl_sf_result* result_im);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_psi_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "psi.h gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_psi_1_int_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1_int_e :: CInt -> (Double,Double)
 psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n
-foreign import ccall "psi.h gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi_1_int(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1_int :: CInt -> Double
 psi_1_int = gsl_sf_psi_1_int
-foreign import ccall "psi.h gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double
+foreign import ccall "gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double
 
 -- | wrapper for int gsl_sf_psi_1_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1_e :: Double -> (Double,Double)
 psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x
-foreign import ccall "psi.h gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi_1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_1 :: Double -> Double
 psi_1 = gsl_sf_psi_1
-foreign import ccall "psi.h gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
+foreign import ccall "gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_psi_n_e(int n,double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_n_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_n_e :: CInt -> Double -> (Double,Double)
 psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x
-foreign import ccall "psi.h gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_psi_n(int n,double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_psi_n&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 psi_n :: CInt -> Double -> Double
 psi_n = gsl_sf_psi_n
-foreign import ccall "psi.h gsl_sf_psi_n" gsl_sf_psi_n :: CInt -> Double -> Double
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Synchrotron.hs
+++ b/lib/Numeric/GSL/Special/Synchrotron.hs
@@ -30,25 +30,25 @@
 --   <http://www.google.com/search?q=gsl_sf_synchrotron_1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 synchrotron_1_e :: Double -> (Double,Double)
 synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x
-foreign import ccall "synchrotron.h gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_synchrotron_1(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_synchrotron_1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 synchrotron_1 :: Double -> Double
 synchrotron_1 = gsl_sf_synchrotron_1
-foreign import ccall "synchrotron.h gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
+foreign import ccall "gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_synchrotron_2_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_synchrotron_2_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 synchrotron_2_e :: Double -> (Double,Double)
 synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x
-foreign import ccall "synchrotron.h gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_synchrotron_2(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_synchrotron_2&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 synchrotron_2 :: Double -> Double
 synchrotron_2 = gsl_sf_synchrotron_2
-foreign import ccall "synchrotron.h gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
+foreign import ccall "gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Trig.hs b/lib/Numeric/GSL/Special/Trig.hs
--- a/lib/Numeric/GSL/Special/Trig.hs
+++ b/lib/Numeric/GSL/Special/Trig.hs
@@ -44,172 +44,172 @@
 --   <http://www.google.com/search?q=gsl_sf_sin_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 sin_e :: Double -> (Double,Double)
 sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x
-foreign import ccall "trig.h gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_sin(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_sin&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 sin :: Double -> Double
 sin = gsl_sf_sin
-foreign import ccall "trig.h gsl_sf_sin" gsl_sf_sin :: Double -> Double
+foreign import ccall "gsl_sf_sin" gsl_sf_sin :: Double -> Double
 
 -- | wrapper for int gsl_sf_cos_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_cos_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 cos_e :: Double -> (Double,Double)
 cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x
-foreign import ccall "trig.h gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_cos(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_cos&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 cos :: Double -> Double
 cos = gsl_sf_cos
-foreign import ccall "trig.h gsl_sf_cos" gsl_sf_cos :: Double -> Double
+foreign import ccall "gsl_sf_cos" gsl_sf_cos :: Double -> Double
 
 -- | wrapper for int gsl_sf_hypot_e(double x,double y,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hypot_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hypot_e :: Double -> Double -> (Double,Double)
 hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y
-foreign import ccall "trig.h gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hypot(double x,double y);
 --
 --   <http://www.google.com/search?q=gsl_sf_hypot&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hypot :: Double -> Double -> Double
 hypot = gsl_sf_hypot
-foreign import ccall "trig.h gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
+foreign import ccall "gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_complex_sin_e(double zr,double zi,gsl_sf_result* szr,gsl_sf_result* szi);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_sin_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "trig.h gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_complex_cos_e(double zr,double zi,gsl_sf_result* czr,gsl_sf_result* czi);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_cos_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "trig.h gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_complex_logsin_e(double zr,double zi,gsl_sf_result* lszr,gsl_sf_result* lszi);
 --
 --   <http://www.google.com/search?q=gsl_sf_complex_logsin_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "trig.h gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_sinc_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_sinc_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 sinc_e :: Double -> (Double,Double)
 sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x
-foreign import ccall "trig.h gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_sinc(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_sinc&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 sinc :: Double -> Double
 sinc = gsl_sf_sinc
-foreign import ccall "trig.h gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
+foreign import ccall "gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
 
 -- | wrapper for int gsl_sf_lnsinh_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnsinh_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnsinh_e :: Double -> (Double,Double)
 lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x
-foreign import ccall "trig.h gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lnsinh(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lnsinh&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lnsinh :: Double -> Double
 lnsinh = gsl_sf_lnsinh
-foreign import ccall "trig.h gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
+foreign import ccall "gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
 
 -- | wrapper for int gsl_sf_lncosh_e(double x,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_lncosh_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lncosh_e :: Double -> (Double,Double)
 lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x
-foreign import ccall "trig.h gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_lncosh(double x);
 --
 --   <http://www.google.com/search?q=gsl_sf_lncosh&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 lncosh :: Double -> Double
 lncosh = gsl_sf_lncosh
-foreign import ccall "trig.h gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
+foreign import ccall "gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
 
 -- | wrapper for int gsl_sf_polar_to_rect(double r,double theta,gsl_sf_result* x,gsl_sf_result* y);
 --
 --   <http://www.google.com/search?q=gsl_sf_polar_to_rect&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "trig.h gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_rect_to_polar(double x,double y,gsl_sf_result* r,gsl_sf_result* theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_rect_to_polar&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 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 "trig.h gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_sin_err_e(double x,double dx,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_sin_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 sin_err_e :: Double -> Double -> (Double,Double)
 sin_err_e x dx = createSFR "sin_err_e" $ gsl_sf_sin_err_e x dx
-foreign import ccall "trig.h gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_cos_err_e(double x,double dx,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_cos_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 cos_err_e :: Double -> Double -> (Double,Double)
 cos_err_e x dx = createSFR "cos_err_e" $ gsl_sf_cos_err_e x dx
-foreign import ccall "trig.h gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_angle_restrict_symm_e(double* theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_symm_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_symm_e :: Ptr Double -> CInt
 angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e
-foreign import ccall "trig.h gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt
+foreign import ccall "gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt
 
 -- | wrapper for double gsl_sf_angle_restrict_symm(double theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_symm&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_symm :: Double -> Double
 angle_restrict_symm = gsl_sf_angle_restrict_symm
-foreign import ccall "trig.h gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
+foreign import ccall "gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
 
 -- | wrapper for int gsl_sf_angle_restrict_pos_e(double* theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_pos_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_pos_e :: Ptr Double -> CInt
 angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e
-foreign import ccall "trig.h gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt
+foreign import ccall "gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt
 
 -- | wrapper for double gsl_sf_angle_restrict_pos(double theta);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_pos&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_pos :: Double -> Double
 angle_restrict_pos = gsl_sf_angle_restrict_pos
-foreign import ccall "trig.h gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
+foreign import ccall "gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
 
 -- | wrapper for int gsl_sf_angle_restrict_symm_err_e(double theta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_symm_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_symm_err_e :: Double -> (Double,Double)
 angle_restrict_symm_err_e theta = createSFR "angle_restrict_symm_err_e" $ gsl_sf_angle_restrict_symm_err_e theta
-foreign import ccall "trig.h gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for int gsl_sf_angle_restrict_pos_err_e(double theta,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_angle_restrict_pos_err_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 angle_restrict_pos_err_e :: Double -> (Double,Double)
 angle_restrict_pos_err_e theta = createSFR "angle_restrict_pos_err_e" $ gsl_sf_angle_restrict_pos_err_e theta
-foreign import ccall "trig.h gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "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
--- a/lib/Numeric/GSL/Special/Zeta.hs
+++ b/lib/Numeric/GSL/Special/Zeta.hs
@@ -40,95 +40,95 @@
 --   <http://www.google.com/search?q=gsl_sf_zeta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zeta_int_e :: CInt -> (Double,Double)
 zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n
-foreign import ccall "zeta.h gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_zeta_int(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_zeta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zeta_int :: CInt -> Double
 zeta_int = gsl_sf_zeta_int
-foreign import ccall "zeta.h gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double
+foreign import ccall "gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double
 
 -- | wrapper for int gsl_sf_zeta_e(double s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_zeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zeta_e :: Double -> (Double,Double)
 zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s
-foreign import ccall "zeta.h gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_zeta(double s);
 --
 --   <http://www.google.com/search?q=gsl_sf_zeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zeta :: Double -> Double
 zeta = gsl_sf_zeta
-foreign import ccall "zeta.h gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
+foreign import ccall "gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
 
 -- | wrapper for int gsl_sf_zetam1_e(double s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_zetam1_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zetam1_e :: Double -> (Double,Double)
 zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s
-foreign import ccall "zeta.h gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_zetam1(double s);
 --
 --   <http://www.google.com/search?q=gsl_sf_zetam1&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zetam1 :: Double -> Double
 zetam1 = gsl_sf_zetam1
-foreign import ccall "zeta.h gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
+foreign import ccall "gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
 
 -- | wrapper for int gsl_sf_zetam1_int_e(int s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_zetam1_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zetam1_int_e :: CInt -> (Double,Double)
 zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s
-foreign import ccall "zeta.h gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_zetam1_int(int s);
 --
 --   <http://www.google.com/search?q=gsl_sf_zetam1_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 zetam1_int :: CInt -> Double
 zetam1_int = gsl_sf_zetam1_int
-foreign import ccall "zeta.h gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double
+foreign import ccall "gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double
 
 -- | wrapper for int gsl_sf_hzeta_e(double s,double q,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_hzeta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hzeta_e :: Double -> Double -> (Double,Double)
 hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q
-foreign import ccall "zeta.h gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_hzeta(double s,double q);
 --
 --   <http://www.google.com/search?q=gsl_sf_hzeta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 hzeta :: Double -> Double -> Double
 hzeta = gsl_sf_hzeta
-foreign import ccall "zeta.h gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
+foreign import ccall "gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
 
 -- | wrapper for int gsl_sf_eta_int_e(int n,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_eta_int_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 eta_int_e :: CInt -> (Double,Double)
 eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n
-foreign import ccall "zeta.h gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_eta_int(int n);
 --
 --   <http://www.google.com/search?q=gsl_sf_eta_int&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 eta_int :: CInt -> Double
 eta_int = gsl_sf_eta_int
-foreign import ccall "zeta.h gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double
+foreign import ccall "gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double
 
 -- | wrapper for int gsl_sf_eta_e(double s,gsl_sf_result* result);
 --
 --   <http://www.google.com/search?q=gsl_sf_eta_e&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 eta_e :: Double -> (Double,Double)
 eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s
-foreign import ccall "zeta.h gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt
+foreign import ccall "gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt
 
 -- | wrapper for double gsl_sf_eta(double s);
 --
 --   <http://www.google.com/search?q=gsl_sf_eta&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>
 eta :: Double -> Double
 eta = gsl_sf_eta
-foreign import ccall "zeta.h gsl_sf_eta" gsl_sf_eta :: Double -> Double
+foreign import ccall "gsl_sf_eta" gsl_sf_eta :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/airy.h b/lib/Numeric/GSL/Special/airy.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/airy.h
+++ /dev/null
@@ -1,24 +0,0 @@
-int gsl_sf_airy_Ai_e(double x,int mode,double* result);
-double gsl_sf_airy_Ai(double x,int mode);
-int gsl_sf_airy_Bi_e(double x,int mode,double* result);
-double gsl_sf_airy_Bi(double x,int mode);
-int gsl_sf_airy_Ai_scaled_e(double x,int mode,double* result);
-double gsl_sf_airy_Ai_scaled(double x,int mode);
-int gsl_sf_airy_Bi_scaled_e(double x,int mode,double* result);
-double gsl_sf_airy_Bi_scaled(double x,int mode);
-int gsl_sf_airy_Ai_deriv_e(double x,int mode,double* result);
-double gsl_sf_airy_Ai_deriv(double x,int mode);
-int gsl_sf_airy_Bi_deriv_e(double x,int mode,double* result);
-double gsl_sf_airy_Bi_deriv(double x,int mode);
-int gsl_sf_airy_Ai_deriv_scaled_e(double x,int mode,double* result);
-double gsl_sf_airy_Ai_deriv_scaled(double x,int mode);
-int gsl_sf_airy_Bi_deriv_scaled_e(double x,int mode,double* result);
-double gsl_sf_airy_Bi_deriv_scaled(double x,int mode);
-int gsl_sf_airy_zero_Ai_e(int s,double* result);
-double gsl_sf_airy_zero_Ai(int s);
-int gsl_sf_airy_zero_Bi_e(int s,double* result);
-double gsl_sf_airy_zero_Bi(int s);
-int gsl_sf_airy_zero_Ai_deriv_e(int s,double* result);
-double gsl_sf_airy_zero_Ai_deriv(int s);
-int gsl_sf_airy_zero_Bi_deriv_e(int s,double* result);
-double gsl_sf_airy_zero_Bi_deriv(int s);
diff --git a/lib/Numeric/GSL/Special/auto.hs b/lib/Numeric/GSL/Special/auto.hs
--- a/lib/Numeric/GSL/Special/auto.hs
+++ b/lib/Numeric/GSL/Special/auto.hs
@@ -54,7 +54,7 @@
     putStrLn headerfile
     --mapM_ print (headers $ fixlong file)
     let parsed = (headers $ fixlong file)
-    writeFile (name ++".h") (fixC $ unlines $ map showC parsed) 
+    -- writeFile (name ++".h") (fixC $ unlines $ map showC parsed) 
 
     --putStrLn ""
     --mapM (\(Header _ n _) -> putStrLn (drop 7 n ++",")) parsed
@@ -180,7 +180,7 @@
 
 showCa (t, a) = showCt t ++" "++ a
 
-showH hc h@(Header t n args) = "foreign import ccall \""++hc++" "++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
+showH hc h@(Header t n args) = "foreign import ccall \""++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
     where t' | pure h = showHt t
              | otherwise = "IO "++showHt t
 
diff --git a/lib/Numeric/GSL/Special/bessel.h b/lib/Numeric/GSL/Special/bessel.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/bessel.h
+++ /dev/null
@@ -1,100 +0,0 @@
-int gsl_sf_bessel_J0_e(double x,double* result);
-double gsl_sf_bessel_J0(double x);
-int gsl_sf_bessel_J1_e(double x,double* result);
-double gsl_sf_bessel_J1(double x);
-int gsl_sf_bessel_Jn_e(int n,double x,double* result);
-double gsl_sf_bessel_Jn(int n,double x);
-int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_Y0_e(double x,double* result);
-double gsl_sf_bessel_Y0(double x);
-int gsl_sf_bessel_Y1_e(double x,double* result);
-double gsl_sf_bessel_Y1(double x);
-int gsl_sf_bessel_Yn_e(int n,double x,double* result);
-double gsl_sf_bessel_Yn(int n,double x);
-int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_I0_e(double x,double* result);
-double gsl_sf_bessel_I0(double x);
-int gsl_sf_bessel_I1_e(double x,double* result);
-double gsl_sf_bessel_I1(double x);
-int gsl_sf_bessel_In_e(int n,double x,double* result);
-double gsl_sf_bessel_In(int n,double x);
-int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_I0_scaled_e(double x,double* result);
-double gsl_sf_bessel_I0_scaled(double x);
-int gsl_sf_bessel_I1_scaled_e(double x,double* result);
-double gsl_sf_bessel_I1_scaled(double x);
-int gsl_sf_bessel_In_scaled_e(int n,double x,double* result);
-double gsl_sf_bessel_In_scaled(int n,double x);
-int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_K0_e(double x,double* result);
-double gsl_sf_bessel_K0(double x);
-int gsl_sf_bessel_K1_e(double x,double* result);
-double gsl_sf_bessel_K1(double x);
-int gsl_sf_bessel_Kn_e(int n,double x,double* result);
-double gsl_sf_bessel_Kn(int n,double x);
-int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_K0_scaled_e(double x,double* result);
-double gsl_sf_bessel_K0_scaled(double x);
-int gsl_sf_bessel_K1_scaled_e(double x,double* result);
-double gsl_sf_bessel_K1_scaled(double x);
-int gsl_sf_bessel_Kn_scaled_e(int n,double x,double* result);
-double gsl_sf_bessel_Kn_scaled(int n,double x);
-int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array);
-int gsl_sf_bessel_j0_e(double x,double* result);
-double gsl_sf_bessel_j0(double x);
-int gsl_sf_bessel_j1_e(double x,double* result);
-double gsl_sf_bessel_j1(double x);
-int gsl_sf_bessel_j2_e(double x,double* result);
-double gsl_sf_bessel_j2(double x);
-int gsl_sf_bessel_jl_e(int l,double x,double* result);
-double gsl_sf_bessel_jl(int l,double x);
-int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array);
-int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array);
-int gsl_sf_bessel_y0_e(double x,double* result);
-double gsl_sf_bessel_y0(double x);
-int gsl_sf_bessel_y1_e(double x,double* result);
-double gsl_sf_bessel_y1(double x);
-int gsl_sf_bessel_y2_e(double x,double* result);
-double gsl_sf_bessel_y2(double x);
-int gsl_sf_bessel_yl_e(int l,double x,double* result);
-double gsl_sf_bessel_yl(int l,double x);
-int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array);
-int gsl_sf_bessel_i0_scaled_e(double x,double* result);
-double gsl_sf_bessel_i0_scaled(double x);
-int gsl_sf_bessel_i1_scaled_e(double x,double* result);
-double gsl_sf_bessel_i1_scaled(double x);
-int gsl_sf_bessel_i2_scaled_e(double x,double* result);
-double gsl_sf_bessel_i2_scaled(double x);
-int gsl_sf_bessel_il_scaled_e(int l,double x,double* result);
-double gsl_sf_bessel_il_scaled(int l,double x);
-int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array);
-int gsl_sf_bessel_k0_scaled_e(double x,double* result);
-double gsl_sf_bessel_k0_scaled(double x);
-int gsl_sf_bessel_k1_scaled_e(double x,double* result);
-double gsl_sf_bessel_k1_scaled(double x);
-int gsl_sf_bessel_k2_scaled_e(double x,double* result);
-double gsl_sf_bessel_k2_scaled(double x);
-int gsl_sf_bessel_kl_scaled_e(int l,double x,double* result);
-double gsl_sf_bessel_kl_scaled(int l,double x);
-int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array);
-int gsl_sf_bessel_Jnu_e(double nu,double x,double* result);
-double gsl_sf_bessel_Jnu(double nu,double x);
-int gsl_sf_bessel_Ynu_e(double nu,double x,double* result);
-double gsl_sf_bessel_Ynu(double nu,double x);
-int gsl_sf_bessel_sequence_Jnu_e(double nu,int mode,size_t size,double* v);
-int gsl_sf_bessel_Inu_scaled_e(double nu,double x,double* result);
-double gsl_sf_bessel_Inu_scaled(double nu,double x);
-int gsl_sf_bessel_Inu_e(double nu,double x,double* result);
-double gsl_sf_bessel_Inu(double nu,double x);
-int gsl_sf_bessel_Knu_scaled_e(double nu,double x,double* result);
-double gsl_sf_bessel_Knu_scaled(double nu,double x);
-int gsl_sf_bessel_Knu_e(double nu,double x,double* result);
-double gsl_sf_bessel_Knu(double nu,double x);
-int gsl_sf_bessel_lnKnu_e(double nu,double x,double* result);
-double gsl_sf_bessel_lnKnu(double nu,double x);
-int gsl_sf_bessel_zero_J0_e(int s,double* result);
-double gsl_sf_bessel_zero_J0(int s);
-int gsl_sf_bessel_zero_J1_e(int s,double* result);
-double gsl_sf_bessel_zero_J1(int s);
-int gsl_sf_bessel_zero_Jnu_e(double nu,int s,double* result);
-double gsl_sf_bessel_zero_Jnu(double nu,int s);
diff --git a/lib/Numeric/GSL/Special/clausen.h b/lib/Numeric/GSL/Special/clausen.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/clausen.h
+++ /dev/null
@@ -1,2 +0,0 @@
-int gsl_sf_clausen_e(double x,double* result);
-double gsl_sf_clausen(double x);
diff --git a/lib/Numeric/GSL/Special/coulomb.h b/lib/Numeric/GSL/Special/coulomb.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/coulomb.h
+++ /dev/null
@@ -1,11 +0,0 @@
-int gsl_sf_hydrogenicR_1_e(double Z,double r,double* result);
-double gsl_sf_hydrogenicR_1(double Z,double r);
-int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,double* result);
-double gsl_sf_hydrogenicR(int n,int l,double Z,double r);
-int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,double* F,double* Fp,double* G,double* Gp,double* exp_F,double* exp_G);
-int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
-int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent);
-int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent);
-int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent);
-int gsl_sf_coulomb_CL_e(double L,double eta,double* result);
-int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl);
diff --git a/lib/Numeric/GSL/Special/coupling.h b/lib/Numeric/GSL/Special/coupling.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/coupling.h
+++ /dev/null
@@ -1,10 +0,0 @@
-int gsl_sf_coupling_3j_e(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc,double* result);
-double gsl_sf_coupling_3j(int two_ja,int two_jb,int two_jc,int two_ma,int two_mb,int two_mc);
-int gsl_sf_coupling_6j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
-double gsl_sf_coupling_6j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
-int gsl_sf_coupling_RacahW_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
-double gsl_sf_coupling_RacahW(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
-int gsl_sf_coupling_9j_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji,double* result);
-double gsl_sf_coupling_9j(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,int two_jg,int two_jh,int two_ji);
-int gsl_sf_coupling_6j_INCORRECT_e(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf,double* result);
-double gsl_sf_coupling_6j_INCORRECT(int two_ja,int two_jb,int two_jc,int two_jd,int two_je,int two_jf);
diff --git a/lib/Numeric/GSL/Special/dawson.h b/lib/Numeric/GSL/Special/dawson.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/dawson.h
+++ /dev/null
@@ -1,2 +0,0 @@
-int gsl_sf_dawson_e(double x,double* result);
-double gsl_sf_dawson(double x);
diff --git a/lib/Numeric/GSL/Special/debye.h b/lib/Numeric/GSL/Special/debye.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/debye.h
+++ /dev/null
@@ -1,12 +0,0 @@
-int gsl_sf_debye_1_e(double x,double* result);
-double gsl_sf_debye_1(double x);
-int gsl_sf_debye_2_e(double x,double* result);
-double gsl_sf_debye_2(double x);
-int gsl_sf_debye_3_e(double x,double* result);
-double gsl_sf_debye_3(double x);
-int gsl_sf_debye_4_e(double x,double* result);
-double gsl_sf_debye_4(double x);
-int gsl_sf_debye_5_e(double x,double* result);
-double gsl_sf_debye_5(double x);
-int gsl_sf_debye_6_e(double x,double* result);
-double gsl_sf_debye_6(double x);
diff --git a/lib/Numeric/GSL/Special/dilog.h b/lib/Numeric/GSL/Special/dilog.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/dilog.h
+++ /dev/null
@@ -1,5 +0,0 @@
-int gsl_sf_dilog_e(double x,double* result);
-double gsl_sf_dilog(double x);
-int gsl_sf_complex_dilog_xy_e(double x,double y,double* result_re,double* result_im);
-int gsl_sf_complex_dilog_e(double r,double theta,double* result_re,double* result_im);
-int gsl_sf_complex_spence_xy_e(double x,double y,double* real_sp,double* imag_sp);
diff --git a/lib/Numeric/GSL/Special/elementary.h b/lib/Numeric/GSL/Special/elementary.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/elementary.h
+++ /dev/null
@@ -1,3 +0,0 @@
-int gsl_sf_multiply_e(double x,double y,double* result);
-double gsl_sf_multiply(double x,double y);
-int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,double* result);
diff --git a/lib/Numeric/GSL/Special/ellint.h b/lib/Numeric/GSL/Special/ellint.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/ellint.h
+++ /dev/null
@@ -1,24 +0,0 @@
-int gsl_sf_ellint_Kcomp_e(double k,int mode,double* result);
-double gsl_sf_ellint_Kcomp(double k,int mode);
-int gsl_sf_ellint_Ecomp_e(double k,int mode,double* result);
-double gsl_sf_ellint_Ecomp(double k,int mode);
-int gsl_sf_ellint_Pcomp_e(double k,double n,int mode,double* result);
-double gsl_sf_ellint_Pcomp(double k,double n,int mode);
-int gsl_sf_ellint_Dcomp_e(double k,int mode,double* result);
-double gsl_sf_ellint_Dcomp(double k,int mode);
-int gsl_sf_ellint_F_e(double phi,double k,int mode,double* result);
-double gsl_sf_ellint_F(double phi,double k,int mode);
-int gsl_sf_ellint_E_e(double phi,double k,int mode,double* result);
-double gsl_sf_ellint_E(double phi,double k,int mode);
-int gsl_sf_ellint_P_e(double phi,double k,double n,int mode,double* result);
-double gsl_sf_ellint_P(double phi,double k,double n,int mode);
-int gsl_sf_ellint_D_e(double phi,double k,double n,int mode,double* result);
-double gsl_sf_ellint_D(double phi,double k,double n,int mode);
-int gsl_sf_ellint_RC_e(double x,double y,int mode,double* result);
-double gsl_sf_ellint_RC(double x,double y,int mode);
-int gsl_sf_ellint_RD_e(double x,double y,double z,int mode,double* result);
-double gsl_sf_ellint_RD(double x,double y,double z,int mode);
-int gsl_sf_ellint_RF_e(double x,double y,double z,int mode,double* result);
-double gsl_sf_ellint_RF(double x,double y,double z,int mode);
-int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,int mode,double* result);
-double gsl_sf_ellint_RJ(double x,double y,double z,double p,int mode);
diff --git a/lib/Numeric/GSL/Special/erf.h b/lib/Numeric/GSL/Special/erf.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/erf.h
+++ /dev/null
@@ -1,12 +0,0 @@
-int gsl_sf_erfc_e(double x,double* result);
-double gsl_sf_erfc(double x);
-int gsl_sf_log_erfc_e(double x,double* result);
-double gsl_sf_log_erfc(double x);
-int gsl_sf_erf_e(double x,double* result);
-double gsl_sf_erf(double x);
-int gsl_sf_erf_Z_e(double x,double* result);
-int gsl_sf_erf_Q_e(double x,double* result);
-double gsl_sf_erf_Z(double x);
-double gsl_sf_erf_Q(double x);
-int gsl_sf_hazard_e(double x,double* result);
-double gsl_sf_hazard(double x);
diff --git a/lib/Numeric/GSL/Special/exp.h b/lib/Numeric/GSL/Special/exp.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/exp.h
+++ /dev/null
@@ -1,18 +0,0 @@
-int gsl_sf_exp_e(double x,double* result);
-double gsl_sf_exp(double x);
-int gsl_sf_exp_e10_e(double x,double* result);
-int gsl_sf_exp_mult_e(double x,double y,double* result);
-double gsl_sf_exp_mult(double x,double y);
-int gsl_sf_exp_mult_e10_e(double x,double y,double* result);
-int gsl_sf_expm1_e(double x,double* result);
-double gsl_sf_expm1(double x);
-int gsl_sf_exprel_e(double x,double* result);
-double gsl_sf_exprel(double x);
-int gsl_sf_exprel_2_e(double x,double* result);
-double gsl_sf_exprel_2(double x);
-int gsl_sf_exprel_n_e(int n,double x,double* result);
-double gsl_sf_exprel_n(int n,double x);
-int gsl_sf_exp_err_e(double x,double dx,double* result);
-int gsl_sf_exp_err_e10_e(double x,double dx,double* result);
-int gsl_sf_exp_mult_err_e(double x,double dx,double y,double dy,double* result);
-int gsl_sf_exp_mult_err_e10_e(double x,double dx,double y,double dy,double* result);
diff --git a/lib/Numeric/GSL/Special/expint.h b/lib/Numeric/GSL/Special/expint.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/expint.h
+++ /dev/null
@@ -1,24 +0,0 @@
-int gsl_sf_expint_E1_e(double x,double* result);
-double gsl_sf_expint_E1(double x);
-int gsl_sf_expint_E2_e(double x,double* result);
-double gsl_sf_expint_E2(double x);
-int gsl_sf_expint_E1_scaled_e(double x,double* result);
-double gsl_sf_expint_E1_scaled(double x);
-int gsl_sf_expint_E2_scaled_e(double x,double* result);
-double gsl_sf_expint_E2_scaled(double x);
-int gsl_sf_expint_Ei_e(double x,double* result);
-double gsl_sf_expint_Ei(double x);
-int gsl_sf_expint_Ei_scaled_e(double x,double* result);
-double gsl_sf_expint_Ei_scaled(double x);
-int gsl_sf_Shi_e(double x,double* result);
-double gsl_sf_Shi(double x);
-int gsl_sf_Chi_e(double x,double* result);
-double gsl_sf_Chi(double x);
-int gsl_sf_expint_3_e(double x,double* result);
-double gsl_sf_expint_3(double x);
-int gsl_sf_Si_e(double x,double* result);
-double gsl_sf_Si(double x);
-int gsl_sf_Ci_e(double x,double* result);
-double gsl_sf_Ci(double x);
-int gsl_sf_atanint_e(double x,double* result);
-double gsl_sf_atanint(double x);
diff --git a/lib/Numeric/GSL/Special/fermi_dirac.h b/lib/Numeric/GSL/Special/fermi_dirac.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/fermi_dirac.h
+++ /dev/null
@@ -1,18 +0,0 @@
-int gsl_sf_fermi_dirac_m1_e(double x,double* result);
-double gsl_sf_fermi_dirac_m1(double x);
-int gsl_sf_fermi_dirac_0_e(double x,double* result);
-double gsl_sf_fermi_dirac_0(double x);
-int gsl_sf_fermi_dirac_1_e(double x,double* result);
-double gsl_sf_fermi_dirac_1(double x);
-int gsl_sf_fermi_dirac_2_e(double x,double* result);
-double gsl_sf_fermi_dirac_2(double x);
-int gsl_sf_fermi_dirac_int_e(int j,double x,double* result);
-double gsl_sf_fermi_dirac_int(int j,double x);
-int gsl_sf_fermi_dirac_mhalf_e(double x,double* result);
-double gsl_sf_fermi_dirac_mhalf(double x);
-int gsl_sf_fermi_dirac_half_e(double x,double* result);
-double gsl_sf_fermi_dirac_half(double x);
-int gsl_sf_fermi_dirac_3half_e(double x,double* result);
-double gsl_sf_fermi_dirac_3half(double x);
-int gsl_sf_fermi_dirac_inc_0_e(double x,double b,double* result);
-double gsl_sf_fermi_dirac_inc_0(double x,double b);
diff --git a/lib/Numeric/GSL/Special/gamma.h b/lib/Numeric/GSL/Special/gamma.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/gamma.h
+++ /dev/null
@@ -1,44 +0,0 @@
-int gsl_sf_lngamma_e(double x,double* result);
-double gsl_sf_lngamma(double x);
-int gsl_sf_lngamma_sgn_e(double x,double* result_lg,double* sgn);
-int gsl_sf_gamma_e(double x,double* result);
-double gsl_sf_gamma(double x);
-int gsl_sf_gammastar_e(double x,double* result);
-double gsl_sf_gammastar(double x);
-int gsl_sf_gammainv_e(double x,double* result);
-double gsl_sf_gammainv(double x);
-int gsl_sf_lngamma_complex_e(double zr,double zi,double* lnr,double* arg);
-int gsl_sf_taylorcoeff_e(int n,double x,double* result);
-double gsl_sf_taylorcoeff(int n,double x);
-int gsl_sf_fact_e(int n,double* result);
-double gsl_sf_fact(int n);
-int gsl_sf_doublefact_e(int n,double* result);
-double gsl_sf_doublefact(int n);
-int gsl_sf_lnfact_e(int n,double* result);
-double gsl_sf_lnfact(int n);
-int gsl_sf_lndoublefact_e(int n,double* result);
-double gsl_sf_lndoublefact(int n);
-int gsl_sf_lnchoose_e(int n,int m,double* result);
-double gsl_sf_lnchoose(int n,int m);
-int gsl_sf_choose_e(int n,int m,double* result);
-double gsl_sf_choose(int n,int m);
-int gsl_sf_lnpoch_e(double a,double x,double* result);
-double gsl_sf_lnpoch(double a,double x);
-int gsl_sf_lnpoch_sgn_e(double a,double x,double* result,double* sgn);
-int gsl_sf_poch_e(double a,double x,double* result);
-double gsl_sf_poch(double a,double x);
-int gsl_sf_pochrel_e(double a,double x,double* result);
-double gsl_sf_pochrel(double a,double x);
-int gsl_sf_gamma_inc_Q_e(double a,double x,double* result);
-double gsl_sf_gamma_inc_Q(double a,double x);
-int gsl_sf_gamma_inc_P_e(double a,double x,double* result);
-double gsl_sf_gamma_inc_P(double a,double x);
-int gsl_sf_gamma_inc_e(double a,double x,double* result);
-double gsl_sf_gamma_inc(double a,double x);
-int gsl_sf_lnbeta_e(double a,double b,double* result);
-double gsl_sf_lnbeta(double a,double b);
-int gsl_sf_lnbeta_sgn_e(double x,double y,double* result,double* sgn);
-int gsl_sf_beta_e(double a,double b,double* result);
-double gsl_sf_beta(double a,double b);
-int gsl_sf_beta_inc_e(double a,double b,double x,double* result);
-double gsl_sf_beta_inc(double a,double b,double x);
diff --git a/lib/Numeric/GSL/Special/gegenbauer.h b/lib/Numeric/GSL/Special/gegenbauer.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/gegenbauer.h
+++ /dev/null
@@ -1,9 +0,0 @@
-int gsl_sf_gegenpoly_1_e(double lambda,double x,double* result);
-int gsl_sf_gegenpoly_2_e(double lambda,double x,double* result);
-int gsl_sf_gegenpoly_3_e(double lambda,double x,double* result);
-double gsl_sf_gegenpoly_1(double lambda,double x);
-double gsl_sf_gegenpoly_2(double lambda,double x);
-double gsl_sf_gegenpoly_3(double lambda,double x);
-int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,double* result);
-double gsl_sf_gegenpoly_n(int n,double lambda,double x);
-int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array);
diff --git a/lib/Numeric/GSL/Special/hyperg.h b/lib/Numeric/GSL/Special/hyperg.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/hyperg.h
+++ /dev/null
@@ -1,22 +0,0 @@
-int gsl_sf_hyperg_0F1_e(double c,double x,double* result);
-double gsl_sf_hyperg_0F1(double c,double x);
-int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,double* result);
-double gsl_sf_hyperg_1F1_int(int m,int n,double x);
-int gsl_sf_hyperg_1F1_e(double a,double b,double x,double* result);
-double gsl_sf_hyperg_1F1(double a,double b,double x);
-int gsl_sf_hyperg_U_int_e(int m,int n,double x,double* result);
-double gsl_sf_hyperg_U_int(int m,int n,double x);
-int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,double* result);
-int gsl_sf_hyperg_U_e(double a,double b,double x,double* result);
-double gsl_sf_hyperg_U(double a,double b,double x);
-int gsl_sf_hyperg_U_e10_e(double a,double b,double x,double* result);
-int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,double* result);
-double gsl_sf_hyperg_2F1(double a,double b,double c,double x);
-int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,double* result);
-double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x);
-int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,double* result);
-double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x);
-int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,double* result);
-double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x);
-int gsl_sf_hyperg_2F0_e(double a,double b,double x,double* result);
-double gsl_sf_hyperg_2F0(double a,double b,double x);
diff --git a/lib/Numeric/GSL/Special/laguerre.h b/lib/Numeric/GSL/Special/laguerre.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/laguerre.h
+++ /dev/null
@@ -1,8 +0,0 @@
-int gsl_sf_laguerre_1_e(double a,double x,double* result);
-int gsl_sf_laguerre_2_e(double a,double x,double* result);
-int gsl_sf_laguerre_3_e(double a,double x,double* result);
-double gsl_sf_laguerre_1(double a,double x);
-double gsl_sf_laguerre_2(double a,double x);
-double gsl_sf_laguerre_3(double a,double x);
-int gsl_sf_laguerre_n_e(int n,double a,double x,double* result);
-double gsl_sf_laguerre_n(int n,double a,double x);
diff --git a/lib/Numeric/GSL/Special/lambert.h b/lib/Numeric/GSL/Special/lambert.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/lambert.h
+++ /dev/null
@@ -1,4 +0,0 @@
-int gsl_sf_lambert_W0_e(double x,double* result);
-double gsl_sf_lambert_W0(double x);
-int gsl_sf_lambert_Wm1_e(double x,double* result);
-double gsl_sf_lambert_Wm1(double x);
diff --git a/lib/Numeric/GSL/Special/legendre.h b/lib/Numeric/GSL/Special/legendre.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/legendre.h
+++ /dev/null
@@ -1,44 +0,0 @@
-int gsl_sf_legendre_Pl_e(int l,double x,double* result);
-double gsl_sf_legendre_Pl(int l,double x);
-int gsl_sf_legendre_Pl_array(int lmax,double x,double* result_array);
-int gsl_sf_legendre_Pl_deriv_array(int lmax,double x,double* result_array,double* result_deriv_array);
-int gsl_sf_legendre_P1_e(double x,double* result);
-int gsl_sf_legendre_P2_e(double x,double* result);
-int gsl_sf_legendre_P3_e(double x,double* result);
-double gsl_sf_legendre_P1(double x);
-double gsl_sf_legendre_P2(double x);
-double gsl_sf_legendre_P3(double x);
-int gsl_sf_legendre_Q0_e(double x,double* result);
-double gsl_sf_legendre_Q0(double x);
-int gsl_sf_legendre_Q1_e(double x,double* result);
-double gsl_sf_legendre_Q1(double x);
-int gsl_sf_legendre_Ql_e(int l,double x,double* result);
-double gsl_sf_legendre_Ql(int l,double x);
-int gsl_sf_legendre_Plm_e(int l,int m,double x,double* result);
-double gsl_sf_legendre_Plm(int l,int m,double x);
-int gsl_sf_legendre_Plm_array(int lmax,int m,double x,double* result_array);
-int gsl_sf_legendre_Plm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
-int gsl_sf_legendre_sphPlm_e(int l,int m,double x,double* result);
-double gsl_sf_legendre_sphPlm(int l,int m,double x);
-int gsl_sf_legendre_sphPlm_array(int lmax,int m,double x,double* result_array);
-int gsl_sf_legendre_sphPlm_deriv_array(int lmax,int m,double x,double* result_array,double* result_deriv_array);
-int gsl_sf_legendre_array_size(int lmax,int m);
-int gsl_sf_conicalP_half_e(double lambda,double x,double* result);
-double gsl_sf_conicalP_half(double lambda,double x);
-int gsl_sf_conicalP_mhalf_e(double lambda,double x,double* result);
-double gsl_sf_conicalP_mhalf(double lambda,double x);
-int gsl_sf_conicalP_0_e(double lambda,double x,double* result);
-double gsl_sf_conicalP_0(double lambda,double x);
-int gsl_sf_conicalP_1_e(double lambda,double x,double* result);
-double gsl_sf_conicalP_1(double lambda,double x);
-int gsl_sf_conicalP_sph_reg_e(int l,double lambda,double x,double* result);
-double gsl_sf_conicalP_sph_reg(int l,double lambda,double x);
-int gsl_sf_conicalP_cyl_reg_e(int m,double lambda,double x,double* result);
-double gsl_sf_conicalP_cyl_reg(int m,double lambda,double x);
-int gsl_sf_legendre_H3d_0_e(double lambda,double eta,double* result);
-double gsl_sf_legendre_H3d_0(double lambda,double eta);
-int gsl_sf_legendre_H3d_1_e(double lambda,double eta,double* result);
-double gsl_sf_legendre_H3d_1(double lambda,double eta);
-int gsl_sf_legendre_H3d_e(int l,double lambda,double eta,double* result);
-double gsl_sf_legendre_H3d(int l,double lambda,double eta);
-int gsl_sf_legendre_H3d_array(int lmax,double lambda,double eta,double* result_array);
diff --git a/lib/Numeric/GSL/Special/log.h b/lib/Numeric/GSL/Special/log.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/log.h
+++ /dev/null
@@ -1,9 +0,0 @@
-int gsl_sf_log_e(double x,double* result);
-double gsl_sf_log(double x);
-int gsl_sf_log_abs_e(double x,double* result);
-double gsl_sf_log_abs(double x);
-int gsl_sf_complex_log_e(double zr,double zi,double* lnr,double* theta);
-int gsl_sf_log_1plusx_e(double x,double* result);
-double gsl_sf_log_1plusx(double x);
-int gsl_sf_log_1plusx_mx_e(double x,double* result);
-double gsl_sf_log_1plusx_mx(double x);
diff --git a/lib/Numeric/GSL/Special/pow_int.h b/lib/Numeric/GSL/Special/pow_int.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/pow_int.h
+++ /dev/null
@@ -1,2 +0,0 @@
-int gsl_sf_pow_int_e(double x,int n,double* result);
-double gsl_sf_pow_int(double x,int n);
diff --git a/lib/Numeric/GSL/Special/psi.h b/lib/Numeric/GSL/Special/psi.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/psi.h
+++ /dev/null
@@ -1,13 +0,0 @@
-int gsl_sf_psi_int_e(int n,double* result);
-double gsl_sf_psi_int(int n);
-int gsl_sf_psi_e(double x,double* result);
-double gsl_sf_psi(double x);
-int gsl_sf_psi_1piy_e(double y,double* result);
-double gsl_sf_psi_1piy(double y);
-int gsl_sf_complex_psi_e(double x,double y,double* result_re,double* result_im);
-int gsl_sf_psi_1_int_e(int n,double* result);
-double gsl_sf_psi_1_int(int n);
-int gsl_sf_psi_1_e(double x,double* result);
-double gsl_sf_psi_1(double x);
-int gsl_sf_psi_n_e(int n,double x,double* result);
-double gsl_sf_psi_n(int n,double x);
diff --git a/lib/Numeric/GSL/Special/synchrotron.h b/lib/Numeric/GSL/Special/synchrotron.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/synchrotron.h
+++ /dev/null
@@ -1,4 +0,0 @@
-int gsl_sf_synchrotron_1_e(double x,double* result);
-double gsl_sf_synchrotron_1(double x);
-int gsl_sf_synchrotron_2_e(double x,double* result);
-double gsl_sf_synchrotron_2(double x);
diff --git a/lib/Numeric/GSL/Special/trig.h b/lib/Numeric/GSL/Special/trig.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/trig.h
+++ /dev/null
@@ -1,25 +0,0 @@
-int gsl_sf_sin_e(double x,double* result);
-double gsl_sf_sin(double x);
-int gsl_sf_cos_e(double x,double* result);
-double gsl_sf_cos(double x);
-int gsl_sf_hypot_e(double x,double y,double* result);
-double gsl_sf_hypot(double x,double y);
-int gsl_sf_complex_sin_e(double zr,double zi,double* szr,double* szi);
-int gsl_sf_complex_cos_e(double zr,double zi,double* czr,double* czi);
-int gsl_sf_complex_logsin_e(double zr,double zi,double* lszr,double* lszi);
-int gsl_sf_sinc_e(double x,double* result);
-double gsl_sf_sinc(double x);
-int gsl_sf_lnsinh_e(double x,double* result);
-double gsl_sf_lnsinh(double x);
-int gsl_sf_lncosh_e(double x,double* result);
-double gsl_sf_lncosh(double x);
-int gsl_sf_polar_to_rect(double r,double theta,double* x,double* y);
-int gsl_sf_rect_to_polar(double x,double y,double* r,double* theta);
-int gsl_sf_sin_err_e(double x,double dx,double* result);
-int gsl_sf_cos_err_e(double x,double dx,double* result);
-int gsl_sf_angle_restrict_symm_e(double* theta);
-double gsl_sf_angle_restrict_symm(double theta);
-int gsl_sf_angle_restrict_pos_e(double* theta);
-double gsl_sf_angle_restrict_pos(double theta);
-int gsl_sf_angle_restrict_symm_err_e(double theta,double* result);
-int gsl_sf_angle_restrict_pos_err_e(double theta,double* result);
diff --git a/lib/Numeric/GSL/Special/zeta.h b/lib/Numeric/GSL/Special/zeta.h
deleted file mode 100644
--- a/lib/Numeric/GSL/Special/zeta.h
+++ /dev/null
@@ -1,14 +0,0 @@
-int gsl_sf_zeta_int_e(int n,double* result);
-double gsl_sf_zeta_int(int n);
-int gsl_sf_zeta_e(double s,double* result);
-double gsl_sf_zeta(double s);
-int gsl_sf_zetam1_e(double s,double* result);
-double gsl_sf_zetam1(double s);
-int gsl_sf_zetam1_int_e(int s,double* result);
-double gsl_sf_zetam1_int(int s);
-int gsl_sf_hzeta_e(double s,double q,double* result);
-double gsl_sf_hzeta(double s,double q);
-int gsl_sf_eta_int_e(int n,double* result);
-double gsl_sf_eta_int(int n);
-int gsl_sf_eta_e(double s,double* result);
-double gsl_sf_eta(double s);
diff --git a/lib/Numeric/GSL/gsl-aux.c b/lib/Numeric/GSL/gsl-aux.c
--- a/lib/Numeric/GSL/gsl-aux.c
+++ b/lib/Numeric/GSL/gsl-aux.c
@@ -7,6 +7,7 @@
 #include <gsl/gsl_deriv.h>
 #include <gsl/gsl_poly.h>
 #include <gsl/gsl_multimin.h>
+#include <gsl/gsl_multiroots.h>
 #include <gsl/gsl_complex.h>
 #include <gsl/gsl_complex_math.h>
 #include <string.h>
@@ -288,6 +289,22 @@
 }
 
 
+int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr)
+{
+    gsl_function F;
+    F.function = f;
+    F.params = 0;
+
+    if(code==0) return gsl_deriv_central (&F, x, h, result, abserr);
+
+    if(code==1) return gsl_deriv_forward (&F, x, h, result, abserr);
+
+    if(code==2) return gsl_deriv_backward (&F, x, h, result, abserr);
+
+    return 0;
+}
+
+
 int integrate_qng(double f(double, void*), double a, double b, double prec,
                    double *result, double*error) {
     DEBUGMSG("integrate_qng");
@@ -352,7 +369,7 @@
 }
 
 // this version returns info about intermediate steps
-int minimize(double f(int, double*), double tolsize, int maxit, 
+int minimize(int method, double f(int, double*), double tolsize, int maxit, 
                  KRVEC(xi), KRVEC(sz), RMAT(sol)) {
     REQUIRES(xin==szn && solr == maxit && solc == 3+xin,BAD_SIZE);
     DEBUGMSG("minimizeList (nmsimplex)");
@@ -371,7 +388,11 @@
     // Starting point
     KDVVIEW(xi);
     // Minimizer nmsimplex, without derivatives
-    T = gsl_multimin_fminimizer_nmsimplex;
+    switch(method) {
+        case 0 : {T = gsl_multimin_fminimizer_nmsimplex; break; }
+        case 1 : {T = gsl_multimin_fminimizer_nmsimplex2; break; }
+        default: ERROR(BAD_CODE);
+    }
     s = gsl_multimin_fminimizer_alloc (T, my_func.n);
     gsl_multimin_fminimizer_set (s, &my_func, V(xi), V(sz));
     do {
@@ -402,7 +423,7 @@
 
 // working with the gradient
 
-typedef struct {double (*f)(int, double*); void (*df)(int, double*, double*);} Tfdf;
+typedef struct {double (*f)(int, double*); int (*df)(int, double*, int, double*);} Tfdf;
 
 double f_aux_min(const gsl_vector*x, void *pars) {
     Tfdf * fdf = ((Tfdf*) pars);
@@ -420,13 +441,13 @@
 void df_aux_min(const gsl_vector * x, void * pars, gsl_vector * g) {
     Tfdf * fdf = ((Tfdf*) pars);  
     double* p = (double*)calloc(x->size,sizeof(double));
-    double* q = (double*)calloc(x->size,sizeof(double));
+    double* q = (double*)calloc(g->size,sizeof(double));
     int k;
     for(k=0;k<x->size;k++) {
         p[k] = gsl_vector_get(x,k);
     }
 
-    fdf->df(x->size,p,q);
+    fdf->df(x->size,p,g->size,q);
 
     for(k=0;k<x->size;k++) {
         gsl_vector_set(g,k,q[k]);
@@ -440,10 +461,10 @@
     df_aux_min(x,pars,g);
 }
 
-// conjugate gradient
-int minimizeWithDeriv(int method, double f(int, double*), void df(int, double*, double*), 
-                      double initstep, double minimpar, double tolgrad, int maxit, 
-                      KRVEC(xi), RMAT(sol)) {
+
+int minimizeD(int method, double f(int, double*), int df(int, double*, int, double*),
+              double initstep, double minimpar, double tolgrad, int maxit, 
+              KRVEC(xi), RMAT(sol)) {
     REQUIRES(solr == maxit && solc == 2+xin,BAD_SIZE);
     DEBUGMSG("minimizeWithDeriv (conjugate_fr)");
     gsl_multimin_function_fdf my_func;
@@ -465,7 +486,10 @@
     // conjugate gradient fr
     switch(method) {
         case 0 : {T = gsl_multimin_fdfminimizer_conjugate_fr; break; }
-        case 1 : {T = gsl_multimin_fdfminimizer_vector_bfgs2; break; }
+        case 1 : {T = gsl_multimin_fdfminimizer_conjugate_pr; break; }
+        case 2 : {T = gsl_multimin_fdfminimizer_vector_bfgs; break; }
+        case 3 : {T = gsl_multimin_fdfminimizer_vector_bfgs2; break; }
+        case 4 : {T = gsl_multimin_fdfminimizer_steepest_descent; break; }
         default: ERROR(BAD_CODE);
     }
     s = gsl_multimin_fdfminimizer_alloc (T, my_func.n);
@@ -492,18 +516,197 @@
     OK
 }
 
+//---------------------------------------------------------------
 
-int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr)
-{
-    gsl_function F;
-    F.function = f;
-    F.params = 0;
+typedef void TrawfunV(int, double*, int, double*);
 
-    if(code==0) return gsl_deriv_central (&F, x, h, result, abserr);
+int only_f_aux_root(const gsl_vector*x, void *pars, gsl_vector*y) {
+    TrawfunV * f = (TrawfunV*) pars;
+    double* p = (double*)calloc(x->size,sizeof(double));
+    double* q = (double*)calloc(y->size,sizeof(double));
+    int k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }
+    f(x->size,p,y->size,q);
+    for(k=0;k<y->size;k++) {
+        gsl_vector_set(y,k,q[k]);
+    }
+    free(p);
+    free(q);
+    return 0; //hmmm
+}
 
-    if(code==1) return gsl_deriv_forward (&F, x, h, result, abserr);
+int root(int method, void f(int, double*, int, double*),
+         double epsabs, int maxit,
+         KRVEC(xi), RMAT(sol)) {
+    REQUIRES(solr == maxit && solc == 1+2*xin,BAD_SIZE);
+    DEBUGMSG("root_only_f");
+    gsl_multiroot_function my_func;
+    // extract function from pars
+    my_func.f = only_f_aux_root;
+    my_func.n = xin;
+    my_func.params = f;
+    size_t iter = 0;
+    int status;
+    const gsl_multiroot_fsolver_type *T;
+    gsl_multiroot_fsolver *s;
+    // Starting point
+    KDVVIEW(xi);
+    switch(method) {
+        case 0 : {T = gsl_multiroot_fsolver_hybrids;; break; }
+        case 1 : {T = gsl_multiroot_fsolver_hybrid; break; }
+        case 2 : {T = gsl_multiroot_fsolver_dnewton; break; }
+        case 3 : {T = gsl_multiroot_fsolver_broyden; break; }
+        default: ERROR(BAD_CODE);
+    }
+    s = gsl_multiroot_fsolver_alloc (T, my_func.n);
+    gsl_multiroot_fsolver_set (s, &my_func, V(xi));
 
-    if(code==2) return gsl_deriv_backward (&F, x, h, result, abserr);
+    do {
+           status = gsl_multiroot_fsolver_iterate (s);
 
+           solp[iter*solc+0] = iter;
+
+           int k;
+           for(k=0;k<xin;k++) {
+               solp[iter*solc+k+1] = gsl_vector_get(s->x,k);
+           }
+           for(k=xin;k<2*xin;k++) {
+               solp[iter*solc+k+1] = gsl_vector_get(s->f,k-xin);
+           }
+
+           iter++;
+           if (status)   /* check if solver is stuck */
+             break;
+
+           status =
+             gsl_multiroot_test_residual (s->f, epsabs);
+        }
+        while (status == GSL_CONTINUE && iter < maxit);
+
+    int i,j;
+    for (i=iter; i<solr; i++) {
+        solp[i*solc+0] = iter;
+        for(j=1;j<solc;j++) {
+            solp[i*solc+j]=0.;
+        }
+    }
+    gsl_multiroot_fsolver_free(s);
+    OK
+}
+
+// working with the jacobian
+
+typedef struct {int (*f)(int, double*, int, double *); int (*jf)(int, double*, int, int, double*);} Tfjf;
+
+int f_aux_root(const gsl_vector*x, void *pars, gsl_vector*y) {
+    Tfjf * fjf = ((Tfjf*) pars);
+    double* p = (double*)calloc(x->size,sizeof(double));
+    double* q = (double*)calloc(y->size,sizeof(double));
+    int k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }
+    (fjf->f)(x->size,p,y->size,q);
+    for(k=0;k<y->size;k++) {
+        gsl_vector_set(y,k,q[k]);
+    }
+    free(p);
+    free(q);
     return 0;
+}
+
+int jf_aux_root(const gsl_vector * x, void * pars, gsl_matrix * jac) {
+    Tfjf * fjf = ((Tfjf*) pars);
+    double* p = (double*)calloc(x->size,sizeof(double));
+    double* q = (double*)calloc((x->size)*(x->size),sizeof(double));
+    int i,j,k;
+    for(k=0;k<x->size;k++) {
+        p[k] = gsl_vector_get(x,k);
+    }
+
+    (fjf->jf)(x->size,p,x->size,x->size,q);
+
+    k=0;
+    for(i=0;i<x->size;i++) {
+        for(j=0;j<x->size;j++){
+            gsl_matrix_set(jac,i,j,q[k++]);
+        }
+    }
+    free(p);
+    free(q);
+    return 0;
+}
+
+int fjf_aux_root(const gsl_vector * x, void * pars, gsl_vector * f, gsl_matrix * g) {
+    f_aux_root(x,pars,f);
+    jf_aux_root(x,pars,g);
+    return 0;
+}
+
+int rootj(int method, int f(int, double*, int, double*),
+                      int jac(int, double*, int, int, double*),
+         double epsabs, int maxit,
+         KRVEC(xi), RMAT(sol)) {
+    REQUIRES(solr == maxit && solc == 1+2*xin,BAD_SIZE);
+    DEBUGMSG("root_fjf");
+    gsl_multiroot_function_fdf my_func;
+    // extract function from pars
+    my_func.f = f_aux_root;
+    my_func.df = jf_aux_root;
+    my_func.fdf = fjf_aux_root;
+    my_func.n = xin;
+    Tfjf stfjf;
+    stfjf.f = f;
+    stfjf.jf = jac;
+    my_func.params = &stfjf;
+    size_t iter = 0;
+    int status;
+    const gsl_multiroot_fdfsolver_type *T;
+    gsl_multiroot_fdfsolver *s;
+    // Starting point
+    KDVVIEW(xi);
+    switch(method) {
+        case 0 : {T = gsl_multiroot_fdfsolver_hybridsj;; break; }
+        case 1 : {T = gsl_multiroot_fdfsolver_hybridj; break; }
+        case 2 : {T = gsl_multiroot_fdfsolver_newton; break; }
+        case 3 : {T = gsl_multiroot_fdfsolver_gnewton; break; }
+        default: ERROR(BAD_CODE);
+    }
+    s = gsl_multiroot_fdfsolver_alloc (T, my_func.n);
+
+    gsl_multiroot_fdfsolver_set (s, &my_func, V(xi));
+
+    do {
+           status = gsl_multiroot_fdfsolver_iterate (s);
+
+           solp[iter*solc+0] = iter;
+
+           int k;
+           for(k=0;k<xin;k++) {
+               solp[iter*solc+k+1] = gsl_vector_get(s->x,k);
+           }
+           for(k=xin;k<2*xin;k++) {
+               solp[iter*solc+k+1] = gsl_vector_get(s->f,k-xin);
+           }
+
+           iter++;
+           if (status)   /* check if solver is stuck */
+             break;
+
+           status =
+             gsl_multiroot_test_residual (s->f, epsabs);
+        }
+        while (status == GSL_CONTINUE && iter < maxit);
+
+    int i,j;
+    for (i=iter; i<solr; i++) {
+        solp[i*solc+0] = iter;
+        for(j=1;j<solc;j++) {
+            solp[i*solc+j]=0.;
+        }
+    }
+    gsl_multiroot_fdfsolver_free(s);
+    OK
 }
diff --git a/lib/Numeric/GSL/gsl-aux.h b/lib/Numeric/GSL/gsl-aux.h
--- a/lib/Numeric/GSL/gsl-aux.h
+++ b/lib/Numeric/GSL/gsl-aux.h
@@ -28,6 +28,8 @@
 
 int fft(int code, KCVEC(a), CVEC(b));
 
+int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr);
+
 int integrate_qng(double f(double, void*), double a, double b, double prec,
                    double *result, double*error);
 
@@ -36,11 +38,3 @@
 
 int polySolve(KRVEC(a), CVEC(z));
 
-int minimize(double f(int, double*), double tolsize, int maxit, 
-                 KRVEC(xi), KRVEC(sz), RMAT(sol));
-
-int minimizeWithDeriv(int method, double f(int, double*), void df(int, double*, double*),
-                      double initstep, double minimpar, double tolgrad, int maxit, 
-                      KRVEC(xi), RMAT(sol));
-
-int deriv(int code, double f(double, void*), double x, double h, double * result, double * abserr);
diff --git a/lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c b/lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c
--- a/lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c
+++ b/lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c
@@ -435,9 +435,6 @@
 //////////////////// least squares complex linear system ////////////
 
 int linearSolveLSC_l(KCMAT(a),KCMAT(b),CMAT(x)) {
-    #ifdef _WIN32
-    return NOSPRTD;
-    #else
     integer m = ar;
     integer n = ac;
     integer nrhs = bc;
@@ -478,7 +475,6 @@
     free(work);
     free(AC);
     OK
-    #endif
 }
 
 //////////////////// least squares real linear system using SVD ////////////
@@ -543,9 +539,6 @@
     integer *info);
 
 int linearSolveSVDC_l(double rcond, KCMAT(a),KCMAT(b),CMAT(x)) {
-    #ifdef _WIN32
-    return NOSPRTD;
-    #else
     integer m = ar;
     integer n = ac;
     integer nrhs = bc;
@@ -596,7 +589,6 @@
     free(S);
     free(AC);
     OK
-    #endif
 }
 
 //////////////////// Cholesky factorization /////////////////////////
@@ -749,9 +741,6 @@
 }
 
 int schur_l_C(KCMAT(a), CMAT(u), CMAT(s)) {
-    #ifdef _WIN32
-    return NOSPRTD;
-    #else
     integer m = ar;
     integer n = ac;
     REQUIRES(m>=1 && n==m && ur==n && uc==n && sr==n && sc==n, BAD_SIZE);
@@ -776,7 +765,6 @@
     free(BWORK);
     free(WORK);
     OK
-    #endif
 }
 
 //////////////////// LU factorization /////////////////////////
diff --git a/lib/Numeric/LinearAlgebra/Tests.hs b/lib/Numeric/LinearAlgebra/Tests.hs
--- a/lib/Numeric/LinearAlgebra/Tests.hs
+++ b/lib/Numeric/LinearAlgebra/Tests.hs
@@ -36,6 +36,8 @@
 
 utest str b = TestCase $ assertBool str b
 
+a ~~ b = fromList a |~| fromList b
+
 feye n = flipud (ident n) :: Matrix Double
 
 detTest1 = det m == 26
@@ -107,17 +109,27 @@
 
 ---------------------------------------------------------------------
 
-minimizationTest = TestList [ utest "minimization conj grad" (minim1 f df [5,7] ~~ [1,2])
-                            , utest "minimization bg2"       (minim2 f df [5,7] ~~ [1,2])
+minimizationTest = TestList [ utest "minimization conjugatefr" (minim1 f df [5,7] ~~ [1,2])
+                            , utest "minimization nmsimplex2"       (minim2 f [5,7] == 24)
                             ]
     where f [x,y] = 10*(x-1)^2 + 20*(y-2)^2 + 30
           df [x,y] = [20*(x-1), 40*(y-2)]
-          a ~~ b = fromList a |~| fromList b
-          minim1 g dg ini = fst $ minimizeConjugateGradient 1E-2 1E-4 1E-3 30 g dg ini
-          minim2 g dg ini = fst $ minimizeVectorBFGS2 1E-2 1E-2 1E-3 30 g dg ini
+          minim1 g dg ini = fst $ minimizeD ConjugateFR 1E-3 30 1E-2 1E-4 g dg ini
+          minim2 g ini = rows $ snd $ minimize NMSimplex2 1E-2 30 [1,1] g ini
 
 ---------------------------------------------------------------------
 
+rootFindingTest = TestList [ utest "root Hybrids" (fst sol1 ~~ [1,1])
+                           , utest "root Newton"  (rows (snd sol2) == 2)
+                           ]
+    where sol1 = root Hybrids 1E-7 30 (rosenbrock 1 10) [-10,-5]
+          sol2 = rootJ Newton 1E-7 30 (rosenbrock 1 10) (jacobian 1 10) [-10,-5]
+          rosenbrock a b [x,y] = [ a*(1-x), b*(y-x^2) ]
+          jacobian a b [x,_y] = [ [-a    , 0]
+                                , [-2*b*x, b] ]
+
+---------------------------------------------------------------------
+
 rot :: Double -> Matrix Double
 rot a = (3><3) [ c,0,s
                , 0,1,0
@@ -152,9 +164,7 @@
     test (linearSolveProp (luSolve.luPacked) . cSqWC)
     putStrLn "------ pinv (linearSolveSVD)"
     test (pinvProp  . rM)
-    if os == "mingw32"
-        then putStrLn "complex pinvTest skipped in this OS"
-        else test (pinvProp  . cM)
+    test (pinvProp  . cM)
     putStrLn "------ det"
     test (detProp   . rSqWC)
     test (detProp   . cSqWC)
@@ -179,9 +189,7 @@
     test (hessProp   . cSq)
     putStrLn "------ schur"
     test (schurProp2 . rSq)
-    if os == "mingw32"
-        then putStrLn "complex schur skipped in this OS"
-        else test (schurProp1 . cSq)
+    test (schurProp1 . cSq)
     putStrLn "------ chol"
     test (cholProp   . rPosDef)
     test (cholProp   . cPosDef)
@@ -217,6 +225,7 @@
         , utest "integrate" (abs (volSphere 2.5 - 4/3*pi*2.5^3) < 1E-8)
         , utest "polySolve" (polySolveProp [1,2,3,4])
         , minimizationTest
+        , rootFindingTest
         ]
     return ()