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