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 --- packages/special/lib/Numeric/GSL/Special/Airy.hs | 141 ++++++ packages/special/lib/Numeric/GSL/Special/Bessel.hs | 508 +++++++++++++++++++++ .../special/lib/Numeric/GSL/Special/Clausen.hs | 30 ++ .../special/lib/Numeric/GSL/Special/Coulomb.hs | 69 +++ .../special/lib/Numeric/GSL/Special/Coupling.hs | 68 +++ packages/special/lib/Numeric/GSL/Special/Dawson.hs | 30 ++ packages/special/lib/Numeric/GSL/Special/Debye.hs | 80 ++++ packages/special/lib/Numeric/GSL/Special/Dilog.hs | 42 ++ .../special/lib/Numeric/GSL/Special/Elementary.hs | 35 ++ packages/special/lib/Numeric/GSL/Special/Ellint.hs | 140 ++++++ packages/special/lib/Numeric/GSL/Special/Elljac.hs | 38 ++ packages/special/lib/Numeric/GSL/Special/Erf.hs | 80 ++++ packages/special/lib/Numeric/GSL/Special/Exp.hs | 115 +++++ packages/special/lib/Numeric/GSL/Special/Expint.hs | 160 +++++++ .../special/lib/Numeric/GSL/Special/Fermi_dirac.hs | 110 +++++ packages/special/lib/Numeric/GSL/Special/Gamma.hs | 236 ++++++++++ .../special/lib/Numeric/GSL/Special/Gegenbauer.hs | 64 +++ packages/special/lib/Numeric/GSL/Special/Hyperg.hs | 130 ++++++ .../special/lib/Numeric/GSL/Special/Internal.hsc | 102 +++++ .../special/lib/Numeric/GSL/Special/Laguerre.hs | 60 +++ .../special/lib/Numeric/GSL/Special/Lambert.hs | 40 ++ .../special/lib/Numeric/GSL/Special/Legendre.hs | 233 ++++++++++ packages/special/lib/Numeric/GSL/Special/Log.hs | 64 +++ .../special/lib/Numeric/GSL/Special/Pow_int.hs | 30 ++ packages/special/lib/Numeric/GSL/Special/Psi.hs | 84 ++++ .../special/lib/Numeric/GSL/Special/Synchrotron.hs | 40 ++ .../special/lib/Numeric/GSL/Special/Transport.hs | 60 +++ packages/special/lib/Numeric/GSL/Special/Trig.hs | 138 ++++++ packages/special/lib/Numeric/GSL/Special/Zeta.hs | 90 ++++ packages/special/lib/Numeric/GSL/Special/auto.hs | 244 ++++++++++ .../special/lib/Numeric/GSL/Special/autoall.sh | 45 ++ .../special/lib/Numeric/GSL/Special/replace.hs | 14 + 32 files changed, 3320 insertions(+) create mode 100644 packages/special/lib/Numeric/GSL/Special/Airy.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Bessel.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Clausen.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Coulomb.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Coupling.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Dawson.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Debye.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Dilog.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Elementary.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Ellint.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Elljac.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Erf.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Exp.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Expint.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Fermi_dirac.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Gamma.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Gegenbauer.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Hyperg.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Internal.hsc create mode 100644 packages/special/lib/Numeric/GSL/Special/Laguerre.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Lambert.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Legendre.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Log.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Pow_int.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Psi.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Synchrotron.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Transport.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Trig.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/Zeta.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/auto.hs create mode 100644 packages/special/lib/Numeric/GSL/Special/autoall.sh create mode 100644 packages/special/lib/Numeric/GSL/Special/replace.hs (limited to 'packages/special/lib/Numeric/GSL/Special') diff --git a/packages/special/lib/Numeric/GSL/Special/Airy.hs b/packages/special/lib/Numeric/GSL/Special/Airy.hs new file mode 100644 index 0000000..8a04eed --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Airy.hs @@ -0,0 +1,141 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Airy +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Bessel.hs b/packages/special/lib/Numeric/GSL/Special/Bessel.hs new file mode 100644 index 0000000..66d6c5b --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Bessel.hs @@ -0,0 +1,508 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Bessel +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Clausen.hs b/packages/special/lib/Numeric/GSL/Special/Clausen.hs new file mode 100644 index 0000000..70f05a7 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Clausen.hs @@ -0,0 +1,30 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Clausen +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Coulomb.hs b/packages/special/lib/Numeric/GSL/Special/Coulomb.hs new file mode 100644 index 0000000..7253972 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Coulomb.hs @@ -0,0 +1,69 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Coulomb +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Coupling.hs b/packages/special/lib/Numeric/GSL/Special/Coupling.hs new file mode 100644 index 0000000..16ff9b9 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Coupling.hs @@ -0,0 +1,68 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Coupling +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Dawson.hs b/packages/special/lib/Numeric/GSL/Special/Dawson.hs new file mode 100644 index 0000000..7e8d9ce --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Dawson.hs @@ -0,0 +1,30 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Dawson +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Debye.hs b/packages/special/lib/Numeric/GSL/Special/Debye.hs new file mode 100644 index 0000000..01976ee --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Debye.hs @@ -0,0 +1,80 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Debye +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Dilog.hs b/packages/special/lib/Numeric/GSL/Special/Dilog.hs new file mode 100644 index 0000000..48b548b --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Dilog.hs @@ -0,0 +1,42 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Dilog +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Elementary.hs b/packages/special/lib/Numeric/GSL/Special/Elementary.hs new file mode 100644 index 0000000..7e7f8b6 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Elementary.hs @@ -0,0 +1,35 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Elementary +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Ellint.hs b/packages/special/lib/Numeric/GSL/Special/Ellint.hs new file mode 100644 index 0000000..6735057 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Ellint.hs @@ -0,0 +1,140 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Ellint +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Elljac.hs b/packages/special/lib/Numeric/GSL/Special/Elljac.hs new file mode 100644 index 0000000..5b32cfe --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Elljac.hs @@ -0,0 +1,38 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Elljac +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Erf.hs b/packages/special/lib/Numeric/GSL/Special/Erf.hs new file mode 100644 index 0000000..258afd3 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Erf.hs @@ -0,0 +1,80 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Erf +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Exp.hs b/packages/special/lib/Numeric/GSL/Special/Exp.hs new file mode 100644 index 0000000..4f15964 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Exp.hs @@ -0,0 +1,115 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Exp +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Expint.hs b/packages/special/lib/Numeric/GSL/Special/Expint.hs new file mode 100644 index 0000000..f1102c4 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Expint.hs @@ -0,0 +1,160 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Expint +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Fermi_dirac.hs b/packages/special/lib/Numeric/GSL/Special/Fermi_dirac.hs new file mode 100644 index 0000000..362c7ba --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Fermi_dirac.hs @@ -0,0 +1,110 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Fermi_dirac +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Gamma.hs b/packages/special/lib/Numeric/GSL/Special/Gamma.hs new file mode 100644 index 0000000..03b39c4 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Gamma.hs @@ -0,0 +1,236 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Gamma +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Gegenbauer.hs b/packages/special/lib/Numeric/GSL/Special/Gegenbauer.hs new file mode 100644 index 0000000..31568f3 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Gegenbauer.hs @@ -0,0 +1,64 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Gegenbauer +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Hyperg.hs b/packages/special/lib/Numeric/GSL/Special/Hyperg.hs new file mode 100644 index 0000000..b5425f1 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Hyperg.hs @@ -0,0 +1,130 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Hyperg +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Internal.hsc b/packages/special/lib/Numeric/GSL/Special/Internal.hsc new file mode 100644 index 0000000..68ec2f2 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Internal.hsc @@ -0,0 +1,102 @@ + {-# LANGUAGE ForeignFunctionInterface #-} +----------------------------------------------------------------------------- +{- | +Module : Numeric.GSL.Special.Internal +Copyright : (c) Alberto Ruiz 2007 +License : GPL-style + +Maintainer : Alberto Ruiz (aruiz at um dot es) +Stability : provisional +Portability : uses ffi + +Support for Special functions. + + +-} +----------------------------------------------------------------------------- + +#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.Development(check,(//)) +import Foreign.C.Types(CSize,CInt) + + +data Precision = PrecDouble | PrecSingle | PrecApprox + +precCode :: Precision -> Int +precCode PrecDouble = 0 +precCode PrecSingle = 1 +precCode PrecApprox = 2 + +type Gsl_mode_t = Int + +type Size_t = CSize + +--------------------------------------------------- + +data Gsl_sf_result = SF Double Double + deriving (Show) + +instance Storable Gsl_sf_result where + sizeOf _ = #size gsl_sf_result + alignment _ = #alignment gsl_sf_result + peek ptr = do + val <- (#peek gsl_sf_result, val) ptr + err <- (#peek gsl_sf_result, err) ptr + return (SF val err) + poke ptr (SF val err) = do + (#poke gsl_sf_result, val) ptr val + (#poke gsl_sf_result, err) ptr err + + +data Gsl_sf_result_e10 = SFE Double Double CInt + deriving (Show) + +instance Storable Gsl_sf_result_e10 where + sizeOf _ = #size gsl_sf_result_e10 + alignment _ = #alignment gsl_sf_result_e10 + peek ptr = do + val <- (#peek gsl_sf_result_e10, val) ptr + err <- (#peek gsl_sf_result_e10, err) ptr + e10 <- (#peek gsl_sf_result_e10, e10) ptr + return (SFE val err e10) + poke ptr (SFE val err e10) = do + (#poke gsl_sf_result_e10, val) ptr val + (#poke gsl_sf_result_e10, err) ptr err + (#poke gsl_sf_result_e10, e10) ptr e10 + + +---------------------------------------------------------------- +-- | access to a sf_result +createSFR :: String -> (Ptr a -> IO CInt) -> (Double, Double) +createSFR s f = unsafePerformIO $ do + p <- malloc :: IO (Ptr Gsl_sf_result) + f (castPtr p) // check s + SF val err <- peek p + free p + return (val,err) + + +--------------------------------------------------------------------- +-- the sf_result_e10 contains two doubles and the exponent + +-- | access to sf_result_e10 +createSFR_E10 :: String -> (Ptr a -> IO CInt) -> (Double, Int, Double) +createSFR_E10 s f = unsafePerformIO $ do + p <- malloc :: IO (Ptr Gsl_sf_result_e10) + f (castPtr p) // check s + SFE val err expo <- peek p + free p + return (val, fromIntegral expo,err) diff --git a/packages/special/lib/Numeric/GSL/Special/Laguerre.hs b/packages/special/lib/Numeric/GSL/Special/Laguerre.hs new file mode 100644 index 0000000..8db6a6c --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Laguerre.hs @@ -0,0 +1,60 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Laguerre +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Lambert.hs b/packages/special/lib/Numeric/GSL/Special/Lambert.hs new file mode 100644 index 0000000..b229bf6 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Lambert.hs @@ -0,0 +1,40 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Lambert +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Legendre.hs b/packages/special/lib/Numeric/GSL/Special/Legendre.hs new file mode 100644 index 0000000..e329457 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Legendre.hs @@ -0,0 +1,233 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Legendre +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Log.hs b/packages/special/lib/Numeric/GSL/Special/Log.hs new file mode 100644 index 0000000..a57b67a --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Log.hs @@ -0,0 +1,64 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Log +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Pow_int.hs b/packages/special/lib/Numeric/GSL/Special/Pow_int.hs new file mode 100644 index 0000000..fd232ab --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Pow_int.hs @@ -0,0 +1,30 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Pow_int +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Psi.hs b/packages/special/lib/Numeric/GSL/Special/Psi.hs new file mode 100644 index 0000000..4655b8c --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Psi.hs @@ -0,0 +1,84 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Psi +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Synchrotron.hs b/packages/special/lib/Numeric/GSL/Special/Synchrotron.hs new file mode 100644 index 0000000..59d6c76 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Synchrotron.hs @@ -0,0 +1,40 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Synchrotron +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Transport.hs b/packages/special/lib/Numeric/GSL/Special/Transport.hs new file mode 100644 index 0000000..e95a67a --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Transport.hs @@ -0,0 +1,60 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Transport +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Trig.hs b/packages/special/lib/Numeric/GSL/Special/Trig.hs new file mode 100644 index 0000000..4b7ae67 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Trig.hs @@ -0,0 +1,138 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Trig +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/Zeta.hs b/packages/special/lib/Numeric/GSL/Special/Zeta.hs new file mode 100644 index 0000000..930efc0 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/Zeta.hs @@ -0,0 +1,90 @@ +------------------------------------------------------------ +-- | +-- Module : Numeric.GSL.Special.Zeta +-- Copyright : (c) Alberto Ruiz 2006 +-- License : GPL +-- Maintainer : Alberto Ruiz (aruiz at um dot es) +-- Stability : provisional +-- Portability : uses ffi +-- +-- Wrappers for selected functions described at: +-- +-- +------------------------------------------------------------ + +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/packages/special/lib/Numeric/GSL/Special/auto.hs b/packages/special/lib/Numeric/GSL/Special/auto.hs new file mode 100644 index 0000000..b46e6c6 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/auto.hs @@ -0,0 +1,244 @@ +#!/usr/bin/env runhaskell + +-- automatic generation of wrappers for simple GSL special functions + +import Text.ParserCombinators.Parsec +import System +import Data.List(intersperse, isPrefixOf) +import Data.Char(toUpper,isUpper,toLower) + +data Type = Normal Ident | Pointer Ident deriving (Eq, Show) + +type Ident = String + +data Header = Header Type Ident [(Type,Ident)] deriving Show + +headers f = case parse parseHeaders "" f of + Right l -> l + Left s -> error (show s) + + +rep (c,r) [] = [] +rep (c,r) f@(x:xs) + | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f) + | otherwise = x:(rep (c,r) xs) + + +fixlong [] = [] +fixlong "\\" = [] +fixlong ('\\':'\n':xs) = xs +fixlong (x:xs) = x : fixlong xs + + +safe (Header _ _ args) = all ok args + || all ok (init args) && kn (last args) + where ok ((Normal s),_) | s `elem` ["double","float","int","gsl_mode_t"] = True + ok _ = False + kn ((Pointer "gsl_sf_result"),_) = True + kn ((Pointer "gsl_sf_result_e10"),_) = True + kn _ = False + + + +fixC s = rep ("gsl_mode_t","int") $ rep ("gsl_sf_result","double") $ rep ("gsl_sf_result_e10","double") $ s + +main = do + args <- getArgs + let name = args!!0 + headerfile = + case args of + [n] -> "/usr/include/gsl/gsl_sf_"++n++".h" + [_,f] -> f + file <- readFile headerfile + + putStrLn headerfile + --mapM_ print (headers $ fixlong file) + let parsed = (headers $ fixlong file) + -- writeFile (name ++".h") (fixC $ unlines $ map showC parsed) + + --putStrLn "" + --mapM (\(Header _ n _) -> putStrLn (drop 7 n ++",")) parsed + --putStrLn "" + --mapM_ (putStrLn.showFull (name ++".h")) parsed + let exports = rep (")",") where") $ rep ("(\n","(\n ") $ rep (",\n",", ") $ unlines $ ["("]++intersperse "," (map (\(Header _ n _) -> hName n) (filter safe parsed))++[")"] + let defs = unlines $ map (showFull (name ++".h")) parsed + let imports = "\nimport Foreign(Ptr)\n" + ++"import Foreign.C.Types(CInt)\n" + ++"import Numeric.GSL.Special.Internal\n" + let mod = modhead name ++ "module Numeric.GSL.Special."++ upperFirst name++exports++imports++defs + writeFile (upperFirst name ++ ".hs") mod +-- appendFile "funs.txt" $ rep ("(\n ","-- * " +-- ++map toUpper name +-- -- ++"\n"++google ( "gsl_sf_"++name++".h")++"\n" +-- ++"\n,") $ rep (") where","") $ exports + + +google name = "" + +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/packages/special/lib/Numeric/GSL/Special/autoall.sh b/packages/special/lib/Numeric/GSL/Special/autoall.sh new file mode 100644 index 0000000..18d0a6e --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/autoall.sh @@ -0,0 +1,45 @@ +#!/bin/bash + +function rep { + ./replace.hs "$1" "$2" < $3 > /tmp/tmp-rep + cp /tmp/tmp-rep $3 +} + +rm -f funs.txt + +./auto.hs airy +rep ') where' ', Precision(..)\n) where' Airy.hs +./auto.hs bessel +./auto.hs clausen +./auto.hs coulomb +./auto.hs coupling +rep ', coupling_6j_INCORRECT_e\n, coupling_6j_INCORRECT\n' '' Coupling.hs +./auto.hs dawson +./auto.hs debye +./auto.hs dilog +./auto.hs elementary +./auto.hs ellint +#./auto.hs elljac +./auto.hs erf +./auto.hs exp +rep ', exp\n' ', Numeric.GSL.Special.Exp.exp\n' Exp.hs +rep ', exprel_n_CF_e' '-- , exprel_n_CF_e' Exp.hs +./auto.hs expint +./auto.hs fermi_dirac +./auto.hs gamma +./auto.hs gegenbauer +./auto.hs hyperg +./auto.hs laguerre +./auto.hs lambert +./auto.hs legendre +./auto.hs log +rep ', log\n' ', Numeric.GSL.Special.Log.log\n' Log.hs +#./auto.hs mathieu +./auto.hs pow_int +./auto.hs psi +./auto.hs synchrotron +./auto.hs transport +./auto.hs trig +rep ', sin\n' ', Numeric.GSL.Special.Trig.sin\n' Trig.hs +rep ', cos\n' ', Numeric.GSL.Special.Trig.cos\n' Trig.hs +./auto.hs zeta diff --git a/packages/special/lib/Numeric/GSL/Special/replace.hs b/packages/special/lib/Numeric/GSL/Special/replace.hs new file mode 100644 index 0000000..f20a6b8 --- /dev/null +++ b/packages/special/lib/Numeric/GSL/Special/replace.hs @@ -0,0 +1,14 @@ +#!/usr/bin/env runhaskell + +import Data.List(isPrefixOf) +import System(getArgs) + +rep (c,r) [] = [] +rep (c,r) f@(x:xs) + | c `isPrefixOf` f = r ++ rep (c,r) (drop (length c) f) + | otherwise = x:(rep (c,r) xs) + +main = do + args <- getArgs + let [p',r'] = map (rep ("\\n","\n")) args + interact $ rep (p',r') -- cgit v1.2.3