packages feed

hmatrix-special (empty) → 0.1.0

raw patch · 36 files changed

+3476/−0 lines, 36 filesdep +basedep +hmatrixsetup-changed

Dependencies added: base, hmatrix

Files

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