hmatrix 0.8.3.1 → 0.9.3.0

raw patch · 79 files changed

+1138/−4057 lines, 79 filesdep +vectordep −haskell98dep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: vector

Dependencies removed: haskell98

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• CHANGES +22/−0
• INSTALL +15/−35
• README +0/−112
• THANKS +74/−0
• examples/devel/ej1/functions.c +35/−0
• examples/devel/ej1/wrappers.hs +44/−0
• examples/devel/ej2/functions.c +24/−0
• examples/devel/ej2/wrappers.hs +32/−0
• examples/devel/functions.c +0/−34
• examples/devel/wrappers.hs +0/−45
• examples/error.hs +1/−0
• examples/parallel.hs +2/−17
• examples/plot.hs +1/−1
• examples/vector.hs +32/−0
• hmatrix.cabal +44/−48
• lib/Data/Packed.hs +3/−51
• lib/Data/Packed/Convert.hs +0/−101
• lib/Data/Packed/Development.hs +5/−2
• lib/Data/Packed/Internal/Common.hs +34/−6
• lib/Data/Packed/Internal/Matrix.hs +20/−20
• lib/Data/Packed/Internal/Signatures.hs +1/−1
• lib/Data/Packed/Internal/Vector.hs +100/−33
• lib/Data/Packed/Matrix.hs +72/−17
• lib/Data/Packed/Random.hs +4/−8
• lib/Data/Packed/ST.hs +2/−2
• lib/Data/Packed/Vector.hs +1/−1
• lib/Graphics/Plot.hs +18/−2
• lib/Numeric/GSL.hs +7/−5
• lib/Numeric/GSL/Fitting.hs +175/−0
• lib/Numeric/GSL/Fourier.hs +1/−1
• lib/Numeric/GSL/Internal.hs +4/−4
• lib/Numeric/GSL/Minimization.hs +2/−2
• lib/Numeric/GSL/ODE.hs +2/−4
• lib/Numeric/GSL/Polynomials.hs +1/−1
• lib/Numeric/GSL/Root.hs +2/−2
• lib/Numeric/GSL/Special.hs +0/−76
• lib/Numeric/GSL/Special/Airy.hs +0/−141
• lib/Numeric/GSL/Special/Bessel.hs +0/−508
• lib/Numeric/GSL/Special/Clausen.hs +0/−30
• lib/Numeric/GSL/Special/Coulomb.hs +0/−69
• lib/Numeric/GSL/Special/Coupling.hs +0/−68
• lib/Numeric/GSL/Special/Dawson.hs +0/−30
• lib/Numeric/GSL/Special/Debye.hs +0/−80
• lib/Numeric/GSL/Special/Dilog.hs +0/−42
• lib/Numeric/GSL/Special/Elementary.hs +0/−35
• lib/Numeric/GSL/Special/Ellint.hs +0/−140
• lib/Numeric/GSL/Special/Elljac.hs +0/−38
• lib/Numeric/GSL/Special/Erf.hs +0/−80
• lib/Numeric/GSL/Special/Exp.hs +0/−115
• lib/Numeric/GSL/Special/Expint.hs +0/−160
• lib/Numeric/GSL/Special/Fermi_dirac.hs +0/−110
• lib/Numeric/GSL/Special/Gamma.hs +0/−236
• lib/Numeric/GSL/Special/Gegenbauer.hs +0/−64
• lib/Numeric/GSL/Special/Hyperg.hs +0/−130
• lib/Numeric/GSL/Special/Internal.hsc +0/−102
• lib/Numeric/GSL/Special/Laguerre.hs +0/−60
• lib/Numeric/GSL/Special/Lambert.hs +0/−40
• lib/Numeric/GSL/Special/Legendre.hs +0/−233
• lib/Numeric/GSL/Special/Log.hs +0/−64
• lib/Numeric/GSL/Special/Pow_int.hs +0/−30
• lib/Numeric/GSL/Special/Psi.hs +0/−84
• lib/Numeric/GSL/Special/Synchrotron.hs +0/−40
• lib/Numeric/GSL/Special/Transport.hs +0/−60
• lib/Numeric/GSL/Special/Trig.hs +0/−138
• lib/Numeric/GSL/Special/Zeta.hs +0/−90
• lib/Numeric/GSL/Special/auto.hs +0/−244
• lib/Numeric/GSL/Special/autoall.sh +0/−45
• lib/Numeric/GSL/Special/replace.hs +0/−14
• lib/Numeric/GSL/Vector.hs +1/−1
• lib/Numeric/GSL/gsl-aux.c +85/−13
• lib/Numeric/LinearAlgebra.hs +1/−8
• lib/Numeric/LinearAlgebra/Algorithms.hs +52/−32
• lib/Numeric/LinearAlgebra/Instances.hs +29/−10
• lib/Numeric/LinearAlgebra/Interface.hs +15/−12
• lib/Numeric/LinearAlgebra/LAPACK.hs +33/−13
• lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c +36/−0
• lib/Numeric/LinearAlgebra/Linear.hs +4/−2
• lib/Numeric/LinearAlgebra/Tests.hs +91/−12
• lib/Numeric/LinearAlgebra/Tests/Properties.hs +11/−3

@@ -1,3 +1,25 @@+0.9.3.0+=======++- flag -fvector to optionally use Data.Vector.Storable.Vector+  without any conversion.++- Simpler module structure.++- toBlocks, toBlocksEvery++- cholSolve, mbCholSH++- GSL Nonlinear Least-Squares fitting using Levenberg-Marquardt.++- GSL special functions moved to separate package hmatrix-special.++- Added offset of Vector, allowing fast, noncopy subVector (slice).+  Vector is now identical to Roman Leshchinskiy's Data.Vector.Storable.Vector,+  so we can convert from/to them in O(1).++- Removed Data.Packed.Convert, see examples/vector.hs+ 0.8.3.0 ======= 

@@ -1,56 +1,36 @@------------------------------------------- A simple scientific library for Haskell------------------------------------------- INSTALLATION -Recommended method (ok in Ubuntu/Debian systems):+Recommended method (tested on Ubuntu/Debian systems):     $ sudo apt-get install libgsl0-dev liblapack-dev     $ cabal install hmatrix  Detailed installation instructions:-    http://www.hmatrix.googlepages.com/installation--INSTALLATION ON WINDOWS ------------------------------------------1) Install a recent ghc (e.g. ghc-6.10.3)--2) Install cabal-install. A binary for windows can be obtained from:+    http://code.haskell.org/hmatrix/install.html -   http://www.haskell.org/cabal/release/cabal-install-0.6.2/cabal.exe+INSTALLATION ON WINDOWS -   Put it somewhere in the path, for instance in c:\ghc\ghc-6.10.3\bin+1) Install the Haskell Platform (tested on 2009.2.0.2). -3) Download and uncompress in a temporary location the following file:+2) Download and unzip the following file into a stable folder %GSL%     http://code.haskell.org/hmatrix/gsl-lapack-windows.zip -   It contains a folder, gsl, and four DLL's.--4) Move the gsl folder to C:\ghc\ghc-6.10.3\include--5) Move the four DLL's to C:\ghc\ghc-6.10.3\bin--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:+3.a) In a msys shell installation should be fully automatic: -     line 17:      build-type:         Custom-     change to:    build-type:         Simple+   $ cabal install hmatrix --extra-lib-dir=${GSL} --extra-include-dir=${GSL} -     and at the end of the file add:+3.b) Alternatively, in a normal windows cmd: -        extra-libraries: libgsl-0 blas lapack-        extra-lib-dirs: c:\ghc\ghc-6.10.3\bin+    > cabal unpack hmatrix -8) Open a terminal, cd to the hmatrix folder, and run+    Edit hmatrix.cabal, in line 18 change build-type to "Simple", and then -   > cabal install+    > cabal install --extra-lib-dir=%GSL% --extra-include-dir=%GSL% -9) If everything is ok we can run the tests:+4) If everything is ok we can run the tests: -   > runhaskell examples\tests.hs+   > ghci+   Prelude> Numeric.LinearAlgebra.Tests.runTests 20  NOTE: The examples using graphics do not yet work in windows.+

@@ -1,112 +0,0 @@------------------------------------------- A simple scientific library for Haskell--------------------------------------------INSTALLATION--See the INSTALL file.--TESTS -----------------------------------------------$ ghci-Prelude> Numeric.LinearAlgebra.Tests.runTests 20--EXAMPLES --------------------------------------------------------$ ghci-Prelude> :m + Numeric.GSL-Prelude Numeric.GSL> let quad = integrateQNG 1E-10-Prelude Numeric.GSL> quad (^2) 0 1-(0.3333333333333333,3.700743415417188e-15)--Prelude Numeric.GSL> :m + Numeric.LinearAlgebra-Prelude Numeric.LinearAlgebra> let m = (2><3)[1,2,3,4,5,6::Double]-Prelude Numeric.LinearAlgebra> let (u,d,v) = full svd m-Prelude Numeric.LinearAlgebra> d-(2><3)- [ 9.508032000695724,                0.0, 0.0- ,               0.0, 0.7728696356734838, 0.0 ]-Prelude Numeric.LinearAlgebra> u <> d <> trans v-(2><3)- [ 1.0000000000000004,               2.0, 3.0- , 3.9999999999999996, 5.000000000000001, 6.0 ]-Prelude Numeric.GSL> :q-Leaving GHCi.--A number of illustrative programs are included in the examples folder.--KNOWN PROBLEMS / BUGS ---------------------------------- On 64-bit machines the example "minimize.hs", when run from ghci,-  produces a segmentation fault. It happens in the call to-  gsl_multimin_fdfminimizer_alloc, inside the C wrapper.-  If the program is called by runhaskell, it just terminates-  prematurely, producing no results. Curiously, in compiled mode the-  program seems to work perfectly well.--- On Ubuntu 6.06 LTS (Dapper) atlas3-sse2-dev (3.6.0-20)-  produced segmentation faults when working with big matrices-  on compiled programs.--ACKNOWLEDGEMENTS -------------------------------------------------------I thank Don Stewart, Henning Thielemann, Bulat Ziganshin, Heinrich Apfelmus,-and all the people in the Haskell mailing lists for their help.--- Nico Mahlo discovered a bug in the eigendecomposition wrapper.--- Frederik Eaton discovered a bug in the design of the wrappers.--- Eric Kidd has created a wiki page explaining the installation on MacOS X:-  http://www.haskell.org/haskellwiki/GSLHaskell_on_MacOS_X--- Fawzi Mohamed discovered a portability bug in the lapack wrappers.--- Pedro E. López de Teruel fixed the interface to lapack.--- Antti Siira discovered a bug in the plotting functions.--- Paulo Tanimoto helped to fix the configuration of the required libraries.-  He also discovered the segfault of minimize.hs in ghci.--- Xiao-Yong Jin reported a bug on x86_64 caused by the assumptions in f2c.h,-  which are wrong for this architecture.--- Jason Schroeder reported an error in the documentation.--- Bulat Ziganshin gave invaluable help for the ST monad interface to-  in-place modifications.--- Don Stewart fixed the implementation of the internal data structures-  to achieve excellent, C-like performance in Haskell functions which-  explicitly work with the elements of vectors and matrices.--- Dylan Alex Simon improved the numeric instances to allow optimized-  implementations of signum and abs on Vectors.--- Pedro E. López de Teruel discovered the need of asm("finit") to-  avoid the wrong NaNs produced by foreign functions.--- Reiner Pope added support for luSolve, based on (d|z)getrs.--- Simon Beaumont reported the need of QuickCheck<2 and the invalid-  asm("finit") on ppc. He also contributed the configuration options-  for the accelerate framework on OS X.--- 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).--- Chris Waterson improved the configure.hs program for OS/X.--- Erik de Castro Lopo added buildVector and buildMatrix, which take a-  size parameter(s) and a function that maps vector/matrix indices-  to the values at that position.--- Jean-Francois Tremblay discovered an error in the tutorial.--- Heinrich Apfelmus fixed hmatrix.cabal for OS/X.

@@ -0,0 +1,74 @@+I thank Don Stewart, Henning Thielemann, Bulat Ziganshin, Heinrich Apfelmus,+and all the people in the Haskell mailing lists for their help.++- Nico Mahlo discovered a bug in the eigendecomposition wrapper.++- Frederik Eaton discovered a bug in the design of the wrappers.++- Eric Kidd has created a wiki page explaining the installation on MacOS X:+  http://www.haskell.org/haskellwiki/GSLHaskell_on_MacOS_X++- Fawzi Mohamed discovered a portability bug in the lapack wrappers.++- Pedro E. López de Teruel fixed the interface to lapack.++- Antti Siira discovered a bug in the plotting functions.++- Paulo Tanimoto helped to fix the configuration of the required libraries.+  He also discovered the segfault of minimize.hs in ghci.++- Xiao-Yong Jin reported a bug on x86_64 caused by the assumptions in f2c.h,+  which are wrong for this architecture.++- Jason Schroeder reported an error in the documentation.++- Bulat Ziganshin gave invaluable help for the ST monad interface to+  in-place modifications.++- Don Stewart fixed the implementation of the internal data structures+  to achieve excellent, C-like performance in Haskell functions which+  explicitly work with the elements of vectors and matrices.++- Dylan Alex Simon improved the numeric instances to allow optimized+  implementations of signum and abs on Vectors.++- Pedro E. López de Teruel discovered the need of asm("finit") to+  avoid the wrong NaNs produced by foreign functions.++- Reiner Pope added support for luSolve, based on (d|z)getrs.++- Simon Beaumont reported the need of QuickCheck<2 and the invalid+  asm("finit") on ppc. He also contributed the configuration options+  for the accelerate framework on OS X.++- 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).++- Chris Waterson improved the configure.hs program for OS/X.++- Erik de Castro Lopo added buildVector and buildMatrix, which take a+  size parameter(s) and a function that maps vector/matrix indices+  to the values at that position.++- Jean-Francois Tremblay discovered an error in the tutorial.++- Gilberto Camara contributed improved blas and lapack dlls for Windows.++- Heinrich Apfelmus fixed hmatrix.cabal for OS/X. He also tested the package+  on PPC discovering a problem in zgesdd.++- Felipe Lessa tested the performance of GSL special function bindings+  and contributed the cabal flag "safe-cheap".++- Ozgur Akgun suggested better symbols for the Bound constructors in the+  Linear Programming package.++- Tim Sears reported the zgesdd problem also in intel mac.++- Max Suica simplified the installation on Windows and improved the instructions.+

@@ -0,0 +1,35 @@+/* assuming row order */++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,row,col) (M##p[(row)*M##c + (col)])++/*-----------------------------------------------------*/++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(DMAT(m),DVEC(y),DMAT(z)) {+    int i,j;+    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;+}

@@ -0,0 +1,44 @@+{-# 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++-----------------------------------------------------+-- forcing row order++foreign import ccall "c_diag"+    cDiag :: 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 RowMajor r c+    app3 cDiag mat (cmat m) vec y mat z "cDiag"+    return (y,z)+  where r = rows m+        c = cols m

@@ -0,0 +1,24 @@+/*  general element order   */++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_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;+}

@@ -0,0 +1,32 @@+{-# 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 $ myDiag $ (3><5) [1..]++-----------------------------------------------------+-- arbitrary data order++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

@@ -1,34 +0,0 @@-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;-}

@@ -1,45 +0,0 @@-{-# 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

@@ -1,4 +1,5 @@ import Numeric.GSL+import Numeric.GSL.Special import Numeric.LinearAlgebra import Prelude hiding (catch) import Control.Exception

@@ -6,19 +6,16 @@ import System.Time  inParallel = parMap rwhnf id---  rdeepseq (or older rnf) not needed in this case + -- matrix product decomposed into p parallel subtasks parMul p x y = fromBlocks [ inParallel ( map (x <>) ys ) ]-    where ys = splitColumns p y---- x <||> y = fromColumns . inParallel . map (x <>) . toColumns $ y+    where [ys] = toBlocksEvery (rows y) (cols y `div` 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 $ 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@@ -28,15 +25,3 @@     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)

@@ -1,6 +1,6 @@ import Numeric.LinearAlgebra import Graphics.Plot-import Numeric.GSL(erf_Z, erf)+import Numeric.GSL.Special(erf_Z, erf)  sombrero n = f x y where      (x,y) = meshdom range range

@@ -0,0 +1,32 @@+-- conversion to/from Data.Vector.Storable+-- from Roman Leshchinskiy "vector" package+--+-- In the future Data.Packed.Vector will be replaced by Data.Vector.Storable++-------------------------------------------++import Numeric.LinearAlgebra as H+import Data.Packed.Development(unsafeFromForeignPtr, unsafeToForeignPtr)+import Foreign.Storable+import qualified Data.Vector.Storable as V++fromVector :: Storable t => V.Vector t -> H.Vector t+fromVector v = unsafeFromForeignPtr p i n where+    (p,i,n) = V.unsafeToForeignPtr v++toVector :: H.Vector t -> V.Vector t+toVector v = V.unsafeFromForeignPtr p i n where+    (p,i,n) = unsafeToForeignPtr v++-------------------------------------------++v = V.slice 5 10 (V.fromList [1 .. 10::Double] V.++ V.replicate 10 7)++w = subVector 2 3 (linspace 10 (0,2))++main = do+    print v+    print $ fromVector v+    print w+    print $ toVector w+

@@ -1,5 +1,5 @@ Name:               hmatrix-Version:            0.8.3.1+Version:            0.9.3.0 License:            GPL License-file:       LICENSE Author:             Alberto Ruiz@@ -10,6 +10,8 @@ Description:        Purely functional interface to basic linear algebra                     and other numerical computations, internally implemented using                     GSL, BLAS and LAPACK.+                    .+                    See also hmatrix-special and hmatrix-glpk. Category:           Math tested-with:        GHC ==6.10.4, GHC ==6.12.1 @@ -18,7 +20,7 @@ build-type:         Custom  extra-source-files: lib/Numeric/LinearAlgebra/Tests/quickCheckCompat.h-                    configure configure.hs README INSTALL CHANGES+                    configure configure.hs THANKS INSTALL CHANGES extra-tmp-files:    hmatrix.buildinfo  extra-source-files: examples/tests.hs@@ -37,17 +39,24 @@                     examples/plot.hs                     examples/inplace.hs                     examples/error.hs-                    examples/devel/wrappers.hs-                    examples/devel/functions.c+                    examples/devel/ej1/wrappers.hs+                    examples/devel/ej1/functions.c+                    examples/devel/ej2/wrappers.hs+                    examples/devel/ej2/functions.c                     examples/Real.hs+                    examples/vector.hs  extra-source-files: lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.h,                     lib/Numeric/LinearAlgebra/LAPACK/clapack.h -extra-source-files: lib/Numeric/GSL/Special/auto.hs,-                    lib/Numeric/GSL/Special/autoall.sh,-                    lib/Numeric/GSL/Special/replace.hs+flag tests+    description:    Build tests+    default:        True +flag dd+    description:    svd = zgesdd+    default:        True+ flag mkl     description:    Link with Intel's MKL optimized libraries.     default:        False@@ -56,12 +65,14 @@     description:    Compile the library with bound checking disabled.     default:        False +flag vector+    description:    Use Data.Vector.Storable type from "vector" package.+    default:        False+ library -    Build-Depends:      base >= 3 && < 5,+    Build-Depends:      base >= 4 && < 5,                         array,-                        haskell98,-                        QuickCheck, HUnit,                         storable-complex,                         process @@ -78,47 +89,16 @@                         Numeric.GSL.Polynomials,                         Numeric.GSL.Minimization,                         Numeric.GSL.Root,+                        Numeric.GSL.Fitting,                         Numeric.GSL.ODE,                         Numeric.GSL.Vector,-                        Numeric.GSL.Special,-                        Numeric.GSL.Special.Gamma,-                        Numeric.GSL.Special.Erf,-                        Numeric.GSL.Special.Airy,-                        Numeric.GSL.Special.Exp,-                        Numeric.GSL.Special.Bessel,-                        Numeric.GSL.Special.Clausen,-                        Numeric.GSL.Special.Coulomb,-                        Numeric.GSL.Special.Coupling,-                        Numeric.GSL.Special.Dawson,-                        Numeric.GSL.Special.Debye,-                        Numeric.GSL.Special.Dilog,-                        Numeric.GSL.Special.Elementary,-                        Numeric.GSL.Special.Ellint,-                        Numeric.GSL.Special.Elljac,-                        Numeric.GSL.Special.Expint,-                        Numeric.GSL.Special.Fermi_dirac,-                        Numeric.GSL.Special.Gegenbauer,-                        Numeric.GSL.Special.Hyperg,-                        Numeric.GSL.Special.Laguerre,-                        Numeric.GSL.Special.Lambert,-                        Numeric.GSL.Special.Legendre,-                        Numeric.GSL.Special.Log,-                        Numeric.GSL.Special.Pow_int,-                        Numeric.GSL.Special.Psi,-                        Numeric.GSL.Special.Synchrotron,-                        Numeric.GSL.Special.Transport,-                        Numeric.GSL.Special.Trig,-                        Numeric.GSL.Special.Zeta,                         Numeric.GSL,                         Numeric.LinearAlgebra,                         Numeric.LinearAlgebra.LAPACK,-                        Numeric.LinearAlgebra.Linear,-                        Numeric.LinearAlgebra.Instances,                         Numeric.LinearAlgebra.Interface,                         Numeric.LinearAlgebra.Algorithms,                         Graphics.Plot,-                        Numeric.LinearAlgebra.Tests,-                        Data.Packed.Convert,+                     -- Data.Packed.Convert,                         Data.Packed.ST,                         Data.Packed.Development,                         Data.Packed.Random@@ -127,15 +107,25 @@                         Data.Packed.Internal.Signatures,                         Data.Packed.Internal.Vector,                         Data.Packed.Internal.Matrix,-                        Numeric.GSL.Internal,-                        Numeric.GSL.Special.Internal,-                        Numeric.LinearAlgebra.Tests.Instances,-                        Numeric.LinearAlgebra.Tests.Properties+                        Numeric.LinearAlgebra.Linear,+                        Numeric.LinearAlgebra.Instances,+                        Numeric.GSL.Internal+     C-sources:          lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.c,                         lib/Numeric/GSL/gsl-aux.c -    ghc-prof-options:   -auto+    if flag(vector)+       Build-Depends:   vector+       cpp-options:     -DVECTOR +    if flag(tests)+       Build-Depends:   QuickCheck, HUnit+       exposed-modules: Numeric.LinearAlgebra.Tests+       other-modules:   Numeric.LinearAlgebra.Tests.Instances,+                        Numeric.LinearAlgebra.Tests.Properties++ -- ghc-prof-options:   -auto+     ghc-options:        -Wall -fno-warn-missing-signatures                               -fno-warn-orphans                               -fno-warn-unused-binds@@ -143,6 +133,9 @@     if flag(unsafe)         cpp-options: -DUNSAFE +    if !flag(dd)+        cpp-options: -DNOZGESDD+     if impl(ghc < 6.10.2)         cpp-options: -DFINIT @@ -157,6 +150,9 @@         include-dirs: /opt/local/include         extra-libraries: gsl         frameworks: Accelerate++    if os(windows)+        extra-libraries: gsl-0 blas lapack  -- The extra-libraries required for GSL and LAPACK -- should now be automatically detected by configure(.hs)

@@ -1,4 +1,3 @@-{-# OPTIONS_GHC -fglasgow-exts #-} ----------------------------------------------------------------------------- {- | Module      :  Data.Packed@@ -17,59 +16,12 @@ module Data.Packed (     module Data.Packed.Vector,     module Data.Packed.Matrix,-    module Data.Complex,-    Container(..)+    module Data.Packed.Random,+    module Data.Complex ) where  import Data.Packed.Vector import Data.Packed.Matrix+import Data.Packed.Random import Data.Complex-import Data.Packed.Internal(fromComplex,toComplex,conj) --- | conversion utilities-class (Element e) => Container c e where-    toComplex   :: RealFloat e => (c e, c e) -> c (Complex e)-    fromComplex :: RealFloat e => c (Complex e) -> (c e, c e)-    comp        :: RealFloat e => c e -> c (Complex e)-    conj        :: RealFloat e => c (Complex e) -> c (Complex e)-    real        :: c Double -> c e-    complex     :: c e -> c (Complex Double)--instance Container Vector Double where-    toComplex = Data.Packed.Internal.toComplex-    fromComplex = Data.Packed.Internal.fromComplex-    comp = internalcomp-    conj = Data.Packed.Internal.conj-    real = id-    complex = Data.Packed.comp--instance Container Vector (Complex Double) where-    toComplex = undefined -- can't match-    fromComplex = undefined-    comp = undefined-    conj = undefined-    real = Data.Packed.comp-    complex = id--instance Container Matrix Double where-    toComplex = uncurry $ liftMatrix2 $ curry Data.Packed.toComplex-    fromComplex z = (reshape c r, reshape c i)-        where (r,i) = Data.Packed.fromComplex (flatten z)-              c = cols z-    comp = liftMatrix internalcomp-    conj = liftMatrix Data.Packed.Internal.conj-    real = id-    complex = Data.Packed.comp--instance Container Matrix (Complex Double) where-    toComplex = undefined-    fromComplex = undefined-    comp = undefined-    conj = undefined-    real = Data.Packed.comp-    complex = id----- | converts a real vector into a complex representation (with zero imaginary parts)-internalcomp :: Vector Double -> Vector (Complex Double)-internalcomp v = Data.Packed.Internal.toComplex (v,constant 0 (dim v))

@@ -1,101 +0,0 @@-{-# OPTIONS -XTypeOperators -XRank2Types  -XFlexibleContexts #-}---------------------------------------------------------------------------------- |--- Module      :  Data.Packed.Convert--- Copyright   :  (c) Alberto Ruiz 2008--- License     :  GPL-style------ Maintainer  :  Alberto Ruiz <aruiz@um.es>--- Stability   :  provisional--- Portability :  portable------ Conversion of Vectors and Matrices to and from the standard Haskell arrays.--- (provisional)-----------------------------------------------------------------------------------module Data.Packed.Convert (-    arrayFromVector, vectorFromArray,-    mArrayFromVector, vectorFromMArray,-    vectorToStorableArray, storableArrayToVector,-    arrayFromMatrix, matrixFromArray,-    mArrayFromMatrix, matrixFromMArray,---    matrixToStorableArray, storableArrayToMatrix-) where--import Data.Packed.Internal-import Data.Array.Storable-import Foreign-import Control.Monad.ST-import Data.Array.ST-import Data.Array.Unboxed---- | Creates a StorableArray indexed from 0 to dim -1.---   (Memory is efficiently copied, so you can then freely modify the obtained array)-vectorToStorableArray :: Storable t => Vector t -> IO (StorableArray Int t)-vectorToStorableArray v = do-    r <- cloneVector v-    unsafeForeignPtrToStorableArray (fptr r) (0,dim r -1)---- | Creates a Vector from a StorableArray.---   (Memory is efficiently copied, so posterior changes in the array will not affect the result)-storableArrayToVector :: Storable t => StorableArray Int t -> IO (Vector t)-storableArrayToVector s = do-    (a,b) <- getBounds s-    let n = (b-a+1)-    r <- createVector n-    withStorableArray s $ \p -> do-        let f _ d =  copyArray d p n >> return 0-        app1 f vec r "storableArrayToVector"-    return r---unsafeVectorToStorableArray :: Storable t => Vector t -> IO (StorableArray Int t)-unsafeVectorToStorableArray v = unsafeForeignPtrToStorableArray (fptr v) (0,dim v -1)----unsafeStorableArrayToVector :: Storable t => StorableArray Int t -> IO (Vector t)---unsafeStorableArrayToVector s = undefined -- the foreign ptr of Storable Array is not available?---------------------------------------------------------------------- provisional, we need Unboxed arrays for Complex Double---unsafeFreeze' :: (MArray a e m, Ix i) => a i e -> m (Array i e)-unsafeFreeze' = unsafeFreeze---- | creates an immutable Array from an hmatrix Vector (to do: unboxed)-arrayFromVector :: (Storable t) => Vector t -> Array Int t-arrayFromVector x = runSTArray (mArrayFromVector x)---- | creates a mutable array from an hmatrix Vector (to do: unboxed)-mArrayFromVector :: (MArray b t (ST s), Storable t) => Vector t -> ST s (b Int t)-mArrayFromVector v = unsafeThaw =<< unsafeIOToST ( unsafeFreeze' =<< (vectorToStorableArray $ v))----- (creates an hmatrix Vector from an immutable array (to do: unboxed))-vectorFromArray :: (Storable t) => Array Int t -> Vector t-vectorFromArray a = unsafePerformIO $ storableArrayToVector =<< unsafeThaw a---- | creates a mutable Array from an hmatrix Vector for manipulation with runSTUArray (to do: unboxed)-vectorFromMArray :: (Storable t, MArray a t (ST s)) => a Int t -> ST s (Vector t)-vectorFromMArray x = fmap vectorFromArray (unsafeFreeze' x)------------------------------------------------------------------------- provisional--matrixFromArray :: UArray (Int, Int) Double -> Matrix Double-matrixFromArray m = reshape c . fromList . elems $ m-    where ((r1,c1),(r2,c2)) = bounds m-          _r = r2-r1+1-          c = c2-c1+1--arrayFromMatrix :: Matrix Double -> UArray (Int, Int) Double-arrayFromMatrix m = listArray ((0,0),(rows m -1, cols m -1)) (toList $ flatten m)---mArrayFromMatrix :: (MArray b Double m) => Matrix Double -> m (b (Int, Int) Double)-mArrayFromMatrix = unsafeThaw . arrayFromMatrix--matrixFromMArray :: (MArray a Double (ST s)) => a (Int,Int) Double -> ST s (Matrix Double)-matrixFromMArray x = fmap matrixFromArray (unsafeFreeze x)

@@ -9,8 +9,7 @@ -- 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+-- 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. --@@ -21,7 +20,11 @@     Adapt,     vec, mat,     app1, app2, app3, app4,+    app5, app6, app7, app8, app9, app10,     MatrixOrder(..), orderOf, cmat, fmat,+    unsafeFromForeignPtr,+    unsafeToForeignPtr,+    check, (//) ) where  import Data.Packed.Internal

@@ -17,7 +17,8 @@ module Data.Packed.Internal.Common(   Adapt,   app1, app2, app3, app4,-  (//), check,+  app5, app6, app7, app8, app9, app10,+  (//), check, mbCatch,   splitEvery, common, compatdim,   fi,   table@@ -29,6 +30,7 @@ import Foreign.C.Types import Foreign.Storable.Complex() import Data.List(transpose,intersperse)+import Control.Exception as E  -- | @splitEvery 3 [1..9] == [[1,2,3],[4,5,6],[7,8,9]]@ splitEvery :: Int -> [a] -> [[a]]@@ -68,9 +70,15 @@ fi = fromIntegral  -- hmm..-ww2 w1 o1 w2 o2 f = w1 o1 $ \a1 -> w2 o2 $ \a2 -> f a1 a2-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)+ww2 w1 o1 w2 o2 f = w1 o1 $ w2 o2 . f+ww3 w1 o1 w2 o2 w3 o3 f = w1 o1 $ ww2 w2 o2 w3 o3 . f+ww4 w1 o1 w2 o2 w3 o3 w4 o4 f = w1 o1 $ ww3 w2 o2 w3 o3 w4 o4 . f+ww5 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 f = w1 o1 $ ww4 w2 o2 w3 o3 w4 o4 w5 o5 . f+ww6 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 f = w1 o1 $ ww5 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 . f+ww7 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 f = w1 o1 $ ww6 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 . f+ww8 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 f = w1 o1 $ ww7 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 . f+ww9 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 f = w1 o1 $ ww8 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 . f+ww10 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 w10 o10 f = w1 o1 $ ww9 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 w10 o10 . f  type Adapt f t r = t -> ((f -> r) -> IO()) -> IO() @@ -114,9 +122,23 @@ 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 $      \a1 a2 a3 -> f // a1 // a2 // a3 // check s-app4 f w1 o1 w2 o2 w3 o3 w4 o4 s = ww4 w1 o1 w2 o2 w3 o3 w4 o4 $ +app4 f w1 o1 w2 o2 w3 o3 w4 o4 s = ww4 w1 o1 w2 o2 w3 o3 w4 o4 $      \a1 a2 a3 a4 -> f // a1 // a2 // a3 // a4 // check s+app5 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 s = ww5 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 $+     \a1 a2 a3 a4 a5 -> f // a1 // a2 // a3 // a4 // a5 // check s+app6 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 s = ww6 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 $+     \a1 a2 a3 a4 a5 a6 -> f // a1 // a2 // a3 // a4 // a5 // a6 // check s+app7 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 s = ww7 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 $+     \a1 a2 a3 a4 a5 a6 a7 -> f // a1 // a2 // a3 // a4 // a5 // a6 // a7 // check s+app8 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 s = ww8 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 $+     \a1 a2 a3 a4 a5 a6 a7 a8 -> f // a1 // a2 // a3 // a4 // a5 // a6 // a7 // a8 // check s+app9 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 s = ww9 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 $+     \a1 a2 a3 a4 a5 a6 a7 a8 a9 -> f // a1 // a2 // a3 // a4 // a5 // a6 // a7 // a8 // a9 // check s+app10 f w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 w10 o10 s = ww10 w1 o1 w2 o2 w3 o3 w4 o4 w5 o5 w6 o6 w7 o7 w8 o8 w9 o9 w10 o10 $+     \a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 -> f // a1 // a2 // a3 // a4 // a5 // a6 // a7 // a8 // a9 // a10 // check s ++ -- GSL error codes are <= 1024 -- | error codes for the auxiliary functions required by the wrappers errorCode :: CInt -> String@@ -150,4 +172,10 @@     return ()  -- | description of GSL error codes-foreign import ccall "auxi.h gsl_strerror" gsl_strerror :: CInt -> IO (Ptr CChar)+foreign import ccall "gsl_strerror" gsl_strerror :: CInt -> IO (Ptr CChar)++-- | Error capture and conversion to Maybe+mbCatch :: IO x -> IO (Maybe x)+mbCatch act = E.catch (Just `fmap` act) f+    where f :: SomeException -> IO (Maybe x)+          f _ = return Nothing

@@ -18,7 +18,7 @@ module Data.Packed.Internal.Matrix(     Matrix(..), rows, cols,     MatrixOrder(..), orderOf,-    createMatrix, withMatrix, mat,+    createMatrix, mat,     cmat, fmat,     toLists, flatten, reshape,     Element(..),@@ -29,7 +29,7 @@     liftMatrix, liftMatrix2,     (@@>),     saveMatrix,-    fromComplex, toComplex, conj,+    fromComplexV, toComplexV, conjV,     singleton ) where @@ -38,7 +38,7 @@ import Data.Packed.Internal.Vector  import Foreign hiding (xor)-import Complex+import Data.Complex import Foreign.C.Types import Foreign.C.String @@ -115,11 +115,11 @@ fmat MC {irows = r, icols = c, cdat = d } = MF {irows = r, icols = c, fdat = transdata c d r}  -- C-Haskell matrix adapter-mat :: Adapt (CInt -> CInt -> Ptr t -> r) (Matrix t) r-mat = withMatrix+-- mat :: Adapt (CInt -> CInt -> Ptr t -> r) (Matrix t) r -withMatrix a f =-    withForeignPtr (fptr (xdat a)) $ \p -> do+mat :: (Storable t) => Matrix t -> (((CInt -> CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b+mat a f =+    unsafeWith (xdat a) $ \p -> do         let m g = do             g (fi (rows a)) (fi (cols a)) p         f m@@ -273,8 +273,8 @@         then v         else unsafePerformIO $ do                 w <- createVector (r2*c2)-                withForeignPtr (fptr v) $ \p ->-                    withForeignPtr (fptr w) $ \q -> do+                unsafeWith v $ \p ->+                    unsafeWith w $ \q -> do                         let go (-1) _ = return ()                             go !i (-1) = go (i-1) (c1-1)                             go !i !j = do x <- peekElemOff p (i*c1+j)@@ -300,8 +300,8 @@         then d         else unsafePerformIO $ do             v <- createVector (dim d)-            withForeignPtr (fptr d) $ \pd ->-                withForeignPtr (fptr v) $ \pv ->+            unsafeWith d $ \pd ->+                unsafeWith v $ \pv ->                     fun (fi r1) (fi c1) pd (fi r2) (fi c2) pv // check "transdataAux"             return v   where r1 = dim d `div` c1@@ -314,7 +314,7 @@  constant' v n = unsafePerformIO $ do     w <- createVector n-    withForeignPtr (fptr w) $ \p -> do+    unsafeWith w $ \p -> do         let go (-1) = return ()             go !k = pokeElemOff p k v >> go (k-1)         go (n-1)@@ -352,8 +352,8 @@  subMatrix'' (r0,c0) (rt,ct) c v = unsafePerformIO $ do     w <- createVector (rt*ct)-    withForeignPtr (fptr v) $ \p ->-        withForeignPtr (fptr w) $ \q -> do+    unsafeWith v $ \p ->+        unsafeWith w $ \q -> do             let go (-1) _ = return ()                 go !i (-1) = go (i-1) (ct-1)                 go !i !j = do x <- peekElemOff p ((i+r0)*c+j+c0)@@ -368,16 +368,16 @@ --------------------------------------------------------------------------  -- | obtains the complex conjugate of a complex vector-conj :: Vector (Complex Double) -> Vector (Complex Double)-conj = mapVector conjugate+conjV :: Vector (Complex Double) -> Vector (Complex Double)+conjV = mapVector conjugate  -- | creates a complex vector from vectors with real and imaginary parts-toComplex :: (Vector Double, Vector Double) ->  Vector (Complex Double)-toComplex (r,i) = asComplex $ flatten $ fromColumns [r,i]+toComplexV :: (Vector Double, Vector Double) ->  Vector (Complex Double)+toComplexV (r,i) = asComplex $ flatten $ fromColumns [r,i]  -- | the inverse of 'toComplex'-fromComplex :: Vector (Complex Double) -> (Vector Double, Vector Double)-fromComplex z = (r,i) where+fromComplexV :: Vector (Complex Double) -> (Vector Double, Vector Double)+fromComplexV z = (r,i) where     [r,i] = toColumns $ reshape 2 $ asReal z  --------------------------------------------------------------------------

@@ -15,7 +15,7 @@ module Data.Packed.Internal.Signatures where  import Foreign-import Complex+import Data.Complex import Foreign.C.Types  type PD = Ptr Double                            --

@@ -12,18 +12,20 @@ -- Vector implementation -- -------------------------------------------------------------------------------- #hide  module Data.Packed.Internal.Vector (-    Vector(..), dim,+    Vector, dim,     fromList, toList, (|>),-    join, (@>), safe, at, at', subVector,+    join, (@>), safe, at, at', subVector, takesV,     mapVector, zipVector,     foldVector, foldVectorG, foldLoop,-    createVector, withVector, vec,+    createVector, vec,     asComplex, asReal,     fwriteVector, freadVector, fprintfVector, fscanfVector,-    cloneVector+    cloneVector,+    unsafeToForeignPtr,+    unsafeFromForeignPtr,+    unsafeWith ) where  import Data.Packed.Internal.Common@@ -31,7 +33,7 @@ import Foreign import Foreign.C.String import Foreign.C.Types(CInt,CChar)-import Complex+import Data.Complex import Control.Monad(when)  #if __GLASGOW_HASKELL__ >= 605@@ -45,31 +47,63 @@ import GHC.IOBase #endif --- | A one-dimensional array of objects stored in a contiguous memory block.+#ifdef VECTOR+import qualified Data.Vector.Storable as Vector+import Data.Vector.Storable(Vector,+                            unsafeToForeignPtr,+                            unsafeFromForeignPtr,+                            unsafeWith)+#endif++#ifdef VECTOR++-- | Number of elements+dim :: (Storable t) => Vector t -> Int+dim = Vector.length++#else++-- | One-dimensional array of objects stored in a contiguous memory block. data Vector t =-    V { idim  :: {-# UNPACK #-} !Int              -- ^ number of elements-      , fptr :: {-# UNPACK #-} !(ForeignPtr t)    -- ^ foreign pointer to the memory block+    V { ioff :: {-# UNPACK #-} !Int              -- ^ offset of first element+      , idim :: {-# UNPACK #-} !Int              -- ^ number of elements+      , fptr :: {-# UNPACK #-} !(ForeignPtr t)   -- ^ foreign pointer to the memory block       } +unsafeToForeignPtr :: Vector a -> (ForeignPtr a, Int, Int)+unsafeToForeignPtr v = (fptr v, ioff v, idim v)++-- | Same convention as in Roman Leshchinskiy's vector package.+unsafeFromForeignPtr :: ForeignPtr a -> Int -> Int -> Vector a+unsafeFromForeignPtr fp i n | n > 0 = V {ioff = i, idim = n, fptr = fp}+                            | otherwise = error "unsafeFromForeignPtr with dim < 1"++unsafeWith (V i _ fp) m = withForeignPtr fp $ \p -> m (p `advancePtr` i)+{-# INLINE unsafeWith #-}+ -- | Number of elements-dim :: Vector t -> Int+dim :: (Storable t) => Vector t -> Int dim = idim --- C-Haskell vector adapter-vec :: Adapt (CInt -> Ptr t -> r) (Vector t) r-vec = withVector+#endif -withVector (V n fp) f = withForeignPtr fp $ \p -> do++-- C-Haskell vector adapter+-- vec :: Adapt (CInt -> Ptr t -> r) (Vector t) r+vec :: (Storable t) => Vector t -> (((CInt -> Ptr t -> t1) -> t1) -> IO b) -> IO b+vec x f = unsafeWith x $ \p -> do     let v g = do-        g (fi n) p+        g (fi $ dim x) p     f v+{-# INLINE vec #-} + -- 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)     fp <- doMalloc undefined-    return $ V n fp+    return $ unsafeFromForeignPtr fp 0 n   where     --     -- Use the much cheaper Haskell heap allocated storage@@ -92,11 +126,10 @@ fromList :: Storable a => [a] -> Vector a fromList l = unsafePerformIO $ do     v <- createVector (length l)-    let f _ p = pokeArray p l >> return 0-    app1 f vec v "fromList"+    unsafeWith v $ \ p -> pokeArray p l     return v -safeRead v = inlinePerformIO . withForeignPtr (fptr v)+safeRead v = inlinePerformIO . unsafeWith v {-# INLINE safeRead #-}  inlinePerformIO :: IO a -> a@@ -161,14 +194,27 @@                         -> Int       -- ^ number of elements to extract                         -> Vector t  -- ^ source                         -> Vector t  -- ^ result-subVector k l (v@V {idim=n})++#ifdef VECTOR++subVector = Vector.slice++#else++subVector k l v@V{idim = n, ioff = i}     | k<0 || k >= n || k+l > n || l < 0 = error "subVector out of range"+    | otherwise = v {idim = l, ioff = i+k}++subVectorCopy k l (v@V {idim=n})+    | k<0 || k >= n || k+l > n || l < 0 = error "subVector out of range"     | otherwise = unsafePerformIO $ do         r <- createVector l         let f _ s _ d = copyArray d (advancePtr s k) l >> return 0         app2 f vec v vec r "subVector"         return r +#endif+ {- | Reads a vector position:  @> fromList [0..9] \@\> 7@@ -191,28 +237,49 @@ join [v] = v join as = unsafePerformIO $ do     let tot = sum (map dim as)-    r@V {fptr = p} <- createVector tot-    withForeignPtr p $ \ptr ->+    r <- createVector tot+    unsafeWith r $ \ptr ->         joiner as tot ptr     return r   where joiner [] _ _ = return ()-        joiner (V {idim = n, fptr = b} : cs) _ p = do-            withForeignPtr b $ \pb -> copyArray p pb n+        joiner (v:cs) _ p = do+            let n = dim v+            unsafeWith v $ \pb -> copyArray p pb n             joiner cs 0 (advancePtr p n)  +{- | Extract consecutive subvectors of the given sizes.++@> takesV [3,4] (linspace 10 (1,10))+[3 |> [1.0,2.0,3.0],4 |> [4.0,5.0,6.0,7.0]]@++-}+takesV :: Storable t => [Int] -> Vector t -> [Vector t]+takesV ms w | sum ms > dim w = error $ "takesV " ++ show ms ++ " on dim = " ++ (show $ dim w)+            | otherwise = go ms w+    where go [] _ = []+          go (n:ns) v = subVector 0 n v+                      : go ns (subVector n (dim v - n) v)++---------------------------------------------------------------+ -- | transforms a complex vector into a real vector with alternating real and imaginary parts  asReal :: Vector (Complex Double) -> Vector Double-asReal v = V { idim = 2*dim v, fptr =  castForeignPtr (fptr v) }+--asReal v = V { ioff = 2*ioff v, idim = 2*dim v, fptr =  castForeignPtr (fptr v) }+asReal v = unsafeFromForeignPtr (castForeignPtr fp) (2*i) (2*n)+    where (fp,i,n) = unsafeToForeignPtr v  -- | transforms a real vector into a complex vector with alternating real and imaginary parts asComplex :: Vector Double -> Vector (Complex Double)-asComplex v = V { idim = dim v `div` 2, fptr =  castForeignPtr (fptr v) }+--asComplex v = V { ioff = ioff v `div` 2, idim = dim v `div` 2, fptr =  castForeignPtr (fptr v) }+asComplex v = unsafeFromForeignPtr (castForeignPtr fp) (i `div` 2) (n `div` 2)+    where (fp,i,n) = unsafeToForeignPtr v  ----------------------------------------------------------------  cloneVector :: Storable t => Vector t -> IO (Vector t)-cloneVector (v@V {idim=n}) = do+cloneVector v = do+        let n = dim v         r <- createVector n         let f _ s _ d =  copyArray d s n >> return 0         app2 f vec v vec r "cloneVector"@@ -224,8 +291,8 @@ mapVector :: (Storable a, Storable b) => (a-> b) -> Vector a -> Vector b mapVector f v = unsafePerformIO $ do     w <- createVector (dim v)-    withForeignPtr (fptr v) $ \p ->-        withForeignPtr (fptr w) $ \q -> do+    unsafeWith v $ \p ->+        unsafeWith w $ \q -> do             let go (-1) = return ()                 go !k = do x <- peekElemOff p k                            pokeElemOff      q k (f x)@@ -239,9 +306,9 @@ zipVector f u v = unsafePerformIO $ do     let n = min (dim u) (dim v)     w <- createVector n-    withForeignPtr (fptr u) $ \pu ->-        withForeignPtr (fptr v) $ \pv ->-            withForeignPtr (fptr w) $ \pw -> do+    unsafeWith u $ \pu ->+        unsafeWith v $ \pv ->+            unsafeWith w $ \pw -> do                 let go (-1) = return ()                     go !k = do x <- peekElemOff pu k                                y <- peekElemOff pv k@@ -252,7 +319,7 @@ {-# INLINE zipVector #-}  foldVector f x v = unsafePerformIO $-    withForeignPtr (fptr (v::Vector Double)) $ \p -> do+    unsafeWith (v::Vector Double) $ \p -> do         let go (-1) s = return s             go !k !s = do y <- peekElemOff p k                           go (k-1::Int) (f y s)

@@ -1,3 +1,4 @@+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts #-} ----------------------------------------------------------------------------- -- | -- Module      :  Data.Packed.Matrix@@ -13,7 +14,7 @@ -----------------------------------------------------------------------------  module Data.Packed.Matrix (-    Element,+    Element, Container(..),     Matrix,rows,cols,     (><),     trans,@@ -22,7 +23,8 @@     (@@>),     asRow, asColumn,     fromRows, toRows, fromColumns, toColumns,-    fromBlocks, repmat,+    fromBlocks, toBlocks, toBlocksEvery,+    repmat,     flipud, fliprl,     subMatrix, takeRows, dropRows, takeColumns, dropColumns,     extractRows,@@ -291,21 +293,6 @@           o = floor $ maximum $ map (logBase 10 . abs) $ toList $ flatten t           fmt = '%':show (dec+3) ++ '.':show dec ++"f" -{- | Show a vector using a function for showing matrices.--@disp = putStr . vecdisp (dispf 2)--\> disp (linspace 10 (0,1))-10 |> 0.00  0.11  0.22  0.33  0.44  0.56  0.67  0.78  0.89  1.00-@--}-vecdisp :: (Element t) => (Matrix t -> String) -> Vector t -> String-vecdisp f v-    = ((show (dim v) ++ " |> ") ++) . (++"\n")-    . unwords . lines .  tail . dropWhile (not . (`elem` " \n"))-    . f . trans . reshape 1-    $ v- -- | Tool to display matrices with latex syntax. latexFormat :: String -- ^ type of braces: \"matrix\", \"bmatrix\", \"pmatrix\", etc.             -> String -- ^ Formatted matrix, with elements separated by spaces and newlines@@ -412,4 +399,72 @@ compat' m1 m2 = rows m1 == 1 && cols m1 == 1              || rows m2 == 1 && cols m2 == 1              || rows m1 == rows m2 && cols m1 == cols m2++------------------------------------------------------------++toBlockRows [r] m | r == rows m = [m]+toBlockRows rs m = map (reshape (cols m)) (takesV szs (flatten m))+    where szs = map (* cols m) rs++toBlockCols [c] m | c == cols m = [m]+toBlockCols cs m = map trans . toBlockRows cs . trans $ m++-- | Partition a matrix into blocks with the given numbers of rows and columns.+-- The remaining rows and columns are discarded.+toBlocks :: (Element t) => [Int] -> [Int] -> Matrix t -> [[Matrix t]]+toBlocks rs cs m = map (toBlockCols cs) . toBlockRows rs $ m++-- | Fully partition a matrix into blocks of the same size. If the dimensions are not+-- a multiple of the given size the last blocks will be smaller.+toBlocksEvery :: (Element t) => Int -> Int -> Matrix t -> [[Matrix t]]+toBlocksEvery r c m = toBlocks rs cs m where+    (qr,rr) = rows m `divMod` r+    (qc,rc) = cols m `divMod` c+    rs = replicate qr r ++ if rr > 0 then [rr] else []+    cs = replicate qc c ++ if rc > 0 then [rc] else []++-------------------------------------------------------------------++-- | conversion utilities+class (Element e) => Container c e where+    toComplex   :: RealFloat e => (c e, c e) -> c (Complex e)+    fromComplex :: RealFloat e => c (Complex e) -> (c e, c e)+    comp        :: RealFloat e => c e -> c (Complex e)+    conj        :: RealFloat e => c (Complex e) -> c (Complex e)+    real        :: c Double -> c e+    complex     :: c e -> c (Complex Double)++instance Container Vector Double where+    toComplex = toComplexV+    fromComplex = fromComplexV+    comp v = toComplex (v,constant 0 (dim v))+    conj = conjV+    real = id+    complex = comp++instance Container Vector (Complex Double) where+    toComplex = undefined -- can't match+    fromComplex = undefined+    comp = undefined+    conj = undefined+    real = comp+    complex = id++instance Container Matrix Double where+    toComplex = uncurry $ liftMatrix2 $ curry toComplex+    fromComplex z = (reshape c r, reshape c i)+        where (r,i) = fromComplex (flatten z)+              c = cols z+    comp = liftMatrix comp+    conj = liftMatrix conj+    real = id+    complex = comp++instance Container Matrix (Complex Double) where+    toComplex = undefined+    fromComplex = undefined+    comp = undefined+    conj = undefined+    real = comp+    complex = id 

@@ -20,10 +20,9 @@ ) where  import Numeric.GSL.Vector-import Data.Packed-import Numeric.LinearAlgebra.Linear+import Data.Packed.Matrix+import Data.Packed.Vector import Numeric.LinearAlgebra.Algorithms-import Numeric.LinearAlgebra.Instances() import Numeric.LinearAlgebra.Interface  -- | Obtains a matrix whose rows are pseudorandom samples from a multivariate@@ -34,12 +33,10 @@                -> Matrix Double -- ^ covariance matrix                -> Matrix Double -- ^ result gaussianSample seed n med cov = m where-    (l,v) = eigSH' cov-    c = dim l+    c = dim med     meds = constant 1 n `outer` med     rs = reshape c $ randomVector seed Gaussian (c * n)-    ds = sqrt (abs l)-    m = rs <> (diag ds <> trans v) + meds+    m = rs <> cholSH cov + meds  -- | Obtains a matrix whose rows are pseudorandom samples from a multivariate -- uniform distribution.@@ -50,7 +47,6 @@ uniformSample seed n rgs = m where     (as,bs) = unzip rgs     a = fromList as-    b = fromList bs     cs = zipWith subtract as bs     d = dim a     dat = toRows $ reshape n $ randomVector seed Uniform (n*d)

@@ -37,11 +37,11 @@  {-# INLINE ioReadV #-} ioReadV :: Storable t => Vector t -> Int -> IO t-ioReadV v k = withForeignPtr (fptr v) $ \s -> peekElemOff s k+ioReadV v k = unsafeWith v $ \s -> peekElemOff s k  {-# INLINE ioWriteV #-} ioWriteV :: Storable t => Vector t -> Int -> t -> IO ()-ioWriteV v k x = withForeignPtr (fptr v) $ \s -> pokeElemOff s k x+ioWriteV v k x = unsafeWith v $ \s -> pokeElemOff s k x  newtype STVector s t = STVector (Vector t) 

@@ -16,7 +16,7 @@     Vector,     fromList, (|>), toList, buildVector,     dim, (@>),-    subVector, join,+    subVector, takesV, join,     constant, linspace,     vecdisp,     vectorMax, vectorMin, vectorMaxIndex, vectorMinIndex,

@@ -24,14 +24,14 @@      matrixToPGM, imshow, -    gnuplotX, gnuplotpdf+    gnuplotX, gnuplotpdf, gnuplotWin  ) where  import Data.Packed import Numeric.LinearAlgebra(outer) import Data.List(intersperse)-import System+import System.Process (system)  size = dim @@ -202,5 +202,21 @@     gnuplot cmd = do         writeFile "gnuplotcommand" cmd         _ <- system "gnuplot gnuplotcommand"+        _ <- system "rm gnuplotcommand"+        return ()++gnuplotWin :: String -> String -> [([[Double]], String)] -> IO ()+gnuplotWin title command ds = gnuplot (prelude ++ command ++" "++ draw) where+    (dats,defs) = unzip ds+    draw = concat (intersperse ", " (map ("\"-\" "++) defs)) ++ "\n" +++           concatMap pr dats++    pr = (++"e\n") . unlines . map (unwords . (map show))++    prelude = "set title \""++title++"\";"++    gnuplot cmd = do+        writeFile "gnuplotcommand" cmd+        _ <- system "gnuplot -persist gnuplotcommand"         _ <- system "rm gnuplotcommand"         return ()

@@ -8,8 +8,10 @@ Stability   :  provisional Portability :  uses -fffi and -fglasgow-exts -This module reexports all the available GSL functions (except those in "Numeric.LinearAlgebra").+This module reexports all available GSL functions. +The GSL special functions are in the separate package hmatrix-special.+ -}  module Numeric.GSL (@@ -20,20 +22,20 @@ , module Numeric.GSL.Minimization , module Numeric.GSL.Root , module Numeric.GSL.ODE-, module Numeric.GSL.Special-, module Complex+, module Numeric.GSL.Fitting+, module Data.Complex , setErrorHandlerOff ) where  import Numeric.GSL.Integration import Numeric.GSL.Differentiation-import Numeric.GSL.Special import Numeric.GSL.Fourier import Numeric.GSL.Polynomials import Numeric.GSL.Minimization import Numeric.GSL.Root import Numeric.GSL.ODE-import Complex+import Numeric.GSL.Fitting+import Data.Complex   -- | This action removes the GSL default error handler (which aborts the program), so that

@@ -0,0 +1,175 @@+{- |+Module      :  Numeric.GSL.Fitting+Copyright   :  (c) Alberto Ruiz 2010+License     :  GPL++Maintainer  :  Alberto Ruiz (aruiz at um dot es)+Stability   :  provisional+Portability :  uses ffi++Nonlinear Least-Squares Fitting++<http://www.gnu.org/software/gsl/manual/html_node/Nonlinear-Least_002dSquares-Fitting.html>++The example program in the GSL manual (see examples/fitting.hs):++@dat = [+ ([0.0],([6.0133918608118675],0.1)),+ ([1.0],([5.5153769909966535],0.1)),+ ([2.0],([5.261094606015287],0.1)),+ ...+ ([39.0],([1.0619821710802808],0.1))]++expModel [a,lambda,b] [t] = [a * exp (-lambda * t) + b]++expModelDer [a,lambda,b] [t] = [[exp (-lambda * t), -t * a * exp(-lambda*t) , 1]]++(sol,path) = fitModelScaled 1E-4 1E-4 20 (expModel, expModelDer) dat [1,0,0]++\> path+(6><5)+ [ 1.0,  76.45780563978782, 1.6465931240727802, 1.8147715267618197e-2, 0.6465931240727797+ , 2.0, 37.683816318260355,  2.858760367632973,  8.092094813253975e-2, 1.4479636296208662+ , 3.0,    9.5807893736187,  4.948995119561291,   0.11942927999921617, 1.0945766509238248+ , 4.0,  5.630494933603935,  5.021755718065913,   0.10287787128056883, 1.0338835440862608+ , 5.0,  5.443976278682909,  5.045204331329302,   0.10405523433131504,  1.019416067207375+ , 6.0, 5.4439736648994685,  5.045357818922331,   0.10404905846029407, 1.0192487112786812 ]+\> sol+[(5.045357818922331,6.027976702418132e-2),+(0.10404905846029407,3.157045047172834e-3),+(1.0192487112786812,3.782067731353722e-2)]@++-}+-----------------------------------------------------------------------------++module Numeric.GSL.Fitting (+    -- * Levenberg-Marquardt+    nlFitting, FittingMethod(..),+    -- * Utilities+    fitModelScaled, fitModel+) where++import Data.Packed.Internal+import Numeric.LinearAlgebra+import Foreign+import Foreign.C.Types(CInt)+import Numeric.GSL.Internal++-------------------------------------------------------------------------++data FittingMethod = LevenbergMarquardtScaled -- ^ Interface to gsl_multifit_fdfsolver_lmsder. This is a robust and efficient version of the Levenberg-Marquardt algorithm as implemented in the scaled lmder routine in minpack. Minpack was written by Jorge J. More, Burton S. Garbow and Kenneth E. Hillstrom.+                   | LevenbergMarquardt -- ^ This is an unscaled version of the lmder algorithm. The elements of the diagonal scaling matrix D are set to 1. This algorithm may be useful in circumstances where the scaled version of lmder converges too slowly, or the function is already scaled appropriately.+        deriving (Enum,Eq,Show,Bounded)+++-- | Nonlinear multidimensional least-squares fitting.+nlFitting :: FittingMethod+      -> Double                     -- ^ absolute tolerance+      -> Double                     -- ^ relative tolerance+      -> Int                        -- ^ maximum number of iterations allowed+      -> (Vector Double -> Vector Double)     -- ^ function to be minimized+      -> (Vector Double -> Matrix Double)   -- ^ Jacobian+      -> Vector Double                   -- ^ starting point+      -> (Vector Double, Matrix Double)  -- ^ solution vector and optimization path++nlFitting method epsabs epsrel maxit fun jac xinit = nlFitGen (fi (fromEnum method)) fun jac xinit epsabs epsrel maxit++nlFitGen m f jac xiv epsabs epsrel maxit = unsafePerformIO $ do+    let p   = dim xiv+        n   = dim (f xiv)+    fp <- mkVecVecfun (aux_vTov (checkdim1 n p . f))+    jp <- mkVecMatfun (aux_vTom (checkdim2 n p . jac))+    rawpath <- createMatrix RowMajor maxit (2+p)+    app2 (c_nlfit m fp jp epsabs epsrel (fi maxit) (fi n)) vec xiv mat rawpath "c_nlfit"+    let it = round (rawpath @@> (maxit-1,0))+        path = takeRows it rawpath+        [sol] = toRows $ dropRows (it-1) path+    freeHaskellFunPtr fp+    freeHaskellFunPtr jp+    return (subVector 2 p sol, path)++foreign import ccall "nlfit"+    c_nlfit:: CInt -> FunPtr TVV -> FunPtr TVM -> Double -> Double -> CInt -> CInt -> TVM++-------------------------------------------------------++checkdim1 n _p v+    | dim v == n = v+    | otherwise = error $ "Error: "++ show n+                        ++ " components expected in the result of the function supplied to nlFitting"++checkdim2 n p m+    | rows m == n && cols m == p = m+    | otherwise = error $ "Error: "++ show n ++ "x" ++ show p+                        ++ " Jacobian expected in nlFitting"++------------------------------------------------------------++err (model,deriv) dat vsol = zip sol errs where+    sol = toList vsol+    c = max 1 (chi/sqrt (fromIntegral dof))+    dof = length dat - (rows cov)+    chi = pnorm PNorm2 (fromList $ cost (resMs model) dat sol)+    js = fromLists $ jacobian (resDs deriv) dat sol+    cov = inv $ trans js <> js+    errs = toList $ scalar c * sqrt (takeDiag cov)++++-- | Higher level interface to 'nlFitting' 'LevenbergMarquardtScaled'. The optimization function and+-- Jacobian are automatically built from a model f vs x = y and its derivatives, and a list of+-- instances (x, (y,sigma)) to be fitted.++fitModelScaled+         :: Double -- ^ absolute tolerance+         -> Double -- ^ relative tolerance+         -> Int    -- ^ maximum number of iterations allowed+         -> ([Double] -> x -> [Double], [Double] -> x -> [[Double]]) -- ^ (model, derivatives)+         -> [(x, ([Double], Double))] -- ^ instances+         -> [Double] -- ^ starting point+         -> ([(Double, Double)], Matrix Double) -- ^ (solution, error) and optimization path+fitModelScaled epsabs epsrel maxit (model,deriv) dt xin = (err (model,deriv) dt sol, path) where+    (sol,path) = nlFitting LevenbergMarquardtScaled epsabs epsrel maxit+                (fromList . cost (resMs model) dt . toList)+                (fromLists . jacobian (resDs deriv) dt . toList)+                (fromList xin)++++-- | Higher level interface to 'nlFitting' 'LevenbergMarquardt'. The optimization function and+-- Jacobian are automatically built from a model f vs x = y and its derivatives, and a list of+-- instances (x,y) to be fitted.++fitModel :: Double -- ^ absolute tolerance+         -> Double -- ^ relative tolerance+         -> Int    -- ^ maximum number of iterations allowed+         -> ([Double] -> x -> [Double], [Double] -> x -> [[Double]]) -- ^ (model, derivatives)+         -> [(x, [Double])]  -- ^ instances+         -> [Double] -- ^ starting point+         -> ([Double], Matrix Double) -- ^ solution and optimization path+fitModel epsabs epsrel maxit (model,deriv) dt xin = (toList sol, path) where+    (sol,path) = nlFitting LevenbergMarquardt epsabs epsrel maxit+                (fromList . cost (resM model) dt . toList)+                (fromLists . jacobian (resD deriv) dt . toList)+                (fromList xin)++cost model ds vs = concatMap (model vs) ds++jacobian modelDer ds vs = concatMap (modelDer vs) ds++-- | Model-to-residual for association pairs with sigma, to be used with 'fitModel'.+resMs :: ([Double] -> x -> [Double]) -> [Double] -> (x, ([Double], Double)) -> [Double]+resMs m v = \(x,(ys,s)) -> zipWith (g s) (m v x) ys where g s a b = (a-b)/s++-- | Associated derivative for 'resMs'.+resDs :: ([Double] -> x -> [[Double]]) -> [Double] -> (x, ([Double], Double)) -> [[Double]]+resDs m v = \(x,(_,s)) -> map (map (/s)) (m v x)++-- | Model-to-residual for association pairs, to be used with 'fitModel'. It is equivalent+-- to 'resMs' with all sigmas = 1.+resM :: ([Double] -> x -> [Double]) -> [Double] -> (x, [Double]) -> [Double]+resM m v = \(x,ys) -> zipWith g (m v x) ys where g a b = a-b++-- | Associated derivative for 'resM'.+resD :: ([Double] -> x -> [[Double]]) -> [Double] -> (x, [Double]) -> [[Double]]+resD m v = \(x,_) -> m v x

@@ -21,7 +21,7 @@ ) where  import Data.Packed.Internal-import Complex+import Data.Complex import Foreign import Foreign.C.Types(CInt) 

@@ -35,12 +35,12 @@  aux_vTov :: (Vector Double -> Vector Double) -> TVV aux_vTov f n p nr r = g where-    V {fptr = pr} = f x+    v = 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)+    g = do unsafeWith v $ \p' -> copyArray r p' (fromIntegral nr)            return 0  foreign import ccall "wrapper"@@ -51,12 +51,12 @@  aux_vTom :: (Vector Double -> Matrix Double) -> TVM aux_vTom f n p rr cr r = g where-    V {fptr = pr} = flatten $ f x+    v = 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)+    g = do unsafeWith v $ \p' -> copyArray r p' (fromIntegral $ rr*cr)            return 0  createV n fun msg = unsafePerformIO $ do

@@ -109,7 +109,7 @@ minimizeV method eps maxit szv f xiv = unsafePerformIO $ do     let n   = dim xiv     fp <- mkVecfun (iv f)-    rawpath <- ww2 withVector xiv withVector szv $ \xiv' szv' ->+    rawpath <- ww2 vec xiv vec szv $ \xiv' szv' ->                    createMIO maxit (n+3)                          (c_minimize (fi (fromEnum method)) fp eps (fi maxit) // xiv' // szv')                          "minimize"@@ -166,7 +166,7 @@         df' = (checkdim1 n . df)     fp <- mkVecfun (iv f')     dfp <- mkVecVecfun (aux_vTov df')-    rawpath <- withVector xiv $ \xiv' ->+    rawpath <- vec xiv $ \xiv' ->                     createMIO maxit (n+2)                          (c_minimizeD (fi (fromEnum method)) fp dfp istep tol eps (fi maxit) // xiv')                          "minimizeD"

@@ -33,7 +33,6 @@ ) where  import Data.Packed.Internal-import Data.Packed.Matrix import Foreign import Foreign.C.Types(CInt) import Numeric.GSL.Internal@@ -64,7 +63,6 @@           epsAbs = 1.49012e-08           epsRel = 1.49012e-08           l2v f = \t -> fromList  . f t . toList-          l2m f = \t -> fromLists . f t . toList  -- | Evolution of the system with adaptive step-size control. odeSolveV@@ -83,8 +81,8 @@     jp <- case mbjac of         Just jac -> mkDoubleVecMatfun (\t -> aux_vTom (checkdim2 n . jac t))         Nothing  -> return nullFunPtr-    sol <- withVector xiv $ \xiv' ->-            withVector (checkTimes ts) $ \ts' ->+    sol <- vec xiv $ \xiv' ->+            vec (checkTimes ts) $ \ts' ->              createMIO (dim ts) n               (ode_c (fi (fromEnum method)) h epsAbs epsRel fp jp // xiv' // ts' )               "ode"

@@ -20,7 +20,7 @@ ) where  import Data.Packed.Internal-import Complex+import Data.Complex import Foreign  {- | Solution of general polynomial equations, using /gsl_poly_complex_solve/. For example,

@@ -79,7 +79,7 @@     let xiv = fromList xi         n   = dim xiv     fp <- mkVecVecfun (aux_vTov (checkdim1 n . fromList . f . toList))-    rawpath <- withVector xiv $ \xiv' ->+    rawpath <- vec xiv $ \xiv' ->                    createMIO maxit (2*n+1)                          (c_root m fp epsabs (fi maxit) // xiv')                          "root"@@ -117,7 +117,7 @@         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' ->+    rawpath <- vec xiv $ \xiv' ->                    createMIO maxit (2*n+1)                          (c_rootj m fp jp epsabs (fi maxit) // xiv')                          "root"

@@ -1,76 +0,0 @@-------------------------------------------------------------------------------{- |-Module      :  Numeric.GSL.Special-Copyright   :  (c) Alberto Ruiz 2006-License     :  GPL-style--Maintainer  :  Alberto Ruiz (aruiz at um dot es)-Stability   :  provisional-Portability :  uses ffi--Wrappers for selected special functions.--<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>--}--------------------------------------------------------------------------------module Numeric.GSL.Special (-  module Numeric.GSL.Special.Airy-, module Numeric.GSL.Special.Bessel-, module Numeric.GSL.Special.Clausen-, module Numeric.GSL.Special.Coulomb-, module Numeric.GSL.Special.Coupling-, module Numeric.GSL.Special.Dawson-, module Numeric.GSL.Special.Debye-, module Numeric.GSL.Special.Dilog-, module Numeric.GSL.Special.Elementary-, module Numeric.GSL.Special.Ellint-, module Numeric.GSL.Special.Elljac-, module Numeric.GSL.Special.Erf-, module Numeric.GSL.Special.Exp-, module Numeric.GSL.Special.Expint-, module Numeric.GSL.Special.Fermi_dirac-, module Numeric.GSL.Special.Gamma-, module Numeric.GSL.Special.Gegenbauer-, module Numeric.GSL.Special.Hyperg-, module Numeric.GSL.Special.Laguerre-, module Numeric.GSL.Special.Lambert-, module Numeric.GSL.Special.Legendre-, module Numeric.GSL.Special.Log-, module Numeric.GSL.Special.Pow_int-, module Numeric.GSL.Special.Psi-, module Numeric.GSL.Special.Synchrotron-, module Numeric.GSL.Special.Transport-, module Numeric.GSL.Special.Trig-, module Numeric.GSL.Special.Zeta-)-where--import Numeric.GSL.Special.Airy-import Numeric.GSL.Special.Bessel-import Numeric.GSL.Special.Clausen-import Numeric.GSL.Special.Coulomb-import Numeric.GSL.Special.Coupling-import Numeric.GSL.Special.Dawson-import Numeric.GSL.Special.Debye-import Numeric.GSL.Special.Dilog-import Numeric.GSL.Special.Elementary-import Numeric.GSL.Special.Ellint-import Numeric.GSL.Special.Elljac-import Numeric.GSL.Special.Erf-import Numeric.GSL.Special.Exp-import Numeric.GSL.Special.Expint-import Numeric.GSL.Special.Fermi_dirac-import Numeric.GSL.Special.Gamma-import Numeric.GSL.Special.Gegenbauer-import Numeric.GSL.Special.Hyperg-import Numeric.GSL.Special.Laguerre-import Numeric.GSL.Special.Lambert-import Numeric.GSL.Special.Legendre-import Numeric.GSL.Special.Log-import Numeric.GSL.Special.Pow_int-import Numeric.GSL.Special.Psi-import Numeric.GSL.Special.Synchrotron-import Numeric.GSL.Special.Transport-import Numeric.GSL.Special.Trig-import Numeric.GSL.Special.Zeta

@@ -1,141 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Airy--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_airy.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Airy(-  airy_Ai_e-, airy_Ai-, airy_Bi_e-, airy_Bi-, airy_Ai_scaled_e-, airy_Ai_scaled-, airy_Bi_scaled_e-, airy_Bi_scaled-, airy_Ai_deriv_e-, airy_Ai_deriv-, airy_Bi_deriv_e-, airy_Bi_deriv-, airy_Ai_deriv_scaled_e-, airy_Ai_deriv_scaled-, airy_Bi_deriv_scaled_e-, airy_Bi_deriv_scaled-, airy_zero_Ai_e-, airy_zero_Ai-, airy_zero_Bi_e-, airy_zero_Bi-, airy_zero_Ai_deriv_e-, airy_zero_Ai_deriv-, airy_zero_Bi_deriv_e-, airy_zero_Bi_deriv-, Precision(..)-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--airy_Ai_e :: Double -> Precision -> (Double,Double)-airy_Ai_e x mode = createSFR "airy_Ai_e" $ gsl_sf_airy_Ai_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Ai :: Double -> Precision -> Double-airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double--airy_Bi_e :: Double -> Precision -> (Double,Double)-airy_Bi_e x mode = createSFR "airy_Bi_e" $ gsl_sf_airy_Bi_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Bi :: Double -> Precision -> Double-airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double--airy_Ai_scaled_e :: Double -> Precision -> (Double,Double)-airy_Ai_scaled_e x mode = createSFR "airy_Ai_scaled_e" $ gsl_sf_airy_Ai_scaled_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Ai_scaled :: Double -> Precision -> Double-airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double--airy_Bi_scaled_e :: Double -> Precision -> (Double,Double)-airy_Bi_scaled_e x mode = createSFR "airy_Bi_scaled_e" $ gsl_sf_airy_Bi_scaled_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Bi_scaled :: Double -> Precision -> Double-airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double--airy_Ai_deriv_e :: Double -> Precision -> (Double,Double)-airy_Ai_deriv_e x mode = createSFR "airy_Ai_deriv_e" $ gsl_sf_airy_Ai_deriv_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Ai_deriv :: Double -> Precision -> Double-airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double--airy_Bi_deriv_e :: Double -> Precision -> (Double,Double)-airy_Bi_deriv_e x mode = createSFR "airy_Bi_deriv_e" $ gsl_sf_airy_Bi_deriv_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Bi_deriv :: Double -> Precision -> Double-airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double--airy_Ai_deriv_scaled_e :: Double -> Precision -> (Double,Double)-airy_Ai_deriv_scaled_e x mode = createSFR "airy_Ai_deriv_scaled_e" $ gsl_sf_airy_Ai_deriv_scaled_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Ai_deriv_scaled :: Double -> Precision -> Double-airy_Ai_deriv_scaled x mode = gsl_sf_airy_Ai_deriv_scaled x  (precCode mode)-foreign import ccall "gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double--airy_Bi_deriv_scaled_e :: Double -> Precision -> (Double,Double)-airy_Bi_deriv_scaled_e x mode = createSFR "airy_Bi_deriv_scaled_e" $ gsl_sf_airy_Bi_deriv_scaled_e x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--airy_Bi_deriv_scaled :: Double -> Precision -> Double-airy_Bi_deriv_scaled x mode = gsl_sf_airy_Bi_deriv_scaled x  (precCode mode)-foreign import ccall "gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double--airy_zero_Ai_e :: CInt -> (Double,Double)-airy_zero_Ai_e s = createSFR "airy_zero_Ai_e" $ gsl_sf_airy_zero_Ai_e s-foreign import ccall "gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt--airy_zero_Ai :: CInt -> Double-airy_zero_Ai = gsl_sf_airy_zero_Ai-foreign import ccall "gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double--airy_zero_Bi_e :: CInt -> (Double,Double)-airy_zero_Bi_e s = createSFR "airy_zero_Bi_e" $ gsl_sf_airy_zero_Bi_e s-foreign import ccall "gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt--airy_zero_Bi :: CInt -> Double-airy_zero_Bi = gsl_sf_airy_zero_Bi-foreign import ccall "gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double--airy_zero_Ai_deriv_e :: CInt -> (Double,Double)-airy_zero_Ai_deriv_e s = createSFR "airy_zero_Ai_deriv_e" $ gsl_sf_airy_zero_Ai_deriv_e s-foreign import ccall "gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt--airy_zero_Ai_deriv :: CInt -> Double-airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv-foreign import ccall "gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double--airy_zero_Bi_deriv_e :: CInt -> (Double,Double)-airy_zero_Bi_deriv_e s = createSFR "airy_zero_Bi_deriv_e" $ gsl_sf_airy_zero_Bi_deriv_e s-foreign import ccall "gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt--airy_zero_Bi_deriv :: CInt -> Double-airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv-foreign import ccall "gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: CInt -> Double

@@ -1,508 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Bessel--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_bessel.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Bessel(-  bessel_J0_e-, bessel_J0-, bessel_J1_e-, bessel_J1-, bessel_Jn_e-, bessel_Jn-, bessel_Y0_e-, bessel_Y0-, bessel_Y1_e-, bessel_Y1-, bessel_Yn_e-, bessel_Yn-, bessel_I0_e-, bessel_I0-, bessel_I1_e-, bessel_I1-, bessel_In_e-, bessel_In-, bessel_I0_scaled_e-, bessel_I0_scaled-, bessel_I1_scaled_e-, bessel_I1_scaled-, bessel_In_scaled_e-, bessel_In_scaled-, bessel_K0_e-, bessel_K0-, bessel_K1_e-, bessel_K1-, bessel_Kn_e-, bessel_Kn-, bessel_K0_scaled_e-, bessel_K0_scaled-, bessel_K1_scaled_e-, bessel_K1_scaled-, bessel_Kn_scaled_e-, bessel_Kn_scaled-, bessel_j0_e-, bessel_j0-, bessel_j1_e-, bessel_j1-, bessel_j2_e-, bessel_j2-, bessel_jl_e-, bessel_jl-, bessel_y0_e-, bessel_y0-, bessel_y1_e-, bessel_y1-, bessel_y2_e-, bessel_y2-, bessel_yl_e-, bessel_yl-, bessel_i0_scaled_e-, bessel_i0_scaled-, bessel_i1_scaled_e-, bessel_i1_scaled-, bessel_i2_scaled_e-, bessel_i2_scaled-, bessel_il_scaled_e-, bessel_il_scaled-, bessel_k0_scaled_e-, bessel_k0_scaled-, bessel_k1_scaled_e-, bessel_k1_scaled-, bessel_k2_scaled_e-, bessel_k2_scaled-, bessel_kl_scaled_e-, bessel_kl_scaled-, bessel_Jnu_e-, bessel_Jnu-, bessel_Ynu_e-, bessel_Ynu-, bessel_Inu_scaled_e-, bessel_Inu_scaled-, bessel_Inu_e-, bessel_Inu-, bessel_Knu_scaled_e-, bessel_Knu_scaled-, bessel_Knu_e-, bessel_Knu-, bessel_lnKnu_e-, bessel_lnKnu-, bessel_zero_J0_e-, bessel_zero_J0-, bessel_zero_J1_e-, bessel_zero_J1-, bessel_zero_Jnu_e-, bessel_zero_Jnu-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--bessel_J0_e :: Double -> (Double,Double)-bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x-foreign import ccall "gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt--bessel_J0 :: Double -> Double-bessel_J0 = gsl_sf_bessel_J0-foreign import ccall "gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double--bessel_J1_e :: Double -> (Double,Double)-bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x-foreign import ccall "gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt--bessel_J1 :: Double -> Double-bessel_J1 = gsl_sf_bessel_J1-foreign import ccall "gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double--bessel_Jn_e :: CInt -> Double -> (Double,Double)-bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x-foreign import ccall "gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_Jn :: CInt -> Double -> Double-bessel_Jn = gsl_sf_bessel_Jn-foreign import ccall "gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double--bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_Jn_array = gsl_sf_bessel_Jn_array-foreign import ccall "gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_Y0_e :: Double -> (Double,Double)-bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x-foreign import ccall "gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt--bessel_Y0 :: Double -> Double-bessel_Y0 = gsl_sf_bessel_Y0-foreign import ccall "gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double--bessel_Y1_e :: Double -> (Double,Double)-bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x-foreign import ccall "gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt--bessel_Y1 :: Double -> Double-bessel_Y1 = gsl_sf_bessel_Y1-foreign import ccall "gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double--bessel_Yn_e :: CInt -> Double -> (Double,Double)-bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x-foreign import ccall "gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_Yn :: CInt -> Double -> Double-bessel_Yn = gsl_sf_bessel_Yn-foreign import ccall "gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double--bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_Yn_array = gsl_sf_bessel_Yn_array-foreign import ccall "gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_I0_e :: Double -> (Double,Double)-bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x-foreign import ccall "gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt--bessel_I0 :: Double -> Double-bessel_I0 = gsl_sf_bessel_I0-foreign import ccall "gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double--bessel_I1_e :: Double -> (Double,Double)-bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x-foreign import ccall "gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt--bessel_I1 :: Double -> Double-bessel_I1 = gsl_sf_bessel_I1-foreign import ccall "gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double--bessel_In_e :: CInt -> Double -> (Double,Double)-bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x-foreign import ccall "gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_In :: CInt -> Double -> Double-bessel_In = gsl_sf_bessel_In-foreign import ccall "gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double--bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_In_array = gsl_sf_bessel_In_array-foreign import ccall "gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_I0_scaled_e :: Double -> (Double,Double)-bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x-foreign import ccall "gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt--bessel_I0_scaled :: Double -> Double-bessel_I0_scaled = gsl_sf_bessel_I0_scaled-foreign import ccall "gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double--bessel_I1_scaled_e :: Double -> (Double,Double)-bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x-foreign import ccall "gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt--bessel_I1_scaled :: Double -> Double-bessel_I1_scaled = gsl_sf_bessel_I1_scaled-foreign import ccall "gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double--bessel_In_scaled_e :: CInt -> Double -> (Double,Double)-bessel_In_scaled_e n x = createSFR "bessel_In_scaled_e" $ gsl_sf_bessel_In_scaled_e n x-foreign import ccall "gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_In_scaled :: CInt -> Double -> Double-bessel_In_scaled = gsl_sf_bessel_In_scaled-foreign import ccall "gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double--bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array-foreign import ccall "gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_K0_e :: Double -> (Double,Double)-bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x-foreign import ccall "gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt--bessel_K0 :: Double -> Double-bessel_K0 = gsl_sf_bessel_K0-foreign import ccall "gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double--bessel_K1_e :: Double -> (Double,Double)-bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x-foreign import ccall "gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt--bessel_K1 :: Double -> Double-bessel_K1 = gsl_sf_bessel_K1-foreign import ccall "gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double--bessel_Kn_e :: CInt -> Double -> (Double,Double)-bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x-foreign import ccall "gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_Kn :: CInt -> Double -> Double-bessel_Kn = gsl_sf_bessel_Kn-foreign import ccall "gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double--bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_Kn_array = gsl_sf_bessel_Kn_array-foreign import ccall "gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_K0_scaled_e :: Double -> (Double,Double)-bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x-foreign import ccall "gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt--bessel_K0_scaled :: Double -> Double-bessel_K0_scaled = gsl_sf_bessel_K0_scaled-foreign import ccall "gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double--bessel_K1_scaled_e :: Double -> (Double,Double)-bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x-foreign import ccall "gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt--bessel_K1_scaled :: Double -> Double-bessel_K1_scaled = gsl_sf_bessel_K1_scaled-foreign import ccall "gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double--bessel_Kn_scaled_e :: CInt -> Double -> (Double,Double)-bessel_Kn_scaled_e n x = createSFR "bessel_Kn_scaled_e" $ gsl_sf_bessel_Kn_scaled_e n x-foreign import ccall "gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_Kn_scaled :: CInt -> Double -> Double-bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled-foreign import ccall "gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double--bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array-foreign import ccall "gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--bessel_j0_e :: Double -> (Double,Double)-bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x-foreign import ccall "gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt--bessel_j0 :: Double -> Double-bessel_j0 = gsl_sf_bessel_j0-foreign import ccall "gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double--bessel_j1_e :: Double -> (Double,Double)-bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x-foreign import ccall "gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt--bessel_j1 :: Double -> Double-bessel_j1 = gsl_sf_bessel_j1-foreign import ccall "gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double--bessel_j2_e :: Double -> (Double,Double)-bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x-foreign import ccall "gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt--bessel_j2 :: Double -> Double-bessel_j2 = gsl_sf_bessel_j2-foreign import ccall "gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double--bessel_jl_e :: CInt -> Double -> (Double,Double)-bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x-foreign import ccall "gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_jl :: CInt -> Double -> Double-bessel_jl = gsl_sf_bessel_jl-foreign import ccall "gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double--bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt-bessel_jl_array = gsl_sf_bessel_jl_array-foreign import ccall "gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt--bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt-bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array-foreign import ccall "gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt--bessel_y0_e :: Double -> (Double,Double)-bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x-foreign import ccall "gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt--bessel_y0 :: Double -> Double-bessel_y0 = gsl_sf_bessel_y0-foreign import ccall "gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double--bessel_y1_e :: Double -> (Double,Double)-bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x-foreign import ccall "gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt--bessel_y1 :: Double -> Double-bessel_y1 = gsl_sf_bessel_y1-foreign import ccall "gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double--bessel_y2_e :: Double -> (Double,Double)-bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x-foreign import ccall "gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt--bessel_y2 :: Double -> Double-bessel_y2 = gsl_sf_bessel_y2-foreign import ccall "gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double--bessel_yl_e :: CInt -> Double -> (Double,Double)-bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x-foreign import ccall "gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_yl :: CInt -> Double -> Double-bessel_yl = gsl_sf_bessel_yl-foreign import ccall "gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double--bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt-bessel_yl_array = gsl_sf_bessel_yl_array-foreign import ccall "gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt--bessel_i0_scaled_e :: Double -> (Double,Double)-bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x-foreign import ccall "gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt--bessel_i0_scaled :: Double -> Double-bessel_i0_scaled = gsl_sf_bessel_i0_scaled-foreign import ccall "gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double--bessel_i1_scaled_e :: Double -> (Double,Double)-bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x-foreign import ccall "gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt--bessel_i1_scaled :: Double -> Double-bessel_i1_scaled = gsl_sf_bessel_i1_scaled-foreign import ccall "gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double--bessel_i2_scaled_e :: Double -> (Double,Double)-bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x-foreign import ccall "gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt--bessel_i2_scaled :: Double -> Double-bessel_i2_scaled = gsl_sf_bessel_i2_scaled-foreign import ccall "gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double--bessel_il_scaled_e :: CInt -> Double -> (Double,Double)-bessel_il_scaled_e l x = createSFR "bessel_il_scaled_e" $ gsl_sf_bessel_il_scaled_e l x-foreign import ccall "gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_il_scaled :: CInt -> Double -> Double-bessel_il_scaled = gsl_sf_bessel_il_scaled-foreign import ccall "gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double--bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt-bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array-foreign import ccall "gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt--bessel_k0_scaled_e :: Double -> (Double,Double)-bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x-foreign import ccall "gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt--bessel_k0_scaled :: Double -> Double-bessel_k0_scaled = gsl_sf_bessel_k0_scaled-foreign import ccall "gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double--bessel_k1_scaled_e :: Double -> (Double,Double)-bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x-foreign import ccall "gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt--bessel_k1_scaled :: Double -> Double-bessel_k1_scaled = gsl_sf_bessel_k1_scaled-foreign import ccall "gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double--bessel_k2_scaled_e :: Double -> (Double,Double)-bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x-foreign import ccall "gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt--bessel_k2_scaled :: Double -> Double-bessel_k2_scaled = gsl_sf_bessel_k2_scaled-foreign import ccall "gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double--bessel_kl_scaled_e :: CInt -> Double -> (Double,Double)-bessel_kl_scaled_e l x = createSFR "bessel_kl_scaled_e" $ gsl_sf_bessel_kl_scaled_e l x-foreign import ccall "gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt--bessel_kl_scaled :: CInt -> Double -> Double-bessel_kl_scaled = gsl_sf_bessel_kl_scaled-foreign import ccall "gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double--bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt-bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array-foreign import ccall "gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt--bessel_Jnu_e :: Double -> Double -> (Double,Double)-bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x-foreign import ccall "gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Jnu :: Double -> Double -> Double-bessel_Jnu = gsl_sf_bessel_Jnu-foreign import ccall "gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double--bessel_Ynu_e :: Double -> Double -> (Double,Double)-bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x-foreign import ccall "gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Ynu :: Double -> Double -> Double-bessel_Ynu = gsl_sf_bessel_Ynu-foreign import ccall "gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double--bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> CInt-bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v-foreign import ccall "gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt--bessel_Inu_scaled_e :: Double -> Double -> (Double,Double)-bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x-foreign import ccall "gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Inu_scaled :: Double -> Double -> Double-bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled-foreign import ccall "gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double--bessel_Inu_e :: Double -> Double -> (Double,Double)-bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x-foreign import ccall "gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Inu :: Double -> Double -> Double-bessel_Inu = gsl_sf_bessel_Inu-foreign import ccall "gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double--bessel_Knu_scaled_e :: Double -> Double -> (Double,Double)-bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x-foreign import ccall "gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Knu_scaled :: Double -> Double -> Double-bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled-foreign import ccall "gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double--bessel_Knu_e :: Double -> Double -> (Double,Double)-bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x-foreign import ccall "gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt--bessel_Knu :: Double -> Double -> Double-bessel_Knu = gsl_sf_bessel_Knu-foreign import ccall "gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double--bessel_lnKnu_e :: Double -> Double -> (Double,Double)-bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x-foreign import ccall "gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt--bessel_lnKnu :: Double -> Double -> Double-bessel_lnKnu = gsl_sf_bessel_lnKnu-foreign import ccall "gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double--bessel_zero_J0_e :: CInt -> (Double,Double)-bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s-foreign import ccall "gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt--bessel_zero_J0 :: CInt -> Double-bessel_zero_J0 = gsl_sf_bessel_zero_J0-foreign import ccall "gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double--bessel_zero_J1_e :: CInt -> (Double,Double)-bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s-foreign import ccall "gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt--bessel_zero_J1 :: CInt -> Double-bessel_zero_J1 = gsl_sf_bessel_zero_J1-foreign import ccall "gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double--bessel_zero_Jnu_e :: Double -> CInt -> (Double,Double)-bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s-foreign import ccall "gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt--bessel_zero_Jnu :: Double -> CInt -> Double-bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu-foreign import ccall "gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> CInt -> Double

@@ -1,30 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Clausen--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_clausen.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Clausen(-  clausen_e-, clausen-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--clausen_e :: Double -> (Double,Double)-clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x-foreign import ccall "gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt--clausen :: Double -> Double-clausen = gsl_sf_clausen-foreign import ccall "gsl_sf_clausen" gsl_sf_clausen :: Double -> Double

@@ -1,69 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Coulomb--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_coulomb.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Coulomb(-  hydrogenicR_1_e-, hydrogenicR_1-, hydrogenicR_e-, hydrogenicR-, coulomb_CL_e-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--hydrogenicR_1_e :: Double -> Double -> (Double,Double)-hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r-foreign import ccall "gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt--hydrogenicR_1 :: Double -> Double -> Double-hydrogenicR_1 = gsl_sf_hydrogenicR_1-foreign import ccall "gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double--hydrogenicR_e :: CInt -> CInt -> Double -> Double -> (Double,Double)-hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r-foreign import ccall "gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt--hydrogenicR :: CInt -> CInt -> Double -> Double -> Double-hydrogenicR = gsl_sf_hydrogenicR-foreign import ccall "gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double--coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt-coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e-foreign import ccall "gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt--coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt-coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array-foreign import ccall "gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt--coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt-coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array-foreign import ccall "gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt--coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt-coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array-foreign import ccall "gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt--coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt-coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array-foreign import ccall "gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt--coulomb_CL_e :: Double -> Double -> (Double,Double)-coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta-foreign import ccall "gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt--coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt-coulomb_CL_array = gsl_sf_coulomb_CL_array-foreign import ccall "gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt

@@ -1,68 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Coupling--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_coupling.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Coupling(-  coupling_3j_e-, coupling_3j-, coupling_6j_e-, coupling_6j-, coupling_RacahW_e-, coupling_RacahW-, coupling_9j_e-, coupling_9j-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)-coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc = createSFR "coupling_3j_e" $ gsl_sf_coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc-foreign import ccall "gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt--coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double-coupling_3j = gsl_sf_coupling_3j-foreign import ccall "gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double--coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)-coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_e" $ gsl_sf_coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf-foreign import ccall "gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt--coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double-coupling_6j = gsl_sf_coupling_6j-foreign import ccall "gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double--coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)-coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_RacahW_e" $ gsl_sf_coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf-foreign import ccall "gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt--coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double-coupling_RacahW = gsl_sf_coupling_RacahW-foreign import ccall "gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double--coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)-coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji = createSFR "coupling_9j_e" $ gsl_sf_coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji-foreign import ccall "gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt--coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double-coupling_9j = gsl_sf_coupling_9j-foreign import ccall "gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double--coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)-coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_INCORRECT_e" $ gsl_sf_coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf-foreign import ccall "gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt--coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double-coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT-foreign import ccall "gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double

@@ -1,30 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Dawson--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_dawson.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Dawson(-  dawson_e-, dawson-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--dawson_e :: Double -> (Double,Double)-dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x-foreign import ccall "gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt--dawson :: Double -> Double-dawson = gsl_sf_dawson-foreign import ccall "gsl_sf_dawson" gsl_sf_dawson :: Double -> Double

@@ -1,80 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Debye--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_debye.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Debye(-  debye_1_e-, debye_1-, debye_2_e-, debye_2-, debye_3_e-, debye_3-, debye_4_e-, debye_4-, debye_5_e-, debye_5-, debye_6_e-, debye_6-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--debye_1_e :: Double -> (Double,Double)-debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x-foreign import ccall "gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt--debye_1 :: Double -> Double-debye_1 = gsl_sf_debye_1-foreign import ccall "gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double--debye_2_e :: Double -> (Double,Double)-debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x-foreign import ccall "gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt--debye_2 :: Double -> Double-debye_2 = gsl_sf_debye_2-foreign import ccall "gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double--debye_3_e :: Double -> (Double,Double)-debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x-foreign import ccall "gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt--debye_3 :: Double -> Double-debye_3 = gsl_sf_debye_3-foreign import ccall "gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double--debye_4_e :: Double -> (Double,Double)-debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x-foreign import ccall "gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt--debye_4 :: Double -> Double-debye_4 = gsl_sf_debye_4-foreign import ccall "gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double--debye_5_e :: Double -> (Double,Double)-debye_5_e x = createSFR "debye_5_e" $ gsl_sf_debye_5_e x-foreign import ccall "gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt--debye_5 :: Double -> Double-debye_5 = gsl_sf_debye_5-foreign import ccall "gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double--debye_6_e :: Double -> (Double,Double)-debye_6_e x = createSFR "debye_6_e" $ gsl_sf_debye_6_e x-foreign import ccall "gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt--debye_6 :: Double -> Double-debye_6 = gsl_sf_debye_6-foreign import ccall "gsl_sf_debye_6" gsl_sf_debye_6 :: Double -> Double

@@ -1,42 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Dilog--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_dilog.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Dilog(-  dilog_e-, dilog-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--dilog_e :: Double -> (Double,Double)-dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x-foreign import ccall "gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt--dilog :: Double -> Double-dilog = gsl_sf_dilog-foreign import ccall "gsl_sf_dilog" gsl_sf_dilog :: Double -> Double--complex_dilog_xy_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re-foreign import ccall "gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--complex_dilog_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re-foreign import ccall "gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--complex_spence_xy_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp-foreign import ccall "gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt

@@ -1,35 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Elementary--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_elementary.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Elementary(-  multiply_e-, multiply-, multiply_err_e-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--multiply_e :: Double -> Double -> (Double,Double)-multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y-foreign import ccall "gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt--multiply :: Double -> Double -> Double-multiply = gsl_sf_multiply-foreign import ccall "gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double--multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double)-multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy-foreign import ccall "gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt

@@ -1,140 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Ellint--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_ellint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Ellint(-  ellint_Kcomp_e-, ellint_Kcomp-, ellint_Ecomp_e-, ellint_Ecomp-, ellint_Pcomp_e-, ellint_Pcomp-, ellint_Dcomp_e-, ellint_Dcomp-, ellint_F_e-, ellint_F-, ellint_E_e-, ellint_E-, ellint_P_e-, ellint_P-, ellint_D_e-, ellint_D-, ellint_RC_e-, ellint_RC-, ellint_RD_e-, ellint_RD-, ellint_RF_e-, ellint_RF-, ellint_RJ_e-, ellint_RJ-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--ellint_Kcomp_e :: Double -> Precision -> (Double,Double)-ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_Kcomp :: Double -> Precision -> Double-ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double--ellint_Ecomp_e :: Double -> Precision -> (Double,Double)-ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_Ecomp :: Double -> Precision -> Double-ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double--ellint_Pcomp_e :: Double -> Double -> Precision -> (Double,Double)-ellint_Pcomp_e k n mode = createSFR "ellint_Pcomp_e" $ gsl_sf_ellint_Pcomp_e k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_Pcomp :: Double -> Double -> Precision -> Double-ellint_Pcomp k n mode = gsl_sf_ellint_Pcomp k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double--ellint_Dcomp_e :: Double -> Precision -> (Double,Double)-ellint_Dcomp_e k mode = createSFR "ellint_Dcomp_e" $ gsl_sf_ellint_Dcomp_e k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_Dcomp :: Double -> Precision -> Double-ellint_Dcomp k mode = gsl_sf_ellint_Dcomp k  (precCode mode)-foreign import ccall "gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double--ellint_F_e :: Double -> Double -> Precision -> (Double,Double)-ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k  (precCode mode)-foreign import ccall "gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_F :: Double -> Double -> Precision -> Double-ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)-foreign import ccall "gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double--ellint_E_e :: Double -> Double -> Precision -> (Double,Double)-ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k  (precCode mode)-foreign import ccall "gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_E :: Double -> Double -> Precision -> Double-ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)-foreign import ccall "gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double--ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double)-ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_P :: Double -> Double -> Double -> Precision -> Double-ellint_P phi k n mode = gsl_sf_ellint_P phi k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double--ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double)-ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_D :: Double -> Double -> Double -> Precision -> Double-ellint_D phi k n mode = gsl_sf_ellint_D phi k n  (precCode mode)-foreign import ccall "gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double--ellint_RC_e :: Double -> Double -> Precision -> (Double,Double)-ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y  (precCode mode)-foreign import ccall "gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_RC :: Double -> Double -> Precision -> Double-ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)-foreign import ccall "gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double--ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double)-ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z  (precCode mode)-foreign import ccall "gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_RD :: Double -> Double -> Double -> Precision -> Double-ellint_RD x y z mode = gsl_sf_ellint_RD x y z  (precCode mode)-foreign import ccall "gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double--ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double)-ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z  (precCode mode)-foreign import ccall "gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_RF :: Double -> Double -> Double -> Precision -> Double-ellint_RF x y z mode = gsl_sf_ellint_RF x y z  (precCode mode)-foreign import ccall "gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double--ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double)-ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p  (precCode mode)-foreign import ccall "gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt--ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double-ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p  (precCode mode)-foreign import ccall "gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double

@@ -1,38 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Elljac--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_elljac.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Elljac(-elljac_e-) where--import Foreign-import Foreign.C.Types(CInt)--elljac_e :: Double -> Double -> (Double,Double,Double)-elljac_e u m = unsafePerformIO $ do-    psn <- malloc-    pcn <- malloc-    pdn <- malloc-    res <- gsl_sf_elljac_e u m psn pcn pdn-    sn <- peek psn-    cn <- peek pcn-    dn <- peek pdn-    free psn-    free pcn-    free pdn-    if res == 0 then return (sn,cn,dn)-                else error $ "error code "++show res++-                             " in elljac_e "++show u++" "++show m--foreign import ccall "gsl_sf_elljac_e" gsl_sf_elljac_e :: Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO CInt

@@ -1,80 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Erf--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_erf.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Erf(-  erfc_e-, erfc-, log_erfc_e-, log_erfc-, erf_e-, erf-, erf_Z_e-, erf_Q_e-, erf_Z-, erf_Q-, hazard_e-, hazard-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--erfc_e :: Double -> (Double,Double)-erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x-foreign import ccall "gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt--erfc :: Double -> Double-erfc = gsl_sf_erfc-foreign import ccall "gsl_sf_erfc" gsl_sf_erfc :: Double -> Double--log_erfc_e :: Double -> (Double,Double)-log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x-foreign import ccall "gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt--log_erfc :: Double -> Double-log_erfc = gsl_sf_log_erfc-foreign import ccall "gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double--erf_e :: Double -> (Double,Double)-erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x-foreign import ccall "gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt--erf :: Double -> Double-erf = gsl_sf_erf-foreign import ccall "gsl_sf_erf" gsl_sf_erf :: Double -> Double--erf_Z_e :: Double -> (Double,Double)-erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x-foreign import ccall "gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt--erf_Q_e :: Double -> (Double,Double)-erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x-foreign import ccall "gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt--erf_Z :: Double -> Double-erf_Z = gsl_sf_erf_Z-foreign import ccall "gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double--erf_Q :: Double -> Double-erf_Q = gsl_sf_erf_Q-foreign import ccall "gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double--hazard_e :: Double -> (Double,Double)-hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x-foreign import ccall "gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt--hazard :: Double -> Double-hazard = gsl_sf_hazard-foreign import ccall "gsl_sf_hazard" gsl_sf_hazard :: Double -> Double

@@ -1,115 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Exp--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_exp.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Exp(-  exp_e-, Numeric.GSL.Special.Exp.exp-, exp_e10_e-, exp_mult_e-, exp_mult-, exp_mult_e10_e-, expm1_e-, expm1-, exprel_e-, exprel-, exprel_2_e-, exprel_2-, exprel_n_e-, exprel_n--- , exprel_n_CF_e-, exp_err_e-, exp_err_e10_e-, exp_mult_err_e-, exp_mult_err_e10_e-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--exp_e :: Double -> (Double,Double)-exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x-foreign import ccall "gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt--exp :: Double -> Double-exp = gsl_sf_exp-foreign import ccall "gsl_sf_exp" gsl_sf_exp :: Double -> Double--exp_e10_e :: Double -> (Double,Int,Double)-exp_e10_e x = createSFR_E10 "exp_e10_e" $ gsl_sf_exp_e10_e x-foreign import ccall "gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt--exp_mult_e :: Double -> Double -> (Double,Double)-exp_mult_e x y = createSFR "exp_mult_e" $ gsl_sf_exp_mult_e x y-foreign import ccall "gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt--exp_mult :: Double -> Double -> Double-exp_mult = gsl_sf_exp_mult-foreign import ccall "gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double--exp_mult_e10_e :: Double -> Double -> (Double,Int,Double)-exp_mult_e10_e x y = createSFR_E10 "exp_mult_e10_e" $ gsl_sf_exp_mult_e10_e x y-foreign import ccall "gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt--expm1_e :: Double -> (Double,Double)-expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x-foreign import ccall "gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt--expm1 :: Double -> Double-expm1 = gsl_sf_expm1-foreign import ccall "gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double--exprel_e :: Double -> (Double,Double)-exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x-foreign import ccall "gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt--exprel :: Double -> Double-exprel = gsl_sf_exprel-foreign import ccall "gsl_sf_exprel" gsl_sf_exprel :: Double -> Double--exprel_2_e :: Double -> (Double,Double)-exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x-foreign import ccall "gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt--exprel_2 :: Double -> Double-exprel_2 = gsl_sf_exprel_2-foreign import ccall "gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double--exprel_n_e :: CInt -> Double -> (Double,Double)-exprel_n_e n x = createSFR "exprel_n_e" $ gsl_sf_exprel_n_e n x-foreign import ccall "gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt--exprel_n :: CInt -> Double -> Double-exprel_n = gsl_sf_exprel_n-foreign import ccall "gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double--exprel_n_CF_e :: Double -> Double -> (Double,Double)-exprel_n_CF_e n x = createSFR "exprel_n_CF_e" $ gsl_sf_exprel_n_CF_e n x-foreign import ccall "gsl_sf_exprel_n_CF_e" gsl_sf_exprel_n_CF_e :: Double -> Double -> Ptr () -> IO CInt--exp_err_e :: Double -> Double -> (Double,Double)-exp_err_e x dx = createSFR "exp_err_e" $ gsl_sf_exp_err_e x dx-foreign import ccall "gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt--exp_err_e10_e :: Double -> Double -> (Double,Int,Double)-exp_err_e10_e x dx = createSFR_E10 "exp_err_e10_e" $ gsl_sf_exp_err_e10_e x dx-foreign import ccall "gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt--exp_mult_err_e :: Double -> Double -> Double -> Double -> (Double,Double)-exp_mult_err_e x dx y dy = createSFR "exp_mult_err_e" $ gsl_sf_exp_mult_err_e x dx y dy-foreign import ccall "gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt--exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> (Double,Int,Double)-exp_mult_err_e10_e x dx y dy = createSFR_E10 "exp_mult_err_e10_e" $ gsl_sf_exp_mult_err_e10_e x dx y dy-foreign import ccall "gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt

@@ -1,160 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Expint--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_expint.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Expint(-  expint_E1_e-, expint_E1-, expint_E2_e-, expint_E2-, expint_En_e-, expint_En-, expint_E1_scaled_e-, expint_E1_scaled-, expint_E2_scaled_e-, expint_E2_scaled-, expint_En_scaled_e-, expint_En_scaled-, expint_Ei_e-, expint_Ei-, expint_Ei_scaled_e-, expint_Ei_scaled-, shi_e-, shi-, chi_e-, chi-, expint_3_e-, expint_3-, si_e-, si-, ci_e-, ci-, atanint_e-, atanint-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--expint_E1_e :: Double -> (Double,Double)-expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x-foreign import ccall "gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt--expint_E1 :: Double -> Double-expint_E1 = gsl_sf_expint_E1-foreign import ccall "gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double--expint_E2_e :: Double -> (Double,Double)-expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x-foreign import ccall "gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt--expint_E2 :: Double -> Double-expint_E2 = gsl_sf_expint_E2-foreign import ccall "gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double--expint_En_e :: CInt -> Double -> (Double,Double)-expint_En_e n x = createSFR "expint_En_e" $ gsl_sf_expint_En_e n x-foreign import ccall "gsl_sf_expint_En_e" gsl_sf_expint_En_e :: CInt -> Double -> Ptr () -> IO CInt--expint_En :: CInt -> Double -> Double-expint_En = gsl_sf_expint_En-foreign import ccall "gsl_sf_expint_En" gsl_sf_expint_En :: CInt -> Double -> Double--expint_E1_scaled_e :: Double -> (Double,Double)-expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x-foreign import ccall "gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt--expint_E1_scaled :: Double -> Double-expint_E1_scaled = gsl_sf_expint_E1_scaled-foreign import ccall "gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double--expint_E2_scaled_e :: Double -> (Double,Double)-expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x-foreign import ccall "gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt--expint_E2_scaled :: Double -> Double-expint_E2_scaled = gsl_sf_expint_E2_scaled-foreign import ccall "gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double--expint_En_scaled_e :: CInt -> Double -> (Double,Double)-expint_En_scaled_e n x = createSFR "expint_En_scaled_e" $ gsl_sf_expint_En_scaled_e n x-foreign import ccall "gsl_sf_expint_En_scaled_e" gsl_sf_expint_En_scaled_e :: CInt -> Double -> Ptr () -> IO CInt--expint_En_scaled :: CInt -> Double -> Double-expint_En_scaled = gsl_sf_expint_En_scaled-foreign import ccall "gsl_sf_expint_En_scaled" gsl_sf_expint_En_scaled :: CInt -> Double -> Double--expint_Ei_e :: Double -> (Double,Double)-expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x-foreign import ccall "gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt--expint_Ei :: Double -> Double-expint_Ei = gsl_sf_expint_Ei-foreign import ccall "gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double--expint_Ei_scaled_e :: Double -> (Double,Double)-expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x-foreign import ccall "gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt--expint_Ei_scaled :: Double -> Double-expint_Ei_scaled = gsl_sf_expint_Ei_scaled-foreign import ccall "gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double--shi_e :: Double -> (Double,Double)-shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x-foreign import ccall "gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt--shi :: Double -> Double-shi = gsl_sf_Shi-foreign import ccall "gsl_sf_Shi" gsl_sf_Shi :: Double -> Double--chi_e :: Double -> (Double,Double)-chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x-foreign import ccall "gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt--chi :: Double -> Double-chi = gsl_sf_Chi-foreign import ccall "gsl_sf_Chi" gsl_sf_Chi :: Double -> Double--expint_3_e :: Double -> (Double,Double)-expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x-foreign import ccall "gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt--expint_3 :: Double -> Double-expint_3 = gsl_sf_expint_3-foreign import ccall "gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double--si_e :: Double -> (Double,Double)-si_e x = createSFR "si_e" $ gsl_sf_Si_e x-foreign import ccall "gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt--si :: Double -> Double-si = gsl_sf_Si-foreign import ccall "gsl_sf_Si" gsl_sf_Si :: Double -> Double--ci_e :: Double -> (Double,Double)-ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x-foreign import ccall "gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt--ci :: Double -> Double-ci = gsl_sf_Ci-foreign import ccall "gsl_sf_Ci" gsl_sf_Ci :: Double -> Double--atanint_e :: Double -> (Double,Double)-atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x-foreign import ccall "gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt--atanint :: Double -> Double-atanint = gsl_sf_atanint-foreign import ccall "gsl_sf_atanint" gsl_sf_atanint :: Double -> Double

@@ -1,110 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Fermi_dirac--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_fermi_dirac.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Fermi_dirac(-  fermi_dirac_m1_e-, fermi_dirac_m1-, fermi_dirac_0_e-, fermi_dirac_0-, fermi_dirac_1_e-, fermi_dirac_1-, fermi_dirac_2_e-, fermi_dirac_2-, fermi_dirac_int_e-, fermi_dirac_int-, fermi_dirac_mhalf_e-, fermi_dirac_mhalf-, fermi_dirac_half_e-, fermi_dirac_half-, fermi_dirac_3half_e-, fermi_dirac_3half-, fermi_dirac_inc_0_e-, fermi_dirac_inc_0-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--fermi_dirac_m1_e :: Double -> (Double,Double)-fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x-foreign import ccall "gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt--fermi_dirac_m1 :: Double -> Double-fermi_dirac_m1 = gsl_sf_fermi_dirac_m1-foreign import ccall "gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double--fermi_dirac_0_e :: Double -> (Double,Double)-fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x-foreign import ccall "gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt--fermi_dirac_0 :: Double -> Double-fermi_dirac_0 = gsl_sf_fermi_dirac_0-foreign import ccall "gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double--fermi_dirac_1_e :: Double -> (Double,Double)-fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x-foreign import ccall "gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt--fermi_dirac_1 :: Double -> Double-fermi_dirac_1 = gsl_sf_fermi_dirac_1-foreign import ccall "gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double--fermi_dirac_2_e :: Double -> (Double,Double)-fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x-foreign import ccall "gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt--fermi_dirac_2 :: Double -> Double-fermi_dirac_2 = gsl_sf_fermi_dirac_2-foreign import ccall "gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double--fermi_dirac_int_e :: CInt -> Double -> (Double,Double)-fermi_dirac_int_e j x = createSFR "fermi_dirac_int_e" $ gsl_sf_fermi_dirac_int_e j x-foreign import ccall "gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt--fermi_dirac_int :: CInt -> Double -> Double-fermi_dirac_int = gsl_sf_fermi_dirac_int-foreign import ccall "gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double--fermi_dirac_mhalf_e :: Double -> (Double,Double)-fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x-foreign import ccall "gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt--fermi_dirac_mhalf :: Double -> Double-fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf-foreign import ccall "gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double--fermi_dirac_half_e :: Double -> (Double,Double)-fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x-foreign import ccall "gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt--fermi_dirac_half :: Double -> Double-fermi_dirac_half = gsl_sf_fermi_dirac_half-foreign import ccall "gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double--fermi_dirac_3half_e :: Double -> (Double,Double)-fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x-foreign import ccall "gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt--fermi_dirac_3half :: Double -> Double-fermi_dirac_3half = gsl_sf_fermi_dirac_3half-foreign import ccall "gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double--fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double)-fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b-foreign import ccall "gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt--fermi_dirac_inc_0 :: Double -> Double -> Double-fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0-foreign import ccall "gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double

@@ -1,236 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Gamma--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_gamma.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Gamma(-  lngamma_e-, lngamma-, gamma_e-, gamma-, gammastar_e-, gammastar-, gammainv_e-, gammainv-, taylorcoeff_e-, taylorcoeff-, fact_e-, fact-, doublefact_e-, doublefact-, lnfact_e-, lnfact-, lndoublefact_e-, lndoublefact-, lnchoose_e-, lnchoose-, choose_e-, choose-, lnpoch_e-, lnpoch-, poch_e-, poch-, pochrel_e-, pochrel-, gamma_inc_Q_e-, gamma_inc_Q-, gamma_inc_P_e-, gamma_inc_P-, gamma_inc_e-, gamma_inc-, lnbeta_e-, lnbeta-, beta_e-, beta-, beta_inc_e-, beta_inc-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--lngamma_e :: Double -> (Double,Double)-lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x-foreign import ccall "gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt--lngamma :: Double -> Double-lngamma = gsl_sf_lngamma-foreign import ccall "gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double--lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt-lngamma_sgn_e = gsl_sf_lngamma_sgn_e-foreign import ccall "gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt--gamma_e :: Double -> (Double,Double)-gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x-foreign import ccall "gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt--gamma :: Double -> Double-gamma = gsl_sf_gamma-foreign import ccall "gsl_sf_gamma" gsl_sf_gamma :: Double -> Double--gammastar_e :: Double -> (Double,Double)-gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x-foreign import ccall "gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt--gammastar :: Double -> Double-gammastar = gsl_sf_gammastar-foreign import ccall "gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double--gammainv_e :: Double -> (Double,Double)-gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x-foreign import ccall "gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt--gammainv :: Double -> Double-gammainv = gsl_sf_gammainv-foreign import ccall "gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double--lngamma_complex_e :: Double -> Double -> Ptr () -> (Double,Double)-lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr-foreign import ccall "gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--taylorcoeff_e :: CInt -> Double -> (Double,Double)-taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x-foreign import ccall "gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt--taylorcoeff :: CInt -> Double -> Double-taylorcoeff = gsl_sf_taylorcoeff-foreign import ccall "gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double--fact_e :: CInt -> (Double,Double)-fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n-foreign import ccall "gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt--fact :: CInt -> Double-fact = gsl_sf_fact-foreign import ccall "gsl_sf_fact" gsl_sf_fact :: CInt -> Double--doublefact_e :: CInt -> (Double,Double)-doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n-foreign import ccall "gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt--doublefact :: CInt -> Double-doublefact = gsl_sf_doublefact-foreign import ccall "gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double--lnfact_e :: CInt -> (Double,Double)-lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n-foreign import ccall "gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt--lnfact :: CInt -> Double-lnfact = gsl_sf_lnfact-foreign import ccall "gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double--lndoublefact_e :: CInt -> (Double,Double)-lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n-foreign import ccall "gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt--lndoublefact :: CInt -> Double-lndoublefact = gsl_sf_lndoublefact-foreign import ccall "gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double--lnchoose_e :: CInt -> CInt -> (Double,Double)-lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m-foreign import ccall "gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt--lnchoose :: CInt -> CInt -> Double-lnchoose = gsl_sf_lnchoose-foreign import ccall "gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double--choose_e :: CInt -> CInt -> (Double,Double)-choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m-foreign import ccall "gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt--choose :: CInt -> CInt -> Double-choose = gsl_sf_choose-foreign import ccall "gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double--lnpoch_e :: Double -> Double -> (Double,Double)-lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x-foreign import ccall "gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt--lnpoch :: Double -> Double -> Double-lnpoch = gsl_sf_lnpoch-foreign import ccall "gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double--lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt-lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e-foreign import ccall "gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt--poch_e :: Double -> Double -> (Double,Double)-poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x-foreign import ccall "gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt--poch :: Double -> Double -> Double-poch = gsl_sf_poch-foreign import ccall "gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double--pochrel_e :: Double -> Double -> (Double,Double)-pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x-foreign import ccall "gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt--pochrel :: Double -> Double -> Double-pochrel = gsl_sf_pochrel-foreign import ccall "gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double--gamma_inc_Q_e :: Double -> Double -> (Double,Double)-gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x-foreign import ccall "gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt--gamma_inc_Q :: Double -> Double -> Double-gamma_inc_Q = gsl_sf_gamma_inc_Q-foreign import ccall "gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double--gamma_inc_P_e :: Double -> Double -> (Double,Double)-gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x-foreign import ccall "gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt--gamma_inc_P :: Double -> Double -> Double-gamma_inc_P = gsl_sf_gamma_inc_P-foreign import ccall "gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double--gamma_inc_e :: Double -> Double -> (Double,Double)-gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x-foreign import ccall "gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt--gamma_inc :: Double -> Double -> Double-gamma_inc = gsl_sf_gamma_inc-foreign import ccall "gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double--lnbeta_e :: Double -> Double -> (Double,Double)-lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b-foreign import ccall "gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt--lnbeta :: Double -> Double -> Double-lnbeta = gsl_sf_lnbeta-foreign import ccall "gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double--lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt-lnbeta_sgn_e = gsl_sf_lnbeta_sgn_e-foreign import ccall "gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt--beta_e :: Double -> Double -> (Double,Double)-beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b-foreign import ccall "gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt--beta :: Double -> Double -> Double-beta = gsl_sf_beta-foreign import ccall "gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double--beta_inc_e :: Double -> Double -> Double -> (Double,Double)-beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x-foreign import ccall "gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt--beta_inc :: Double -> Double -> Double -> Double-beta_inc = gsl_sf_beta_inc-foreign import ccall "gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double

@@ -1,64 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Gegenbauer--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_gegenbauer.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Gegenbauer(-  gegenpoly_1_e-, gegenpoly_2_e-, gegenpoly_3_e-, gegenpoly_1-, gegenpoly_2-, gegenpoly_3-, gegenpoly_n_e-, gegenpoly_n-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--gegenpoly_1_e :: Double -> Double -> (Double,Double)-gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x-foreign import ccall "gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt--gegenpoly_2_e :: Double -> Double -> (Double,Double)-gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x-foreign import ccall "gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt--gegenpoly_3_e :: Double -> Double -> (Double,Double)-gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x-foreign import ccall "gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt--gegenpoly_1 :: Double -> Double -> Double-gegenpoly_1 = gsl_sf_gegenpoly_1-foreign import ccall "gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double--gegenpoly_2 :: Double -> Double -> Double-gegenpoly_2 = gsl_sf_gegenpoly_2-foreign import ccall "gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double--gegenpoly_3 :: Double -> Double -> Double-gegenpoly_3 = gsl_sf_gegenpoly_3-foreign import ccall "gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double--gegenpoly_n_e :: CInt -> Double -> Double -> (Double,Double)-gegenpoly_n_e n lambda x = createSFR "gegenpoly_n_e" $ gsl_sf_gegenpoly_n_e n lambda x-foreign import ccall "gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt--gegenpoly_n :: CInt -> Double -> Double -> Double-gegenpoly_n = gsl_sf_gegenpoly_n-foreign import ccall "gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double--gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt-gegenpoly_array = gsl_sf_gegenpoly_array-foreign import ccall "gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt

@@ -1,130 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Hyperg--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_hyperg.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Hyperg(-  hyperg_0F1_e-, hyperg_0F1-, hyperg_1F1_int_e-, hyperg_1F1_int-, hyperg_1F1_e-, hyperg_1F1-, hyperg_U_int_e-, hyperg_U_int-, hyperg_U_int_e10_e-, hyperg_U_e-, hyperg_U-, hyperg_U_e10_e-, hyperg_2F1_e-, hyperg_2F1-, hyperg_2F1_conj_e-, hyperg_2F1_conj-, hyperg_2F1_renorm_e-, hyperg_2F1_renorm-, hyperg_2F1_conj_renorm_e-, hyperg_2F1_conj_renorm-, hyperg_2F0_e-, hyperg_2F0-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--hyperg_0F1_e :: Double -> Double -> (Double,Double)-hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x-foreign import ccall "gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt--hyperg_0F1 :: Double -> Double -> Double-hyperg_0F1 = gsl_sf_hyperg_0F1-foreign import ccall "gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double--hyperg_1F1_int_e :: CInt -> CInt -> Double -> (Double,Double)-hyperg_1F1_int_e m n x = createSFR "hyperg_1F1_int_e" $ gsl_sf_hyperg_1F1_int_e m n x-foreign import ccall "gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt--hyperg_1F1_int :: CInt -> CInt -> Double -> Double-hyperg_1F1_int = gsl_sf_hyperg_1F1_int-foreign import ccall "gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double--hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double)-hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x-foreign import ccall "gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_1F1 :: Double -> Double -> Double -> Double-hyperg_1F1 = gsl_sf_hyperg_1F1-foreign import ccall "gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double--hyperg_U_int_e :: CInt -> CInt -> Double -> (Double,Double)-hyperg_U_int_e m n x = createSFR "hyperg_U_int_e" $ gsl_sf_hyperg_U_int_e m n x-foreign import ccall "gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt--hyperg_U_int :: CInt -> CInt -> Double -> Double-hyperg_U_int = gsl_sf_hyperg_U_int-foreign import ccall "gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double--hyperg_U_int_e10_e :: CInt -> CInt -> Double -> (Double,Int,Double)-hyperg_U_int_e10_e m n x = createSFR_E10 "hyperg_U_int_e10_e" $ gsl_sf_hyperg_U_int_e10_e m n x-foreign import ccall "gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt--hyperg_U_e :: Double -> Double -> Double -> (Double,Double)-hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x-foreign import ccall "gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_U :: Double -> Double -> Double -> Double-hyperg_U = gsl_sf_hyperg_U-foreign import ccall "gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double--hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double)-hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x-foreign import ccall "gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double)-hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x-foreign import ccall "gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F1 :: Double -> Double -> Double -> Double -> Double-hyperg_2F1 = gsl_sf_hyperg_2F1-foreign import ccall "gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double--hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double)-hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x-foreign import ccall "gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double-hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj-foreign import ccall "gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double--hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)-hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x-foreign import ccall "gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double-hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm-foreign import ccall "gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double--hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)-hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x-foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double-hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm-foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double--hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double)-hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x-foreign import ccall "gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt--hyperg_2F0 :: Double -> Double -> Double -> Double-hyperg_2F0 = gsl_sf_hyperg_2F0-foreign import ccall "gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double

@@ -1,102 +0,0 @@- {-# LANGUAGE ForeignFunctionInterface #-}-------------------------------------------------------------------------------{- |-Module      :  Numeric.GSL.Special.Internal-Copyright   :  (c) Alberto Ruiz 2007-License     :  GPL-style--Maintainer  :  Alberto Ruiz (aruiz at um dot es)-Stability   :  provisional-Portability :  uses ffi--Support for Special functions.--<http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html#Special-Functions>--}--------------------------------------------------------------------------------#include <gsl/gsl_sf_result.h>-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)--module Numeric.GSL.Special.Internal (-    createSFR,-    createSFR_E10,-    Precision(..),-    Gsl_mode_t,-    Size_t,-    precCode-)-where--import Foreign-import Data.Packed.Internal(check,(//))-import Foreign.C.Types(CSize,CInt)---data Precision = PrecDouble | PrecSingle | PrecApprox--precCode :: Precision -> Int-precCode PrecDouble = 0-precCode PrecSingle = 1-precCode PrecApprox = 2--type Gsl_mode_t = Int--type Size_t = CSize-------------------------------------------------------data Gsl_sf_result = SF Double Double-  deriving (Show)--instance Storable Gsl_sf_result where-  sizeOf _ = #size gsl_sf_result-  alignment _ = #alignment gsl_sf_result-  peek ptr = do-    val <- (#peek gsl_sf_result, val) ptr-    err <- (#peek gsl_sf_result, err) ptr-    return (SF val err)-  poke ptr (SF val err) = do-    (#poke gsl_sf_result, val) ptr val-    (#poke gsl_sf_result, err) ptr err---data Gsl_sf_result_e10 = SFE Double Double CInt-  deriving (Show)--instance Storable Gsl_sf_result_e10 where-  sizeOf _ = #size gsl_sf_result_e10-  alignment _ = #alignment gsl_sf_result_e10-  peek ptr = do-    val <- (#peek gsl_sf_result_e10, val) ptr-    err <- (#peek gsl_sf_result_e10, err) ptr-    e10 <- (#peek gsl_sf_result_e10, e10) ptr-    return (SFE val err e10)-  poke ptr (SFE val err e10) = do-    (#poke gsl_sf_result_e10, val) ptr val-    (#poke gsl_sf_result_e10, err) ptr err-    (#poke gsl_sf_result_e10, e10) ptr e10---------------------------------------------------------------------- | access to a sf_result-createSFR :: String -> (Ptr a -> IO CInt) -> (Double, Double)-createSFR s f = unsafePerformIO $ do-    p <- malloc :: IO (Ptr Gsl_sf_result)-    f (castPtr p) // check s-    SF val err <- peek p-    free p-    return (val,err)--------------------------------------------------------------------------- the sf_result_e10 contains two doubles and the exponent---- | access to sf_result_e10-createSFR_E10 :: String -> (Ptr a -> IO CInt) -> (Double, Int, Double)-createSFR_E10 s f = unsafePerformIO $ do-    p <- malloc :: IO (Ptr Gsl_sf_result_e10)-    f (castPtr p) // check s-    SFE val err expo  <- peek p-    free p-    return (val, fromIntegral expo,err)

@@ -1,60 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Laguerre--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_laguerre.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Laguerre(-  laguerre_1_e-, laguerre_2_e-, laguerre_3_e-, laguerre_1-, laguerre_2-, laguerre_3-, laguerre_n_e-, laguerre_n-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--laguerre_1_e :: Double -> Double -> (Double,Double)-laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x-foreign import ccall "gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt--laguerre_2_e :: Double -> Double -> (Double,Double)-laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x-foreign import ccall "gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt--laguerre_3_e :: Double -> Double -> (Double,Double)-laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x-foreign import ccall "gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt--laguerre_1 :: Double -> Double -> Double-laguerre_1 = gsl_sf_laguerre_1-foreign import ccall "gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double--laguerre_2 :: Double -> Double -> Double-laguerre_2 = gsl_sf_laguerre_2-foreign import ccall "gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double--laguerre_3 :: Double -> Double -> Double-laguerre_3 = gsl_sf_laguerre_3-foreign import ccall "gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double--laguerre_n_e :: CInt -> Double -> Double -> (Double,Double)-laguerre_n_e n a x = createSFR "laguerre_n_e" $ gsl_sf_laguerre_n_e n a x-foreign import ccall "gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt--laguerre_n :: CInt -> Double -> Double -> Double-laguerre_n = gsl_sf_laguerre_n-foreign import ccall "gsl_sf_laguerre_n" gsl_sf_laguerre_n :: CInt -> Double -> Double -> Double

@@ -1,40 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Lambert--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_lambert.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Lambert(-  lambert_W0_e-, lambert_W0-, lambert_Wm1_e-, lambert_Wm1-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--lambert_W0_e :: Double -> (Double,Double)-lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x-foreign import ccall "gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt--lambert_W0 :: Double -> Double-lambert_W0 = gsl_sf_lambert_W0-foreign import ccall "gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double--lambert_Wm1_e :: Double -> (Double,Double)-lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x-foreign import ccall "gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt--lambert_Wm1 :: Double -> Double-lambert_Wm1 = gsl_sf_lambert_Wm1-foreign import ccall "gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double

@@ -1,233 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Legendre--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_legendre.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Legendre(-  legendre_Pl_e-, legendre_Pl-, legendre_P1_e-, legendre_P2_e-, legendre_P3_e-, legendre_P1-, legendre_P2-, legendre_P3-, legendre_Q0_e-, legendre_Q0-, legendre_Q1_e-, legendre_Q1-, legendre_Ql_e-, legendre_Ql-, legendre_Plm_e-, legendre_Plm-, legendre_sphPlm_e-, legendre_sphPlm-, legendre_array_size-, conicalP_half_e-, conicalP_half-, conicalP_mhalf_e-, conicalP_mhalf-, conicalP_0_e-, conicalP_0-, conicalP_1_e-, conicalP_1-, conicalP_sph_reg_e-, conicalP_sph_reg-, conicalP_cyl_reg_e-, conicalP_cyl_reg-, legendre_H3d_0_e-, legendre_H3d_0-, legendre_H3d_1_e-, legendre_H3d_1-, legendre_H3d_e-, legendre_H3d-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--legendre_Pl_e :: CInt -> Double -> (Double,Double)-legendre_Pl_e l x = createSFR "legendre_Pl_e" $ gsl_sf_legendre_Pl_e l x-foreign import ccall "gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt--legendre_Pl :: CInt -> Double -> Double-legendre_Pl = gsl_sf_legendre_Pl-foreign import ccall "gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double--legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt-legendre_Pl_array = gsl_sf_legendre_Pl_array-foreign import ccall "gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt--legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt-legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array-foreign import ccall "gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt--legendre_P1_e :: Double -> (Double,Double)-legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x-foreign import ccall "gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt--legendre_P2_e :: Double -> (Double,Double)-legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x-foreign import ccall "gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt--legendre_P3_e :: Double -> (Double,Double)-legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x-foreign import ccall "gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt--legendre_P1 :: Double -> Double-legendre_P1 = gsl_sf_legendre_P1-foreign import ccall "gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double--legendre_P2 :: Double -> Double-legendre_P2 = gsl_sf_legendre_P2-foreign import ccall "gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double--legendre_P3 :: Double -> Double-legendre_P3 = gsl_sf_legendre_P3-foreign import ccall "gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double--legendre_Q0_e :: Double -> (Double,Double)-legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x-foreign import ccall "gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt--legendre_Q0 :: Double -> Double-legendre_Q0 = gsl_sf_legendre_Q0-foreign import ccall "gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double--legendre_Q1_e :: Double -> (Double,Double)-legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x-foreign import ccall "gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt--legendre_Q1 :: Double -> Double-legendre_Q1 = gsl_sf_legendre_Q1-foreign import ccall "gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double--legendre_Ql_e :: CInt -> Double -> (Double,Double)-legendre_Ql_e l x = createSFR "legendre_Ql_e" $ gsl_sf_legendre_Ql_e l x-foreign import ccall "gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt--legendre_Ql :: CInt -> Double -> Double-legendre_Ql = gsl_sf_legendre_Ql-foreign import ccall "gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double--legendre_Plm_e :: CInt -> CInt -> Double -> (Double,Double)-legendre_Plm_e l m x = createSFR "legendre_Plm_e" $ gsl_sf_legendre_Plm_e l m x-foreign import ccall "gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt--legendre_Plm :: CInt -> CInt -> Double -> Double-legendre_Plm = gsl_sf_legendre_Plm-foreign import ccall "gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double--legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-legendre_Plm_array = gsl_sf_legendre_Plm_array-foreign import ccall "gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt-legendre_Plm_deriv_array = gsl_sf_legendre_Plm_deriv_array-foreign import ccall "gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt--legendre_sphPlm_e :: CInt -> CInt -> Double -> (Double,Double)-legendre_sphPlm_e l m x = createSFR "legendre_sphPlm_e" $ gsl_sf_legendre_sphPlm_e l m x-foreign import ccall "gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt--legendre_sphPlm :: CInt -> CInt -> Double -> Double-legendre_sphPlm = gsl_sf_legendre_sphPlm-foreign import ccall "gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double--legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt-legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array-foreign import ccall "gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt--legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt-legendre_sphPlm_deriv_array = gsl_sf_legendre_sphPlm_deriv_array-foreign import ccall "gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt--legendre_array_size :: CInt -> CInt -> CInt-legendre_array_size = gsl_sf_legendre_array_size-foreign import ccall "gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt--conicalP_half_e :: Double -> Double -> (Double,Double)-conicalP_half_e lambda x = createSFR "conicalP_half_e" $ gsl_sf_conicalP_half_e lambda x-foreign import ccall "gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt--conicalP_half :: Double -> Double -> Double-conicalP_half = gsl_sf_conicalP_half-foreign import ccall "gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double--conicalP_mhalf_e :: Double -> Double -> (Double,Double)-conicalP_mhalf_e lambda x = createSFR "conicalP_mhalf_e" $ gsl_sf_conicalP_mhalf_e lambda x-foreign import ccall "gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt--conicalP_mhalf :: Double -> Double -> Double-conicalP_mhalf = gsl_sf_conicalP_mhalf-foreign import ccall "gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double--conicalP_0_e :: Double -> Double -> (Double,Double)-conicalP_0_e lambda x = createSFR "conicalP_0_e" $ gsl_sf_conicalP_0_e lambda x-foreign import ccall "gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt--conicalP_0 :: Double -> Double -> Double-conicalP_0 = gsl_sf_conicalP_0-foreign import ccall "gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double--conicalP_1_e :: Double -> Double -> (Double,Double)-conicalP_1_e lambda x = createSFR "conicalP_1_e" $ gsl_sf_conicalP_1_e lambda x-foreign import ccall "gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt--conicalP_1 :: Double -> Double -> Double-conicalP_1 = gsl_sf_conicalP_1-foreign import ccall "gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double--conicalP_sph_reg_e :: CInt -> Double -> Double -> (Double,Double)-conicalP_sph_reg_e l lambda x = createSFR "conicalP_sph_reg_e" $ gsl_sf_conicalP_sph_reg_e l lambda x-foreign import ccall "gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt--conicalP_sph_reg :: CInt -> Double -> Double -> Double-conicalP_sph_reg = gsl_sf_conicalP_sph_reg-foreign import ccall "gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double--conicalP_cyl_reg_e :: CInt -> Double -> Double -> (Double,Double)-conicalP_cyl_reg_e m lambda x = createSFR "conicalP_cyl_reg_e" $ gsl_sf_conicalP_cyl_reg_e m lambda x-foreign import ccall "gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt--conicalP_cyl_reg :: CInt -> Double -> Double -> Double-conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg-foreign import ccall "gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double--legendre_H3d_0_e :: Double -> Double -> (Double,Double)-legendre_H3d_0_e lambda eta = createSFR "legendre_H3d_0_e" $ gsl_sf_legendre_H3d_0_e lambda eta-foreign import ccall "gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt--legendre_H3d_0 :: Double -> Double -> Double-legendre_H3d_0 = gsl_sf_legendre_H3d_0-foreign import ccall "gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double--legendre_H3d_1_e :: Double -> Double -> (Double,Double)-legendre_H3d_1_e lambda eta = createSFR "legendre_H3d_1_e" $ gsl_sf_legendre_H3d_1_e lambda eta-foreign import ccall "gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt--legendre_H3d_1 :: Double -> Double -> Double-legendre_H3d_1 = gsl_sf_legendre_H3d_1-foreign import ccall "gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double--legendre_H3d_e :: CInt -> Double -> Double -> (Double,Double)-legendre_H3d_e l lambda eta = createSFR "legendre_H3d_e" $ gsl_sf_legendre_H3d_e l lambda eta-foreign import ccall "gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt--legendre_H3d :: CInt -> Double -> Double -> Double-legendre_H3d = gsl_sf_legendre_H3d-foreign import ccall "gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double--legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt-legendre_H3d_array = gsl_sf_legendre_H3d_array-foreign import ccall "gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt

@@ -1,64 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Log--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_log.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Log(-  log_e-, Numeric.GSL.Special.Log.log-, log_abs_e-, log_abs-, log_1plusx_e-, log_1plusx-, log_1plusx_mx_e-, log_1plusx_mx-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--log_e :: Double -> (Double,Double)-log_e x = createSFR "log_e" $ gsl_sf_log_e x-foreign import ccall "gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt--log :: Double -> Double-log = gsl_sf_log-foreign import ccall "gsl_sf_log" gsl_sf_log :: Double -> Double--log_abs_e :: Double -> (Double,Double)-log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x-foreign import ccall "gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt--log_abs :: Double -> Double-log_abs = gsl_sf_log_abs-foreign import ccall "gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double--complex_log_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_log_e zr zi lnr = createSFR "complex_log_e" $ gsl_sf_complex_log_e zr zi lnr-foreign import ccall "gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--log_1plusx_e :: Double -> (Double,Double)-log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x-foreign import ccall "gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt--log_1plusx :: Double -> Double-log_1plusx = gsl_sf_log_1plusx-foreign import ccall "gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double--log_1plusx_mx_e :: Double -> (Double,Double)-log_1plusx_mx_e x = createSFR "log_1plusx_mx_e" $ gsl_sf_log_1plusx_mx_e x-foreign import ccall "gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt--log_1plusx_mx :: Double -> Double-log_1plusx_mx = gsl_sf_log_1plusx_mx-foreign import ccall "gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double

@@ -1,30 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Pow_int--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_pow_int.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Pow_int(-  pow_int_e-, pow_int-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--pow_int_e :: Double -> CInt -> (Double,Double)-pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n-foreign import ccall "gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt--pow_int :: Double -> CInt -> Double-pow_int = gsl_sf_pow_int-foreign import ccall "gsl_sf_pow_int" gsl_sf_pow_int :: Double -> CInt -> Double

@@ -1,84 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Psi--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_psi.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Psi(-  psi_int_e-, psi_int-, psi_e-, psi-, psi_1piy_e-, psi_1piy-, psi_1_int_e-, psi_1_int-, psi_1_e-, psi_1-, psi_n_e-, psi_n-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--psi_int_e :: CInt -> (Double,Double)-psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n-foreign import ccall "gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt--psi_int :: CInt -> Double-psi_int = gsl_sf_psi_int-foreign import ccall "gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double--psi_e :: Double -> (Double,Double)-psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x-foreign import ccall "gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt--psi :: Double -> Double-psi = gsl_sf_psi-foreign import ccall "gsl_sf_psi" gsl_sf_psi :: Double -> Double--psi_1piy_e :: Double -> (Double,Double)-psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y-foreign import ccall "gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt--psi_1piy :: Double -> Double-psi_1piy = gsl_sf_psi_1piy-foreign import ccall "gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double--complex_psi_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_psi_e x y result_re = createSFR "complex_psi_e" $ gsl_sf_complex_psi_e x y result_re-foreign import ccall "gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--psi_1_int_e :: CInt -> (Double,Double)-psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n-foreign import ccall "gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt--psi_1_int :: CInt -> Double-psi_1_int = gsl_sf_psi_1_int-foreign import ccall "gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double--psi_1_e :: Double -> (Double,Double)-psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x-foreign import ccall "gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt--psi_1 :: Double -> Double-psi_1 = gsl_sf_psi_1-foreign import ccall "gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double--psi_n_e :: CInt -> Double -> (Double,Double)-psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x-foreign import ccall "gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt--psi_n :: CInt -> Double -> Double-psi_n = gsl_sf_psi_n-foreign import ccall "gsl_sf_psi_n" gsl_sf_psi_n :: CInt -> Double -> Double

@@ -1,40 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Synchrotron--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_synchrotron.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Synchrotron(-  synchrotron_1_e-, synchrotron_1-, synchrotron_2_e-, synchrotron_2-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--synchrotron_1_e :: Double -> (Double,Double)-synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x-foreign import ccall "gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt--synchrotron_1 :: Double -> Double-synchrotron_1 = gsl_sf_synchrotron_1-foreign import ccall "gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double--synchrotron_2_e :: Double -> (Double,Double)-synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x-foreign import ccall "gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt--synchrotron_2 :: Double -> Double-synchrotron_2 = gsl_sf_synchrotron_2-foreign import ccall "gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double

@@ -1,60 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Transport--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_transport.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Transport(-  transport_2_e-, transport_2-, transport_3_e-, transport_3-, transport_4_e-, transport_4-, transport_5_e-, transport_5-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--transport_2_e :: Double -> (Double,Double)-transport_2_e x = createSFR "transport_2_e" $ gsl_sf_transport_2_e x-foreign import ccall "gsl_sf_transport_2_e" gsl_sf_transport_2_e :: Double -> Ptr () -> IO CInt--transport_2 :: Double -> Double-transport_2 = gsl_sf_transport_2-foreign import ccall "gsl_sf_transport_2" gsl_sf_transport_2 :: Double -> Double--transport_3_e :: Double -> (Double,Double)-transport_3_e x = createSFR "transport_3_e" $ gsl_sf_transport_3_e x-foreign import ccall "gsl_sf_transport_3_e" gsl_sf_transport_3_e :: Double -> Ptr () -> IO CInt--transport_3 :: Double -> Double-transport_3 = gsl_sf_transport_3-foreign import ccall "gsl_sf_transport_3" gsl_sf_transport_3 :: Double -> Double--transport_4_e :: Double -> (Double,Double)-transport_4_e x = createSFR "transport_4_e" $ gsl_sf_transport_4_e x-foreign import ccall "gsl_sf_transport_4_e" gsl_sf_transport_4_e :: Double -> Ptr () -> IO CInt--transport_4 :: Double -> Double-transport_4 = gsl_sf_transport_4-foreign import ccall "gsl_sf_transport_4" gsl_sf_transport_4 :: Double -> Double--transport_5_e :: Double -> (Double,Double)-transport_5_e x = createSFR "transport_5_e" $ gsl_sf_transport_5_e x-foreign import ccall "gsl_sf_transport_5_e" gsl_sf_transport_5_e :: Double -> Ptr () -> IO CInt--transport_5 :: Double -> Double-transport_5 = gsl_sf_transport_5-foreign import ccall "gsl_sf_transport_5" gsl_sf_transport_5 :: Double -> Double

@@ -1,138 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Trig--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_trig.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Trig(-  sin_e-, Numeric.GSL.Special.Trig.sin-, cos_e-, Numeric.GSL.Special.Trig.cos-, hypot_e-, hypot-, sinc_e-, sinc-, lnsinh_e-, lnsinh-, lncosh_e-, lncosh-, sin_err_e-, cos_err_e-, angle_restrict_symm-, angle_restrict_pos-, angle_restrict_symm_err_e-, angle_restrict_pos_err_e-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--sin_e :: Double -> (Double,Double)-sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x-foreign import ccall "gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt--sin :: Double -> Double-sin = gsl_sf_sin-foreign import ccall "gsl_sf_sin" gsl_sf_sin :: Double -> Double--cos_e :: Double -> (Double,Double)-cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x-foreign import ccall "gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt--cos :: Double -> Double-cos = gsl_sf_cos-foreign import ccall "gsl_sf_cos" gsl_sf_cos :: Double -> Double--hypot_e :: Double -> Double -> (Double,Double)-hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y-foreign import ccall "gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt--hypot :: Double -> Double -> Double-hypot = gsl_sf_hypot-foreign import ccall "gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double--complex_sin_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_sin_e zr zi szr = createSFR "complex_sin_e" $ gsl_sf_complex_sin_e zr zi szr-foreign import ccall "gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--complex_cos_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_cos_e zr zi czr = createSFR "complex_cos_e" $ gsl_sf_complex_cos_e zr zi czr-foreign import ccall "gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--complex_logsin_e :: Double -> Double -> Ptr () -> (Double,Double)-complex_logsin_e zr zi lszr = createSFR "complex_logsin_e" $ gsl_sf_complex_logsin_e zr zi lszr-foreign import ccall "gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--sinc_e :: Double -> (Double,Double)-sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x-foreign import ccall "gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt--sinc :: Double -> Double-sinc = gsl_sf_sinc-foreign import ccall "gsl_sf_sinc" gsl_sf_sinc :: Double -> Double--lnsinh_e :: Double -> (Double,Double)-lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x-foreign import ccall "gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt--lnsinh :: Double -> Double-lnsinh = gsl_sf_lnsinh-foreign import ccall "gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double--lncosh_e :: Double -> (Double,Double)-lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x-foreign import ccall "gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt--lncosh :: Double -> Double-lncosh = gsl_sf_lncosh-foreign import ccall "gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double--polar_to_rect :: Double -> Double -> Ptr () -> (Double,Double)-polar_to_rect r theta x = createSFR "polar_to_rect" $ gsl_sf_polar_to_rect r theta x-foreign import ccall "gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--rect_to_polar :: Double -> Double -> Ptr () -> (Double,Double)-rect_to_polar x y r = createSFR "rect_to_polar" $ gsl_sf_rect_to_polar x y r-foreign import ccall "gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt--sin_err_e :: Double -> Double -> (Double,Double)-sin_err_e x dx = createSFR "sin_err_e" $ gsl_sf_sin_err_e x dx-foreign import ccall "gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt--cos_err_e :: Double -> Double -> (Double,Double)-cos_err_e x dx = createSFR "cos_err_e" $ gsl_sf_cos_err_e x dx-foreign import ccall "gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt--angle_restrict_symm_e :: Ptr Double -> CInt-angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e-foreign import ccall "gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt--angle_restrict_symm :: Double -> Double-angle_restrict_symm = gsl_sf_angle_restrict_symm-foreign import ccall "gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double--angle_restrict_pos_e :: Ptr Double -> CInt-angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e-foreign import ccall "gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt--angle_restrict_pos :: Double -> Double-angle_restrict_pos = gsl_sf_angle_restrict_pos-foreign import ccall "gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double--angle_restrict_symm_err_e :: Double -> (Double,Double)-angle_restrict_symm_err_e theta = createSFR "angle_restrict_symm_err_e" $ gsl_sf_angle_restrict_symm_err_e theta-foreign import ccall "gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt--angle_restrict_pos_err_e :: Double -> (Double,Double)-angle_restrict_pos_err_e theta = createSFR "angle_restrict_pos_err_e" $ gsl_sf_angle_restrict_pos_err_e theta-foreign import ccall "gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr () -> IO CInt

@@ -1,90 +0,0 @@---------------------------------------------------------------- |--- Module      :  Numeric.GSL.Special.Zeta--- Copyright   :  (c) Alberto Ruiz 2006--- License     :  GPL--- Maintainer  :  Alberto Ruiz (aruiz at um dot es)--- Stability   :  provisional--- Portability :  uses ffi------ Wrappers for selected functions described at:------ <http://www.google.com/search?q=gsl_sf_zeta.h&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>---------------------------------------------------------------module Numeric.GSL.Special.Zeta(-  zeta_int_e-, zeta_int-, zeta_e-, zeta-, zetam1_e-, zetam1-, zetam1_int_e-, zetam1_int-, hzeta_e-, hzeta-, eta_int_e-, eta_int-, eta_e-, eta-) where--import Foreign(Ptr)-import Foreign.C.Types(CInt)-import Numeric.GSL.Special.Internal--zeta_int_e :: CInt -> (Double,Double)-zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n-foreign import ccall "gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt--zeta_int :: CInt -> Double-zeta_int = gsl_sf_zeta_int-foreign import ccall "gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double--zeta_e :: Double -> (Double,Double)-zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s-foreign import ccall "gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt--zeta :: Double -> Double-zeta = gsl_sf_zeta-foreign import ccall "gsl_sf_zeta" gsl_sf_zeta :: Double -> Double--zetam1_e :: Double -> (Double,Double)-zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s-foreign import ccall "gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt--zetam1 :: Double -> Double-zetam1 = gsl_sf_zetam1-foreign import ccall "gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double--zetam1_int_e :: CInt -> (Double,Double)-zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s-foreign import ccall "gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt--zetam1_int :: CInt -> Double-zetam1_int = gsl_sf_zetam1_int-foreign import ccall "gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double--hzeta_e :: Double -> Double -> (Double,Double)-hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q-foreign import ccall "gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt--hzeta :: Double -> Double -> Double-hzeta = gsl_sf_hzeta-foreign import ccall "gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double--eta_int_e :: CInt -> (Double,Double)-eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n-foreign import ccall "gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt--eta_int :: CInt -> Double-eta_int = gsl_sf_eta_int-foreign import ccall "gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double--eta_e :: Double -> (Double,Double)-eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s-foreign import ccall "gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt--eta :: Double -> Double-eta = gsl_sf_eta-foreign import ccall "gsl_sf_eta" gsl_sf_eta :: Double -> Double

@@ -1,244 +0,0 @@-#!/usr/bin/env runhaskell---- automatic generation of wrappers for simple GSL special functions--import Text.ParserCombinators.Parsec-import System-import Data.List(intersperse, isPrefixOf)-import Data.Char(toUpper,isUpper,toLower)--data Type = Normal Ident | Pointer Ident deriving (Eq, Show)--type Ident = String--data Header = Header Type Ident [(Type,Ident)] deriving Show--headers f = case parse parseHeaders "" f of-    Right l -> l-    Left s -> error (show s)---rep (c,r) [] = []-rep (c,r) f@(x:xs) -  | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f)-  | otherwise        = x:(rep (c,r) xs)---fixlong [] = []-fixlong "\\" = []-fixlong ('\\':'\n':xs) = xs-fixlong (x:xs) = x : fixlong xs---safe (Header _ _ args) =  all ok args -                         || all ok (init args) && kn (last args)-    where ok ((Normal s),_) | s `elem` ["double","float","int","gsl_mode_t"] = True-          ok _ = False-          kn ((Pointer "gsl_sf_result"),_) = True-          kn ((Pointer "gsl_sf_result_e10"),_) = True-          kn _ = False----fixC s = rep ("gsl_mode_t","int") $ rep ("gsl_sf_result","double") $ rep ("gsl_sf_result_e10","double") $ s--main = do-    args <- getArgs-    let name = args!!0-        headerfile =-            case args of-                [n] -> "/usr/include/gsl/gsl_sf_"++n++".h"-                [_,f] -> f-    file <- readFile headerfile--    putStrLn headerfile-    --mapM_ print (headers $ fixlong file)-    let parsed = (headers $ fixlong file)-    -- writeFile (name ++".h") (fixC $ unlines $ map showC parsed) --    --putStrLn ""-    --mapM (\(Header _ n _) -> putStrLn (drop 7 n ++",")) parsed-    --putStrLn ""-    --mapM_ (putStrLn.showFull (name ++".h")) parsed-    let exports = rep (")",") where") $ rep ("(\n","(\n  ") $ rep (",\n",", ") $ unlines $ ["("]++intersperse "," (map (\(Header _ n _) -> hName n) (filter safe parsed))++[")"]-    let defs = unlines $ map (showFull (name ++".h")) parsed-    let imports = "\nimport Foreign(Ptr)\n"-                ++"import Foreign.C.Types(CInt)\n"-                ++"import Numeric.GSL.Special.Internal\n"-    let mod = modhead name ++ "module Numeric.GSL.Special."++ upperFirst name++exports++imports++defs-    writeFile (upperFirst name ++ ".hs") mod---     appendFile "funs.txt" $ rep ("(\n ","-- * "---                                      ++map toUpper name---                                 --   ++"\n"++google ( "gsl_sf_"++name++".h")++"\n"---                                      ++"\n,") $ rep (") where","") $ exports---google name = "<http://www.google.com/search?q="-               ++name-               ++"&as_sitesearch=www.gnu.org/software/gsl/manual&btnI=Lucky>"--modhead name = replicate 60 '-' ++ "\n-- |\n"-             ++"-- Module      :  Numeric.GSL.Special."++upperFirst name++"\n"-             ++"-- Copyright   :  (c) Alberto Ruiz 2006\n"-             ++"-- License     :  GPL\n"-             ++"-- Maintainer  :  Alberto Ruiz (aruiz at um dot es)\n"-             ++"-- Stability   :  provisional\n"-             ++"-- Portability :  uses ffi\n"-             ++"--\n"-             ++"-- Wrappers for selected functions described at:\n--\n-- "-             ++ google ( "gsl_sf_"++name++".h")++"\n"-             ++ replicate 60 '-' ++ "\n\n"--upperFirst (x:xs) = toUpper x : xs--comment = do-    string "/*"-    closecomment-    spaces-    return "comment"--closecomment = try (string "*/")-               <|> (do anyChar-                       closecomment)--ident = do -    spaces-    id <- many1 (noneOf "()[]* \n\t,;")-    spaces-    return id--comment' = between (char '(') (char ')') (many $ noneOf ")") ---define = do-    string "#"-    closedefine-    spaces-    return "define"--closedefine = try (string "\n")-              <|> (do anyChar-                      closedefine)--marks = do-    try (string "__BEGIN_DECLS" >> spaces >> return "begin")-    <|>-    try (string "__END_DECLS" >> spaces >> return "end")----irrelevant =-    try comment-    <|>-    try define-    <|>-    marks---parseHeaders = many parseHeader--parseHeader = do-    spaces-    many irrelevant-    spaces-    (res,name)  <- typ-    spaces-    args <- between (char '(') (char ')') (sepBy typ (char ','))-    spaces-    char ';'-    spaces-    many irrelevant-    return $ Header res name args--typ = try t1 <|> t2--symbol s = spaces >> string s >> spaces--t1 = do-    t <- try (symbol "const" >> symbol "unsigned" >> ident) -- aaagh -         <|>-         try (symbol "const" >> ident)-         <|>-         try (symbol "unsigned" >> ident)-         <|> ident-    n <- ident-    return (Normal t,n)--t2 = do-    t <- ident-    spaces-    char '*'-    spaces-    n <- ident-    return (Pointer t,n)--pure (Header _ _ args) | fst (last args) == Pointer "gsl_sf_result" = False-                       | fst (last args) == Pointer "gsl_sf_result_e10" = False-                       | otherwise = True--showC (Header t n args) = showCt t ++ " " ++ n ++ "("  ++ (concat $ intersperse "," $ map showCa args) ++ ");"--showCt (Normal s) = s-showCt (Pointer s) = s ++ "*"--showCa (t, a) = showCt t ++" "++ a--showH hc h@(Header t n args) = "foreign import ccall \""++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'-    where t' | pure h = showHt t-             | otherwise = "IO "++showHt t--ht "int" = "CInt"-ht (s:ss) = toUpper s : ss--showHt (Normal t) = ht t-showHt (Pointer "gsl_sf_result") = "Ptr ()"-showHt (Pointer "gsl_sf_result_e10") = "Ptr ()"-showHt (Pointer t) = "Ptr "++ht t--showHa (t,a) = showHt t--showFull hc h@(Header t n args) = -- "\n-- | wrapper for "++showC h-                                  --   ++"\n--\n--   "++google n ++"\n"++-                                  -- ++ "\n" ++-                                  "\n" ++ boiler h ++ -                                  "\n" ++ showH hc h--fixmd1 = rep ("Gsl_mode_t","Precision")-fixmd2 = rep ("mode"," (precCode mode)")--boiler h@(Header t n args) | fst (last args) == Pointer "gsl_sf_result" = boilerResult h-                           | fst (last args) == Pointer "gsl_sf_result_e10" = boilerResultE10 h-                           | any isMode args = boilerMode h-                           | otherwise = boilerBasic h--isMode (Normal "gsl_mode_t",_) = True-isMode _ = False--hName n = f $ drop 7 n-    where f (s:ss) = toLower s : ss---boilerResult h@(Header t n args) =-    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Double)\n" ++-     hName n ++ " "++ initArgs args ++-       " = createSFR \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)--boilerResultE10 h@(Header t n args) =-    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa (init args)) ++" -> " ++ "(Double,Int,Double)\n" ++-     hName n ++ " "++ initArgs args ++-       " = createSFR_E10 \""++ hName n ++"\" $ " ++ n ++ " "++ (fixmd2 $ initArgs args)--boilerBasic h@(Header t n args) = -    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$map showHa args) ++" -> " ++showHt t ++ "\n" ++-      hName n ++ " = " ++fixmd2 n--boilerMode h@(Header t n args) =-    hName n++" :: "++ (fixmd1 $ concat $ intersperse" -> "$ map showHa args) ++" -> " ++ showHt t++"\n" ++-     hName n ++ " "++ allArgs args ++-       " = " ++ n ++ " "++ (fixmd2 $ allArgs args)--cVar (v:vs) | isUpper v = toLower v : v : vs-            | otherwise = v:vs--allArgs args =  unwords (map (cVar.snd) args)-initArgs args = unwords (map (cVar.snd) (init args))

@@ -1,45 +0,0 @@-#!/bin/bash--function rep {-    ./replace.hs "$1" "$2" < $3 > /tmp/tmp-rep-    cp /tmp/tmp-rep $3-}--rm -f funs.txt--./auto.hs airy-rep ') where' ', Precision(..)\n) where' Airy.hs-./auto.hs bessel-./auto.hs clausen-./auto.hs coulomb-./auto.hs coupling-rep ', coupling_6j_INCORRECT_e\n, coupling_6j_INCORRECT\n' '' Coupling.hs-./auto.hs dawson-./auto.hs debye-./auto.hs dilog-./auto.hs elementary-./auto.hs ellint-#./auto.hs elljac-./auto.hs erf-./auto.hs exp-rep ', exp\n' ', Numeric.GSL.Special.Exp.exp\n' Exp.hs-rep ', exprel_n_CF_e' '-- , exprel_n_CF_e' Exp.hs-./auto.hs expint-./auto.hs fermi_dirac-./auto.hs gamma-./auto.hs gegenbauer-./auto.hs hyperg-./auto.hs laguerre-./auto.hs lambert-./auto.hs legendre-./auto.hs log-rep ', log\n' ', Numeric.GSL.Special.Log.log\n' Log.hs-#./auto.hs mathieu-./auto.hs pow_int-./auto.hs psi-./auto.hs synchrotron-./auto.hs transport-./auto.hs trig-rep ', sin\n' ', Numeric.GSL.Special.Trig.sin\n' Trig.hs-rep ', cos\n' ', Numeric.GSL.Special.Trig.cos\n' Trig.hs-./auto.hs zeta

@@ -1,14 +0,0 @@-#!/usr/bin/env runhaskell--import Data.List(isPrefixOf)-import System(getArgs)--rep (c,r) [] = []-rep (c,r) f@(x:xs) -  | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f)-  | otherwise        = x:(rep (c,r) xs)--main = do-    args <- getArgs-    let [p',r'] = map (rep ("\\n","\n")) args-    interact $ rep (p',r')

@@ -25,7 +25,7 @@ import Data.Packed.Internal.Signatures import Data.Packed.Internal.Vector -import Complex+import Data.Complex import Foreign import Foreign.C.Types(CInt) 

@@ -23,6 +23,7 @@ #include <gsl/gsl_rng.h> #include <gsl/gsl_randist.h> #include <gsl/gsl_odeiv.h>+#include <gsl/gsl_multifit_nlin.h> #include <string.h> #include <stdio.h> @@ -668,9 +669,10 @@  // working with the jacobian -typedef struct {int (*f)(int, double*, int, double *); int (*jf)(int, double*, int, int, double*);} Tfjf;+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) {+int f_aux(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));@@ -687,20 +689,20 @@     return 0; } -int jf_aux_root(const gsl_vector * x, void * pars, gsl_matrix * jac) {+int jf_aux(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));+    double* q = (double*)calloc((jac->size1)*(jac->size2),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);+    (fjf->jf)(x->size,p,jac->size1,jac->size2,q);      k=0;-    for(i=0;i<x->size;i++) {-        for(j=0;j<x->size;j++){+    for(i=0;i<jac->size1;i++) {+        for(j=0;j<jac->size2;j++){             gsl_matrix_set(jac,i,j,q[k++]);         }     }@@ -709,9 +711,9 @@     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);+int fjf_aux(const gsl_vector * x, void * pars, gsl_vector * f, gsl_matrix * g) {+    f_aux(x,pars,f);+    jf_aux(x,pars,g);     return 0; } @@ -723,9 +725,9 @@     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.f = f_aux;+    my_func.df = jf_aux;+    my_func.fdf = fjf_aux;     my_func.n = xin;     Tfjf stfjf;     stfjf.f = f;@@ -781,7 +783,77 @@     OK } +//-------------- non linear least squares fitting -------------------++int nlfit(int method, int f(int, double*, int, double*),+                      int jac(int, double*, int, int, double*),+         double epsabs, double epsrel, int maxit, int p,+         KRVEC(xi), RMAT(sol)) {+    REQUIRES(solr == maxit && solc == 2+xin,BAD_SIZE);+    DEBUGMSG("nlfit");+    const gsl_multifit_fdfsolver_type *T;+    gsl_multifit_fdfsolver *s;+    gsl_multifit_function_fdf my_f;+    // extract function from pars+    my_f.f = f_aux;+    my_f.df = jf_aux;+    my_f.fdf = fjf_aux;+    my_f.n = p;+    my_f.p = xin;  // !!!!+    Tfjf stfjf;+    stfjf.f = f;+    stfjf.jf = jac;+    my_f.params = &stfjf;+    size_t iter = 0;+    int status;++    KDVVIEW(xi);+    //DMVIEW(cov);++    switch(method) {+        case 0 : { T = gsl_multifit_fdfsolver_lmsder; break; }+        case 1 : { T = gsl_multifit_fdfsolver_lmder; break; }+        default: ERROR(BAD_CODE);+    }++    s = gsl_multifit_fdfsolver_alloc (T, my_f.n, my_f.p);+    gsl_multifit_fdfsolver_set (s, &my_f, V(xi));++    do {   status = gsl_multifit_fdfsolver_iterate (s);++           solp[iter*solc+0] = iter+1;+           solp[iter*solc+1] = gsl_blas_dnrm2 (s->f);++           int k;+           for(k=0;k<xin;k++) {+               solp[iter*solc+k+2] = gsl_vector_get(s->x,k);+           }++           iter++;+           if (status)   /* check if solver is stuck */+             break;++           status = gsl_multifit_test_delta (s->dx, s->x, epsabs, epsrel);+        }+        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_multifit_covar (s->J, 0.0, M(cov));++    gsl_multifit_fdfsolver_free (s);+    OK+}++ //////////////////////////////////////////////////////+  #define RAN(C,F) case C: { for(k=0;k<rn;k++) { rp[k]= F(gen); }; OK } 

@@ -8,23 +8,16 @@ Stability   :  provisional Portability :  uses ffi -Basic matrix computations implemented by BLAS, LAPACK and GSL.--This module reexports the most comon functions (including "Numeric.LinearAlgebra.Instances").+This module reexports all normally required functions for Linear Algebra applications.  -} ----------------------------------------------------------------------------- module Numeric.LinearAlgebra (     module Data.Packed,-    module Data.Packed.Random,-    module Numeric.LinearAlgebra.Linear,     module Numeric.LinearAlgebra.Algorithms,     module Numeric.LinearAlgebra.Interface ) where  import Data.Packed-import Data.Packed.Random-import Numeric.LinearAlgebra.Linear import Numeric.LinearAlgebra.Algorithms-import Numeric.LinearAlgebra.Instances() import Numeric.LinearAlgebra.Interface

@@ -27,6 +27,7 @@ -- * Linear Systems     linearSolve,     luSolve,+    cholSolve,     linearSolveLS,     linearSolveSVD,     inv, pinv,@@ -45,7 +46,7 @@ -- ** QR     qr, rq, -- ** Cholesky-    chol, cholSH,+    chol, cholSH, mbCholSH, -- ** Hessenberg     hess, -- ** Schur@@ -65,6 +66,7 @@ -- * Misc     ctrans,     eps, i,+    Linear(..), -- * Util     haussholder,     unpackQR, unpackHess,@@ -74,8 +76,10 @@ ) where  -import Data.Packed.Internal hiding (fromComplex, toComplex, conj, (//))-import Data.Packed+import Data.Packed.Internal hiding ((//))+import Data.Packed.Vector+import Data.Packed.Matrix+import Data.Complex import Numeric.GSL.Vector import Numeric.LinearAlgebra.LAPACK as LAPACK import Numeric.LinearAlgebra.Linear@@ -91,6 +95,7 @@     luPacked'    :: Matrix t -> (Matrix t, [Int])     luSolve'     :: (Matrix t, [Int]) -> Matrix t -> Matrix t     linearSolve' :: Matrix t -> Matrix t -> Matrix t+    cholSolve'   :: Matrix t -> Matrix t -> Matrix t     linearSolveSVD' :: Matrix t -> Matrix t -> Matrix t     linearSolveLS'  :: Matrix t -> Matrix t -> Matrix t     eig'         :: Matrix t -> (Vector (Complex Double), Matrix (Complex Double))@@ -98,6 +103,7 @@     eigOnly      :: Matrix t -> Vector (Complex Double)     eigOnlySH    :: Matrix t -> Vector Double     cholSH'      :: Matrix t -> Matrix t+    mbCholSH'    :: Matrix t -> Maybe (Matrix t)     qr'          :: Matrix t -> (Matrix t, Matrix t)     hess'        :: Matrix t -> (Matrix t, Matrix t)     schur'       :: Matrix t -> (Matrix t, Matrix t)@@ -112,6 +118,7 @@     luPacked' = luR     luSolve' (l_u,perm) = lusR l_u perm     linearSolve' = linearSolveR                 -- (luSolve . luPacked) ??+    cholSolve' = cholSolveR     linearSolveLS' = linearSolveLSR     linearSolveSVD' = linearSolveSVDR Nothing     ctrans' = trans@@ -120,18 +127,25 @@     eigOnly = eigOnlyR     eigOnlySH = eigOnlyS     cholSH' = cholS+    mbCholSH' = mbCholS     qr' = unpackQR . qrR     hess' = unpackHess hessR     schur' = schurR     multiply' = multiplyR  instance Field (Complex Double) where+#ifdef NOZGESDD+    svd' = svdC+    thinSVD' = thinSVDC+#else     svd' = svdCd     thinSVD' = thinSVDCd+#endif     sv' = svC     luPacked' = luC     luSolve' (l_u,perm) = lusC l_u perm     linearSolve' = linearSolveC+    cholSolve' = cholSolveC     linearSolveLS' = linearSolveLSC     linearSolveSVD' = linearSolveSVDC Nothing     ctrans' = conj . trans@@ -140,6 +154,7 @@     eigSH'' = eigH     eigOnlySH = eigOnlyH     cholSH' = cholH+    mbCholSH' = mbCholH     qr' = unpackQR . qrC     hess' = unpackHess hessC     schur' = schurC@@ -157,17 +172,17 @@  -- | Full singular value decomposition. svd :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)-svd = svd'+svd = {-# SCC "svd" #-} svd'  -- | A version of 'svd' which returns only the @min (rows m) (cols m)@ singular vectors of @m@. -- -- If @(u,s,v) = thinSVD m@ then @m == u \<> diag s \<> trans v@. thinSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)-thinSVD = thinSVD'+thinSVD = {-# SCC "thinSVD" #-} thinSVD'  -- | Singular values only. singularValues :: Field t => Matrix t -> Vector Double-singularValues = sv'+singularValues = {-# SCC "singularValues" #-} sv'  -- | A version of 'svd' which returns an appropriate diagonal matrix with the singular values. --@@ -217,46 +232,50 @@ --------------------------------------------------------------  -- | Obtains the LU decomposition of a matrix in a compact data structure suitable for 'luSolve'.-luPacked    :: Field t => Matrix t -> (Matrix t, [Int])-luPacked = luPacked'+luPacked :: Field t => Matrix t -> (Matrix t, [Int])+luPacked = {-# SCC "luPacked" #-} luPacked'  -- | Solution of a linear system (for several right hand sides) from the precomputed LU factorization obtained by 'luPacked'.-luSolve     :: Field t => (Matrix t, [Int]) -> Matrix t -> Matrix t-luSolve = luSolve'+luSolve :: Field t => (Matrix t, [Int]) -> Matrix t -> Matrix t+luSolve = {-# SCC "luSolve" #-} luSolve'  -- | Solve a linear system (for square coefficient matrix and several right-hand sides) using the LU decomposition. For underconstrained or overconstrained systems use 'linearSolveLS' or 'linearSolveSVD'. -- It is similar to 'luSolve' . 'luPacked', but @linearSolve@ raises an error if called on a singular system. linearSolve :: Field t => Matrix t -> Matrix t -> Matrix t-linearSolve = linearSolve'+linearSolve = {-# SCC "linearSolve" #-} linearSolve' +-- | Solve a symmetric or Hermitian positive definite linear system using a precomputed Cholesky decomposition obtained by 'chol'.+cholSolve :: Field t => Matrix t -> Matrix t -> Matrix t+cholSolve = {-# SCC "cholSolve" #-} cholSolve'+ -- | Minimum norm solution of a general linear least squares problem Ax=B using the SVD. Admits rank-deficient systems but it is slower than 'linearSolveLS'. The effective rank of A is determined by treating as zero those singular valures which are less than 'eps' times the largest singular value. linearSolveSVD :: Field t => Matrix t -> Matrix t -> Matrix t-linearSolveSVD = linearSolveSVD'+linearSolveSVD = {-# SCC "linearSolveSVD" #-} linearSolveSVD'   -- | Least squared error solution of an overconstrained linear system, or the minimum norm solution of an underconstrained system. For rank-deficient systems use 'linearSolveSVD'. linearSolveLS :: Field t => Matrix t -> Matrix t -> Matrix t-linearSolveLS = linearSolveLS'+linearSolveLS = {-# SCC "linearSolveLS" #-} linearSolveLS'  --------------------------------------------------------------  -- | Eigenvalues and eigenvectors of a general square matrix. -- -- If @(s,v) = eig m@ then @m \<> v == v \<> diag s@-eig         :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))-eig = eig'+eig :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))+eig = {-# SCC "eig" #-} eig'  -- | Eigenvalues of a general square matrix. eigenvalues :: Field t => Matrix t -> Vector (Complex Double)-eigenvalues = eigOnly+eigenvalues = {-# SCC "eigenvalues" #-} eigOnly --- | Similar to 'eigSH' without checking that the input matrix is hermitian or symmetric.-eigSH'      :: Field t => Matrix t -> (Vector Double, Matrix t)-eigSH' = eigSH''+-- | Similar to 'eigSH' without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part.+eigSH' :: Field t => Matrix t -> (Vector Double, Matrix t)+eigSH' = {-# SCC "eigSH'" #-} eigSH'' --- | Similar to 'eigenvaluesSH' without checking that the input matrix is hermitian or symmetric.+-- | Similar to 'eigenvaluesSH' without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part. eigenvaluesSH' :: Field t => Matrix t -> Vector Double-eigenvaluesSH' = eigOnlySH+eigenvaluesSH' = {-# SCC "eigenvaluesSH'" #-} eigOnlySH  -- | Eigenvalues and Eigenvectors of a complex hermitian or real symmetric matrix. --@@ -275,14 +294,14 @@ -- | QR factorization. -- -- If @(q,r) = qr m@ then @m == q \<> r@, where q is unitary and r is upper triangular.-qr          :: Field t => Matrix t -> (Matrix t, Matrix t)-qr = qr'+qr :: Field t => Matrix t -> (Matrix t, Matrix t)+qr = {-# SCC "qr" #-} qr'  -- | RQ factorization. -- -- If @(r,q) = rq m@ then @m == r \<> q@, where q is unitary and r is upper triangular. rq :: Field t => Matrix t -> (Matrix t, Matrix t)-rq m = (r,q) where+rq m =  {-# SCC "rq" #-} (r,q) where     (q',r') = qr $ trans $ rev1 m     r = rev2 (trans r')     q = rev2 (trans q')@@ -313,16 +332,19 @@  -- | Matrix product. multiply :: Field t => Matrix t -> Matrix t -> Matrix t-multiply = multiply'+multiply = {-# SCC "multiply" #-} multiply' +-- | Similar to 'cholSH', but instead of an error (e.g., caused by a matrix not positive definite) it returns 'Nothing'.+mbCholSH :: Field t => Matrix t -> Maybe (Matrix t)+mbCholSH = {-# SCC "mbCholSH" #-} mbCholSH' --- | Similar to 'chol' without checking that the input matrix is hermitian or symmetric.+-- | Similar to 'chol', without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part. cholSH      :: Field t => Matrix t -> Matrix t-cholSH = cholSH'+cholSH = {-# SCC "cholSH" #-} cholSH'  -- | Cholesky factorization of a positive definite hermitian or symmetric matrix. ----- If @c = chol m@ then @m == ctrans c \<> c@.+-- If @c = chol m@ then @c@ is upper triangular and @m == ctrans c \<> c@. chol :: Field t => Matrix t ->  Matrix t chol m | exactHermitian m = cholSH m        | otherwise = error "chol requires positive definite complex hermitian or real symmetric matrix"@@ -332,7 +354,7 @@  -- | Determinant of a square matrix. det :: Field t => Matrix t -> t-det m | square m = s * (product $ toList $ takeDiag $ lup)+det m | square m = {-# SCC "det" #-} s * (product $ toList $ takeDiag $ lup)       | otherwise = error "det of nonsquare matrix"     where (lup,perm) = luPacked m           s = signlp (rows m) perm@@ -455,8 +477,6 @@              -> (Vector Double, Matrix t) -- ^ 'rightSV' of m              -> [Vector t]        -- ^ list of unitary vectors spanning the nullspace nullspaceSVD hint a (s,v) = vs where-    r = rows a-    c = cols a     tol = case hint of         Left t -> t         _      -> eps@@ -527,7 +547,7 @@   unpackQR :: (Field t) => (Matrix t, Vector t) -> (Matrix t, Matrix t)-unpackQR (pq, tau) = (q,r)+unpackQR (pq, tau) =  {-# SCC "unpackQR" #-} (q,r)     where cs = toColumns pq           m = rows pq           n = cols pq

@@ -22,13 +22,14 @@ import Numeric.LinearAlgebra.Linear import Numeric.GSL.Vector import Data.Packed.Matrix-import Complex+import Data.Complex import Data.List(transpose,intersperse)-import Foreign(Storable)-import Data.Monoid import Data.Packed.Internal.Vector--- import Control.Parallel.Strategies +#ifndef VECTOR+import Foreign(Storable)+#endif+ ------------------------------------------------------------------  instance (Show a, Element a) => (Show (Matrix a)) where@@ -43,9 +44,13 @@         pad n str = replicate (n - length str) ' ' ++ str         unwords' = concat . intersperse ", " +#ifndef VECTOR+ instance (Show a, Storable a) => (Show (Vector a)) where     show v = (show (dim v))++" |> " ++ show (toList v) +#endif+ ------------------------------------------------------------------  instance (Element a, Read a) => Read (Matrix a) where@@ -55,12 +60,23 @@               cs = read . init . fst. breakAt ')' . snd . breakAt '<' $ dims               rs = read . snd . breakAt '(' .init . fst . breakAt '>' $ dims +#ifdef VECTOR+ instance (Element a, Read a) => Read (Vector a) where+    readsPrec _ s = [(fromList . read $ listnums, rest)]+        where (thing,trest) = breakAt ']' s+              (dims,listnums) = breakAt ' ' (dropWhile (==' ') thing)+              rest = drop 31 trest+#else++instance (Element a, Read a) => Read (Vector a) where     readsPrec _ s = [((d |>) . read $ listnums, rest)]         where (thing,rest) = breakAt ']' s               (dims,listnums) = breakAt '>' thing               d = read . init . fst . breakAt '|' $ dims +#endif+ breakAt c l = (a++[c],tail b) where     (a,b) = break (==c) l @@ -71,10 +87,13 @@     | dim y == 1 = f3 x (y@>0)     | otherwise = f2 x y +#ifndef VECTOR  instance Linear Vector a => Eq (Vector a) where     (==) = equal +#endif+ instance Num (Vector Double) where     (+) = adaptScalar addConstant add (flip addConstant)     negate = scale (-1)@@ -182,12 +201,12 @@  --------------------------------------------------------------- -instance (Storable a, Num (Vector a)) => Monoid (Vector a) where-    mempty = 0 { idim = 0 }-    mappend a b = mconcat [a,b]-    mconcat = j . filter ((>0).dim)-        where j [] = mempty-              j l  = join l+-- instance (Storable a, Num (Vector a)) => Monoid (Vector a) where+--     mempty = 0 { idim = 0 }+--     mappend a b = mconcat [a,b]+--     mconcat = j . filter ((>0).dim)+--         where j [] = mempty+--               j l  = join l  --------------------------------------------------------------- 

@@ -9,8 +9,11 @@ Stability   :  provisional Portability :  portable -(Very provisional) operators for frequent operations.+Some useful operators, and Show, Read, Eq, Num, Fractional, and Floating instances for Vector and Matrix. +In the context of the standard numeric operators, one-component vectors and matrices automatically expand to match the dimensions of the other operand.++ -} ----------------------------------------------------------------------------- @@ -21,14 +24,14 @@     (<|>),(<->), ) where -import Numeric.LinearAlgebra.Linear+import Numeric.LinearAlgebra.Instances() import Data.Packed.Vector import Data.Packed.Matrix import Numeric.LinearAlgebra.Algorithms  class Mul a b c | a b -> c where  infixl 7 <>- -- | matrix product+ -- | Matrix-matrix, matrix-vector, and vector-matrix products.  (<>) :: Field t => a t -> b t -> c t  instance Mul Matrix Matrix Matrix where@@ -42,7 +45,7 @@  --------------------------------------------------- --- | @u \<.\> v = dot u v@+-- | Dot product: @u \<.\> v = dot u v@ (<.>) :: (Field t) => Vector t -> Vector t -> t infixl 7 <.> (<.>) = dot@@ -51,8 +54,8 @@  {-# DEPRECATED (.*) "use scale a x or scalar a * x" #-} --- | @x .* a = scale x a@-(.*) :: (Linear c a) => a -> c a -> c a+-- -- | @x .* a = scale x a@+-- (.*) :: (Linear c a) => a -> c a -> c a infixl 7 .* a .* x = scale a x @@ -60,8 +63,8 @@  {-# DEPRECATED (*/) "use scale (recip a) x or x / scalar a" #-} --- | @a *\/ x = scale (recip x) a@-(*/) :: (Linear c a) => c a -> a -> c a+-- -- | @a *\/ x = scale (recip x) a@+-- (*/) :: (Linear c a) => c a -> a -> c a infixl 7 */ v */ x = scale (recip x) v @@ -94,7 +97,7 @@ infixl 4 <|> infixl 3 <-> -{- | Horizontal concatenation of matrices and vectors:+{-- - | Horizontal concatenation of matrices and vectors:  @> (ident 3 \<-\> 3 * ident 3) \<|\> fromList [1..6.0] (6><4)@@ -105,10 +108,10 @@  , 0.0, 3.0, 0.0, 5.0  , 0.0, 0.0, 3.0, 6.0 ]@ -}-(<|>) :: (Element t, Joinable a b) => a t -> b t -> Matrix t+-- (<|>) :: (Element t, Joinable a b) => a t -> b t -> Matrix t a <|> b = joinH a b --- | Vertical concatenation of matrices and vectors.-(<->) :: (Element t, Joinable a b) => a t -> b t -> Matrix t+-- -- | Vertical concatenation of matrices and vectors.+-- (<->) :: (Element t, Joinable a b) => a t -> b t -> Matrix t a <-> b = joinV a b 

@@ -18,6 +18,7 @@     -- * Linear systems     linearSolveR, linearSolveC,     lusR, lusC,+    cholSolveR, cholSolveC,     linearSolveLSR, linearSolveLSC,     linearSolveSVDR, linearSolveSVDC,     -- * SVD@@ -31,7 +32,7 @@     -- * LU     luR, luC,     -- * Cholesky-    cholS, cholH,+    cholS, cholH, mbCholS, mbCholH,     -- * QR     qrR, qrC,     -- * Hessenberg@@ -40,8 +41,9 @@     schurR, schurC ) where -import Data.Packed.Internal hiding (toComplex)-import Data.Packed+import Data.Packed.Internal+import Data.Packed.Matrix+import Data.Complex import Numeric.GSL.Vector(vectorMapValR, FunCodeSV(Scale)) import Foreign import Foreign.C.Types (CInt)@@ -236,7 +238,6 @@           s' = fixeig1 s           v' = toRows $ trans v           v'' = fromColumns $ fixeig (toList s') v'-          r = rows m  eigRaux :: Matrix Double -> (Vector (Complex Double), Matrix Double) eigRaux m = unsafePerformIO $ do@@ -312,8 +313,10 @@ vrev = flatten . flipud . reshape 1  ------------------------------------------------------------------------------foreign import ccall "LAPACK/lapack-aux.h linearSolveR_l" dgesv :: TMMM-foreign import ccall "LAPACK/lapack-aux.h linearSolveC_l" zgesv :: TCMCMCM+foreign import ccall "linearSolveR_l" dgesv :: TMMM+foreign import ccall "linearSolveC_l" zgesv :: TCMCMCM+foreign import ccall "cholSolveR_l" dpotrs :: TMMM+foreign import ccall "cholSolveC_l" zpotrs :: TCMCMCM  linearSolveSQAux f st a b     | n1==n2 && n1==r = unsafePerformIO $ do@@ -334,6 +337,15 @@ linearSolveC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double) linearSolveC a b = linearSolveSQAux zgesv "linearSolveC" (fmat a) (fmat b) ++-- | Solves a symmetric positive definite system of linear equations using a precomputed Cholesky factorization obtained by 'cholS'.+cholSolveR :: Matrix Double -> Matrix Double -> Matrix Double+cholSolveR a b = linearSolveSQAux dpotrs "cholSolveR" (fmat a) (fmat b)++-- | Solves a Hermitian positive definite system of linear equations using a precomputed Cholesky factorization obtained by 'cholH'.+cholSolveC :: Matrix (Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)+cholSolveC a b = linearSolveSQAux zpotrs "cholSolveC" (fmat a) (fmat b)+ ----------------------------------------------------------------------------------- foreign import ccall "LAPACK/lapack-aux.h linearSolveLSR_l" dgels :: TMMM foreign import ccall "LAPACK/lapack-aux.h linearSolveLSC_l" zgels :: TCMCMCM@@ -380,19 +392,27 @@ foreign import ccall "LAPACK/lapack-aux.h chol_l_H" zpotrf :: TCMCM foreign import ccall "LAPACK/lapack-aux.h chol_l_S" dpotrf :: TMM +cholAux f st a = do+    r <- createMatrix ColumnMajor n n+    app2 f mat a mat r st+    return r+  where n = rows a+ -- | Cholesky factorization of a complex Hermitian positive definite matrix, using LAPACK's /zpotrf/. cholH :: Matrix (Complex Double) -> Matrix (Complex Double)-cholH = cholAux zpotrf "cholH" . fmat+cholH = unsafePerformIO . cholAux zpotrf "cholH" . fmat  -- | Cholesky factorization of a real symmetric positive definite matrix, using LAPACK's /dpotrf/. cholS :: Matrix Double -> Matrix Double-cholS = cholAux dpotrf "cholS" . fmat+cholS =  unsafePerformIO . cholAux dpotrf "cholS" . fmat -cholAux f st a = unsafePerformIO $ do-    r <- createMatrix ColumnMajor n n-    app2 f mat a mat r st-    return r-  where n = rows a+-- | Cholesky factorization of a complex Hermitian positive definite matrix, using LAPACK's /zpotrf/ ('Maybe' version).+mbCholH :: Matrix (Complex Double) -> Maybe (Matrix (Complex Double))+mbCholH = unsafePerformIO . mbCatch . cholAux zpotrf "cholH" . fmat++-- | Cholesky factorization of a real symmetric positive definite matrix, using LAPACK's /dpotrf/  ('Maybe' version).+mbCholS :: Matrix Double -> Maybe (Matrix Double)+mbCholS =  unsafePerformIO . mbCatch . cholAux dpotrf "cholS" . fmat  ----------------------------------------------------------------------------------- foreign import ccall "LAPACK/lapack-aux.h qr_l_R" dgeqr2 :: TMVM

@@ -492,6 +492,42 @@     OK } +//////// symmetric positive definite real linear system using Cholesky ////////////++int cholSolveR_l(KDMAT(a),KDMAT(b),DMAT(x)) {+    integer n = ar;+    integer nhrs = bc;+    REQUIRES(n>=1 && ar==ac && ar==br,BAD_SIZE);+    DEBUGMSG("cholSolveR_l");+    memcpy(xp,bp,n*nhrs*sizeof(double));+    integer res;+    dpotrs_ ("U",+             &n,&nhrs,+             (double*)ap, &n,+             xp, &n,+             &res);+    CHECK(res,res);+    OK+}++//////// Hermitian positive definite real linear system using Cholesky ////////////++int cholSolveC_l(KCMAT(a),KCMAT(b),CMAT(x)) {+    integer n = ar;+    integer nhrs = bc;+    REQUIRES(n>=1 && ar==ac && ar==br,BAD_SIZE);+    DEBUGMSG("cholSolveC_l");+    memcpy(xp,bp,2*n*nhrs*sizeof(double));+    integer res;+    zpotrs_  ("U",+             &n,&nhrs,+             (doublecomplex*)ap, &n,+             (doublecomplex*)xp, &n,+             &res);+    CHECK(res,res);+    OK+}+ //////////////////// least squares real linear system ////////////  int linearSolveLSR_l(KDMAT(a),KDMAT(b),DMAT(x)) {

@@ -18,10 +18,12 @@     Linear(..) ) where -import Data.Packed+import Data.Packed.Vector+import Data.Packed.Matrix+import Data.Complex import Numeric.GSL.Vector --- | A generic interface for vectors and matrices to a few element-by-element functions in Numeric.GSL.Vector.+-- | Basic element-by-element functions. class (Container c e) => Linear c e where     -- | create a structure with a single element     scalar      :: e -> c e

@@ -28,7 +28,7 @@ import Test.HUnit hiding ((~:),test,Testable) import System.Info import Data.List(foldl1')-import Numeric.GSL hiding (sin,cos,exp,choose)+import Numeric.GSL import Prelude hiding ((^)) import qualified Prelude import System.CPUTime@@ -78,14 +78,19 @@  --------------------------------------------------------------------- -besselTest = utest "bessel_J0_e" ( abs (r-expected) < e )-    where (r,e) = bessel_J0_e 5.0-          expected = -0.17759677131433830434739701+derivTest = abs (d (\x-> x * d (\y-> x+y) 1) 1 - 1) < 1E-10+    where d f x = fst $ derivCentral 0.01 f x -exponentialTest = utest "exp_e10_e" ( abs (v*10^e - expected) < 4E-2 )-    where (v,e,_err) = exp_e10_e 30.0-          expected = exp 30.0+--------------------------------------------------------------------- +-- besselTest = utest "bessel_J0_e" ( abs (r-expected) < e )+--     where (r,e) = bessel_J0_e 5.0+--           expected = -0.17759677131433830434739701++-- exponentialTest = utest "exp_e10_e" ( abs (v*10^e - expected) < 4E-2 )+--     where (v,e,_err) = exp_e10_e 30.0+--           expected = exp 30.0+ ---------------------------------------------------------------------  nd1 = (3><3) [ 1/2, 1/4, 1/4@@ -143,6 +148,34 @@  --------------------------------------------------------------------- +fittingTest = utest "levmar" (ok1 && ok2)+    where+    xs = map return [0 .. 39]+    sigma = 0.1+    ys = map return $ toList $ fromList (map (head . expModel [5,0.1,1]) xs)+                    + scalar sigma * (randomVector 0 Gaussian 40)+    dats = zip xs (zip ys (repeat sigma))+    dat = zip xs ys++    expModel [a,lambda,b] [t] = [a * exp (-lambda * t) + b]+    expModelDer [a,lambda,_b] [t] = [[exp (-lambda * t), -t * a * exp(-lambda*t) , 1]]++    sols = fst $ fitModelScaled 1E-4 1E-4 20 (expModel, expModelDer) dats [1,0,0]+    sol = fst $ fitModel 1E-4 1E-4 20 (expModel, expModelDer) dat [1,0,0]++    ok1 = and (zipWith f sols [5,0.1,1]) where f (x,d) r = abs (x-r)<2*d+    ok2 = pnorm PNorm2 (fromList (map fst sols) - fromList sol) < 1E-5++-----------------------------------------------------++mbCholTest = utest "mbCholTest" (ok1 && ok2) where+    m1 = (2><2) [2,5,5,8 :: Double]+    m2 = (2><2) [3,5,5,9 :: Complex Double]+    ok1 = mbCholSH m1 == Nothing+    ok2 = mbCholSH m2 == Just (chol m2)++---------------------------------------------------------------------+ randomTestGaussian = c :~1~: snd (meanCov dat) where     a = (3><3) [1,2,3,                 2,4,0,@@ -180,6 +213,9 @@     test (multProp1  . cConsist)     test (multProp2  . rConsist)     test (multProp2  . cConsist)+    putStrLn "------ sub-trans"+    test (subProp . rM)+    test (subProp . cM)     putStrLn "------ lu"     test (luProp    . rM)     test (luProp    . cM)@@ -189,6 +225,9 @@     putStrLn "------ luSolve"     test (linearSolveProp (luSolve.luPacked) . rSqWC)     test (linearSolveProp (luSolve.luPacked) . cSqWC)+    putStrLn "------ cholSolve"+    test (linearSolveProp (cholSolve.chol) . rPosDef)+    test (linearSolveProp (cholSolve.chol) . cPosDef)     putStrLn "------ luSolveLS"     test (linearSolveProp linearSolveLS . rSqWC)     test (linearSolveProp linearSolveLS . cSqWC)@@ -206,7 +245,9 @@     test (svdProp1a svdR)     test (svdProp1a svdC)     test (svdProp1a svdRd)-    test (svdProp1a svdCd)+    test (svdProp1b svdR)+    test (svdProp1b svdC)+    test (svdProp1b svdRd)     test (svdProp2 thinSVDR)     test (svdProp2 thinSVDC)     test (svdProp2 thinSVDRd)@@ -221,6 +262,13 @@     test (svdProp6b)     test (svdProp7  . rM)     test (svdProp7  . cM)+    putStrLn "------ svdCd"+#ifdef NOZGESDD+    putStrLn "Omitted"+#else+    test (svdProp1a svdCd)+    test (svdProp1b svdCd)+#endif     putStrLn "------ eig"     test (eigSHProp . rHer)     test (eigSHProp . cHer)@@ -273,9 +321,10 @@         , utest "arith2" $ ((scalar (1+i) * ones (100,100) * 5 + 2)/0.5 - 7)**2 |~| ( scalar (140*i-51) :: CM)         , utest "arith3" $ exp (scalar i * ones(10,10)*pi) + 1 |~| 0         , utest "<\\>"   $ (3><2) [2,0,0,3,1,1::Double] <\> 3|>[4,9,5] |~| 2|>[2,3]-        , utest "gamma" (gamma 5 == 24.0)-        , besselTest-        , exponentialTest+--        , utest "gamma" (gamma 5 == 24.0)+--        , besselTest+--        , exponentialTest+        , utest "deriv" derivTest         , utest "integrate" (abs (volSphere 2.5 - 4/3*pi*2.5^3) < 1E-8)         , utest "polySolve" (polySolveProp [1,2,3,4])         , minimizationTest@@ -289,6 +338,8 @@                        && rank ((2><3)[1,0,0,1,7*eps,0]) == 2         , utest "block" $ fromBlocks [[ident 3,0],[0,ident 4]] == (ident 7 :: CM)         , odeTest+        , fittingTest+        , mbCholTest         ]     return () @@ -305,6 +356,8 @@ -- | Performance measurements. runBenchmarks :: IO () runBenchmarks = do+    solveBench+    subBench     multBench     svdBench     eigBench@@ -317,7 +370,7 @@     t0 <- getCPUTime     act `seq` putStr " "     t1 <- getCPUTime-    printf "%5.1f s CPU\n" $ (fromIntegral (t1 - t0) / (10^12 :: Double)) :: IO ()+    printf "%6.2f s CPU\n" $ (fromIntegral (t1 - t0) / (10^12 :: Double)) :: IO ()     return ()  --------------------------------@@ -335,6 +388,16 @@  -------------------------------- +subBench = do+    putStrLn ""+    let g = foldl1' (.) (replicate (10^5) (\v -> subVector 1 (dim v -1) v))+    time "0.1M subVector   " (g (constant 1 (1+10^5) :: Vector Double) @> 0)+    let f = foldl1' (.) (replicate (10^5) (fromRows.toRows))+    time "subVector-join  3" (f (ident  3 :: Matrix Double) @@>(0,0))+    time "subVector-join 10" (f (ident 10 :: Matrix Double) @@>(0,0))++--------------------------------+ multBench = do     let a = ident 1000 :: Matrix Double     let b = ident 2000 :: Matrix Double@@ -376,3 +439,19 @@     time "singular values 1000x1000" (singularValues b)     time "full svd        1000x1000" (fv $ svd b) +--------------------------------++solveBenchN n = do+    let x = uniformSample 777 (2*n) (replicate n (-1,1))+        a = trans x <> x+        b = asColumn $ randomVector 666 Uniform n+    a `seq` b `seq` putStrLn ""+    time ("svd solve " ++ show n) (linearSolveSVD a b)+    time (" ls solve " ++ show n) (linearSolveLS a b)+    time ("    solve " ++ show n) (linearSolve a b)+    time ("cholSolve " ++ show n) (cholSolve (chol a) b)++solveBench = do+    solveBenchN 500+    solveBenchN 1000+    -- solveBenchN 1500

@@ -29,7 +29,7 @@     pinvProp,     detProp,     nullspaceProp,-    svdProp1, svdProp1a, svdProp2, svdProp3, svdProp4,+    svdProp1, svdProp1a, svdProp1b, svdProp2, svdProp3, svdProp4,     svdProp5a, svdProp5b, svdProp6a, svdProp6b, svdProp7,     eigProp, eigSHProp, eigProp2, eigSHProp2,     qrProp, rqProp,@@ -38,6 +38,7 @@     cholProp,     expmDiagProp,     multProp1, multProp2,+    subProp,     linearSolveProp, linearSolveProp2 ) where @@ -119,7 +120,8 @@           (q,r) = qr m           s x = fromList [x] -nullspaceProp m = null nl `trivial` (null nl || m <> n |~| zeros (r,c))+nullspaceProp m = null nl `trivial` (null nl || m <> n |~| zeros (r,c)+                                     && orthonormal (fromColumns nl))     where nl = nullspacePrec 1 m           n = fromColumns nl           r = rows m@@ -135,6 +137,9 @@     (u,s,v) = svdfun m     d = diagRect s (rows m) (cols m) +svdProp1b svdfun m = unitary u && unitary v where+    (u,_,v) = svdfun m+ -- thinSVD svdProp2 thinSVDfun m = m |~| u <> diag (real s) <> trans v && orthonormal u && orthonormal v && dim s == min (rows m) (cols m)     where (u,s,v) = thinSVDfun m@@ -180,7 +185,7 @@ svdProp7 m = s |~| s' && u |~| u' && v |~| v' && s |~| s'''     where (u,s,v) = svd m           (s',v') = rightSV m-          (u',s'') = leftSV m+          (u',_s'') = leftSV m           s''' = singularValues m  ------------------------------------------------------------------@@ -242,3 +247,6 @@     where q = min (rows a) (cols a)           b = a <> x           wc = rank a == q++subProp m = m == (trans . fromColumns . toRows) m+