From 620d5008ea9a931a91907cd0c902bb64f005121f Mon Sep 17 00:00:00 2001 From: Alberto Ruiz Date: Thu, 13 Sep 2007 10:27:17 +0000 Subject: automatic google search in the docs for the special functions --- lib/GSL/Special/Bessel.hs | 207 ++++++++++++++++++++++++++++++++++++++++- lib/GSL/Special/Clausen.hs | 6 +- lib/GSL/Special/Coulomb.hs | 24 ++++- lib/GSL/Special/Dawson.hs | 6 +- lib/GSL/Special/Debye.hs | 18 +++- lib/GSL/Special/Dilog.hs | 12 ++- lib/GSL/Special/Elementary.hs | 8 +- lib/GSL/Special/Ellint.hs | 42 ++++++++- lib/GSL/Special/Erf.hs | 26 +++++- lib/GSL/Special/Expint.hs | 50 +++++++++- lib/GSL/Special/Fermi_dirac.hs | 38 +++++++- lib/GSL/Special/Gamma.hs | 89 +++++++++++++++++- lib/GSL/Special/Gegenbauer.hs | 20 +++- lib/GSL/Special/Hyperg.hs | 46 ++++++++- lib/GSL/Special/Internal.hs | 3 + lib/GSL/Special/Laguerre.hs | 18 +++- lib/GSL/Special/Lambert.hs | 10 +- lib/GSL/Special/Pow_int.hs | 6 +- lib/GSL/Special/Psi.hs | 26 +++++- lib/GSL/Special/Synchrotron.hs | 10 +- lib/GSL/Special/Zeta.hs | 30 +++++- lib/GSL/Special/auto.hs | 22 ++++- lib/GSL/Special/autoall.sh | 41 ++++++++ lib/GSL/Special/bessel.h | 1 + lib/GSL/Special/manual.txt | 12 --- 25 files changed, 734 insertions(+), 37 deletions(-) create mode 100644 lib/GSL/Special/autoall.sh delete mode 100644 lib/GSL/Special/manual.txt (limited to 'lib') diff --git a/lib/GSL/Special/Bessel.hs b/lib/GSL/Special/Bessel.hs index e0e2ab5..4a96926 100644 --- a/lib/GSL/Special/Bessel.hs +++ b/lib/GSL/Special/Bessel.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -109,496 +109,701 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_bessel_J0_e(double x,gsl_sf_result* result); +-- +-- bessel_J0_e :: Double -> (Double,Double) bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x foreign import ccall "bessel.h gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_J0(double x); +-- +-- bessel_J0 :: Double -> Double bessel_J0 = gsl_sf_bessel_J0 foreign import ccall "bessel.h gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_J1_e(double x,gsl_sf_result* result); +-- +-- bessel_J1_e :: Double -> (Double,Double) bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x foreign import ccall "bessel.h gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_J1(double x); +-- +-- bessel_J1 :: Double -> Double bessel_J1 = gsl_sf_bessel_J1 foreign import ccall "bessel.h gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_Jn_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_Jn_e :: Int -> Double -> (Double,Double) bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x foreign import ccall "bessel.h gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Jn(int n,double x); +-- +-- bessel_Jn :: Int -> Double -> Double bessel_Jn = gsl_sf_bessel_Jn foreign import ccall "bessel.h gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_Jn_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_Jn_array = gsl_sf_bessel_Jn_array foreign import ccall "bessel.h gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_Y0_e(double x,gsl_sf_result* result); +-- +-- bessel_Y0_e :: Double -> (Double,Double) bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x foreign import ccall "bessel.h gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Y0(double x); +-- +-- bessel_Y0 :: Double -> Double bessel_Y0 = gsl_sf_bessel_Y0 foreign import ccall "bessel.h gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_Y1_e(double x,gsl_sf_result* result); +-- +-- bessel_Y1_e :: Double -> (Double,Double) bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x foreign import ccall "bessel.h gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Y1(double x); +-- +-- bessel_Y1 :: Double -> Double bessel_Y1 = gsl_sf_bessel_Y1 foreign import ccall "bessel.h gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_Yn_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_Yn_e :: Int -> Double -> (Double,Double) bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x foreign import ccall "bessel.h gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Yn(int n,double x); +-- +-- bessel_Yn :: Int -> Double -> Double bessel_Yn = gsl_sf_bessel_Yn foreign import ccall "bessel.h gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_Yn_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_Yn_array = gsl_sf_bessel_Yn_array foreign import ccall "bessel.h gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_I0_e(double x,gsl_sf_result* result); +-- +-- bessel_I0_e :: Double -> (Double,Double) bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x foreign import ccall "bessel.h gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_I0(double x); +-- +-- bessel_I0 :: Double -> Double bessel_I0 = gsl_sf_bessel_I0 foreign import ccall "bessel.h gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_I1_e(double x,gsl_sf_result* result); +-- +-- bessel_I1_e :: Double -> (Double,Double) bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x foreign import ccall "bessel.h gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_I1(double x); +-- +-- bessel_I1 :: Double -> Double bessel_I1 = gsl_sf_bessel_I1 foreign import ccall "bessel.h gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_In_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_In_e :: Int -> Double -> (Double,Double) bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x foreign import ccall "bessel.h gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_In(int n,double x); +-- +-- bessel_In :: Int -> Double -> Double bessel_In = gsl_sf_bessel_In foreign import ccall "bessel.h gsl_sf_bessel_In" gsl_sf_bessel_In :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_In_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_In_array = gsl_sf_bessel_In_array foreign import ccall "bessel.h gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_I0_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_I0_scaled_e :: Double -> (Double,Double) bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_I0_scaled(double x); +-- +-- bessel_I0_scaled :: Double -> Double bessel_I0_scaled = gsl_sf_bessel_I0_scaled foreign import ccall "bessel.h gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_I1_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_I1_scaled_e :: Double -> (Double,Double) bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_I1_scaled(double x); +-- +-- bessel_I1_scaled :: Double -> Double bessel_I1_scaled = gsl_sf_bessel_I1_scaled foreign import ccall "bessel.h gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_In_scaled_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_In_scaled_e :: Int -> Double -> (Double,Double) bessel_In_scaled_e n x = createSFR "bessel_In_scaled_e" $ gsl_sf_bessel_In_scaled_e n x foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_In_scaled(int n,double x); +-- +-- bessel_In_scaled :: Int -> Double -> Double bessel_In_scaled = gsl_sf_bessel_In_scaled foreign import ccall "bessel.h gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_In_scaled_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array foreign import ccall "bessel.h gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_K0_e(double x,gsl_sf_result* result); +-- +-- bessel_K0_e :: Double -> (Double,Double) bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x foreign import ccall "bessel.h gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_K0(double x); +-- +-- bessel_K0 :: Double -> Double bessel_K0 = gsl_sf_bessel_K0 foreign import ccall "bessel.h gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_K1_e(double x,gsl_sf_result* result); +-- +-- bessel_K1_e :: Double -> (Double,Double) bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x foreign import ccall "bessel.h gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_K1(double x); +-- +-- bessel_K1 :: Double -> Double bessel_K1 = gsl_sf_bessel_K1 foreign import ccall "bessel.h gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_Kn_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_Kn_e :: Int -> Double -> (Double,Double) bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x foreign import ccall "bessel.h gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Kn(int n,double x); +-- +-- bessel_Kn :: Int -> Double -> Double bessel_Kn = gsl_sf_bessel_Kn foreign import ccall "bessel.h gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_Kn_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_Kn_array = gsl_sf_bessel_Kn_array foreign import ccall "bessel.h gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_K0_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_K0_scaled_e :: Double -> (Double,Double) bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_K0_scaled(double x); +-- +-- bessel_K0_scaled :: Double -> Double bessel_K0_scaled = gsl_sf_bessel_K0_scaled foreign import ccall "bessel.h gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_K1_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_K1_scaled_e :: Double -> (Double,Double) bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_K1_scaled(double x); +-- +-- bessel_K1_scaled :: Double -> Double bessel_K1_scaled = gsl_sf_bessel_K1_scaled foreign import ccall "bessel.h gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_Kn_scaled_e(int n,double x,gsl_sf_result* result); +-- +-- bessel_Kn_scaled_e :: Int -> Double -> (Double,Double) bessel_Kn_scaled_e n x = createSFR "bessel_Kn_scaled_e" $ gsl_sf_bessel_Kn_scaled_e n x foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Kn_scaled(int n,double x); +-- +-- bessel_Kn_scaled :: Int -> Double -> Double bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_Kn_scaled_array(int nmin,int nmax,double x,double* result_array); +-- +-- bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array foreign import ccall "bessel.h gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: Int -> Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_j0_e(double x,gsl_sf_result* result); +-- +-- bessel_j0_e :: Double -> (Double,Double) bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x foreign import ccall "bessel.h gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_j0(double x); +-- +-- bessel_j0 :: Double -> Double bessel_j0 = gsl_sf_bessel_j0 foreign import ccall "bessel.h gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_j1_e(double x,gsl_sf_result* result); +-- +-- bessel_j1_e :: Double -> (Double,Double) bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x foreign import ccall "bessel.h gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_j1(double x); +-- +-- bessel_j1 :: Double -> Double bessel_j1 = gsl_sf_bessel_j1 foreign import ccall "bessel.h gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_j2_e(double x,gsl_sf_result* result); +-- +-- bessel_j2_e :: Double -> (Double,Double) bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x foreign import ccall "bessel.h gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_j2(double x); +-- +-- bessel_j2 :: Double -> Double bessel_j2 = gsl_sf_bessel_j2 foreign import ccall "bessel.h gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double -- | wrapper for int gsl_sf_bessel_jl_e(int l,double x,gsl_sf_result* result); +-- +-- bessel_jl_e :: Int -> Double -> (Double,Double) bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x foreign import ccall "bessel.h gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_jl(int l,double x); +-- +-- bessel_jl :: Int -> Double -> Double bessel_jl = gsl_sf_bessel_jl foreign import ccall "bessel.h gsl_sf_bessel_jl" gsl_sf_bessel_jl :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_jl_array(int lmax,double x,double* result_array); +-- +-- bessel_jl_array :: Int -> Double -> Ptr Double -> Int bessel_jl_array = gsl_sf_bessel_jl_array foreign import ccall "bessel.h gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_jl_steed_array(int lmax,double x,double* jl_x_array); +-- +-- bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array foreign import ccall "bessel.h gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_y0_e(double x,gsl_sf_result* result); +-- +-- bessel_y0_e :: Double -> (Double,Double) bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x foreign import ccall "bessel.h gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_y0(double x); +-- +-- bessel_y0 :: Double -> Double bessel_y0 = gsl_sf_bessel_y0 foreign import ccall "bessel.h gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double -- | wrapper for int gsl_sf_bessel_y1_e(double x,gsl_sf_result* result); +-- +-- bessel_y1_e :: Double -> (Double,Double) bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x foreign import ccall "bessel.h gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_y1(double x); +-- +-- bessel_y1 :: Double -> Double bessel_y1 = gsl_sf_bessel_y1 foreign import ccall "bessel.h gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double -- | wrapper for int gsl_sf_bessel_y2_e(double x,gsl_sf_result* result); +-- +-- bessel_y2_e :: Double -> (Double,Double) bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x foreign import ccall "bessel.h gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_y2(double x); +-- +-- bessel_y2 :: Double -> Double bessel_y2 = gsl_sf_bessel_y2 foreign import ccall "bessel.h gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double -- | wrapper for int gsl_sf_bessel_yl_e(int l,double x,gsl_sf_result* result); +-- +-- bessel_yl_e :: Int -> Double -> (Double,Double) bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x foreign import ccall "bessel.h gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_yl(int l,double x); +-- +-- bessel_yl :: Int -> Double -> Double bessel_yl = gsl_sf_bessel_yl foreign import ccall "bessel.h gsl_sf_bessel_yl" gsl_sf_bessel_yl :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_yl_array(int lmax,double x,double* result_array); +-- +-- bessel_yl_array :: Int -> Double -> Ptr Double -> Int bessel_yl_array = gsl_sf_bessel_yl_array foreign import ccall "bessel.h gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_i0_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_i0_scaled_e :: Double -> (Double,Double) bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_i0_scaled(double x); +-- +-- bessel_i0_scaled :: Double -> Double bessel_i0_scaled = gsl_sf_bessel_i0_scaled foreign import ccall "bessel.h gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_i1_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_i1_scaled_e :: Double -> (Double,Double) bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_i1_scaled(double x); +-- +-- bessel_i1_scaled :: Double -> Double bessel_i1_scaled = gsl_sf_bessel_i1_scaled foreign import ccall "bessel.h gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_i2_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_i2_scaled_e :: Double -> (Double,Double) bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_i2_scaled(double x); +-- +-- bessel_i2_scaled :: Double -> Double bessel_i2_scaled = gsl_sf_bessel_i2_scaled foreign import ccall "bessel.h gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_il_scaled_e(int l,double x,gsl_sf_result* result); +-- +-- bessel_il_scaled_e :: Int -> Double -> (Double,Double) bessel_il_scaled_e l x = createSFR "bessel_il_scaled_e" $ gsl_sf_bessel_il_scaled_e l x foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_il_scaled(int l,double x); +-- +-- bessel_il_scaled :: Int -> Double -> Double bessel_il_scaled = gsl_sf_bessel_il_scaled foreign import ccall "bessel.h gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_il_scaled_array(int lmax,double x,double* result_array); +-- +-- bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array foreign import ccall "bessel.h gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_k0_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_k0_scaled_e :: Double -> (Double,Double) bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_k0_scaled(double x); +-- +-- bessel_k0_scaled :: Double -> Double bessel_k0_scaled = gsl_sf_bessel_k0_scaled foreign import ccall "bessel.h gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_k1_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_k1_scaled_e :: Double -> (Double,Double) bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_k1_scaled(double x); +-- +-- bessel_k1_scaled :: Double -> Double bessel_k1_scaled = gsl_sf_bessel_k1_scaled foreign import ccall "bessel.h gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_k2_scaled_e(double x,gsl_sf_result* result); +-- +-- bessel_k2_scaled_e :: Double -> (Double,Double) bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_k2_scaled(double x); +-- +-- bessel_k2_scaled :: Double -> Double bessel_k2_scaled = gsl_sf_bessel_k2_scaled foreign import ccall "bessel.h gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double -- | wrapper for int gsl_sf_bessel_kl_scaled_e(int l,double x,gsl_sf_result* result); +-- +-- bessel_kl_scaled_e :: Int -> Double -> (Double,Double) bessel_kl_scaled_e l x = createSFR "bessel_kl_scaled_e" $ gsl_sf_bessel_kl_scaled_e l x foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_kl_scaled(int l,double x); +-- +-- bessel_kl_scaled :: Int -> Double -> Double bessel_kl_scaled = gsl_sf_bessel_kl_scaled foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: Int -> Double -> Double -- | wrapper for int gsl_sf_bessel_kl_scaled_array(int lmax,double x,double* result_array); +-- +-- bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array foreign import ccall "bessel.h gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: Int -> Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_bessel_Jnu_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Jnu_e :: Double -> Double -> (Double,Double) bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Jnu(double nu,double x); +-- +-- bessel_Jnu :: Double -> Double -> Double bessel_Jnu = gsl_sf_bessel_Jnu foreign import ccall "bessel.h gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_Ynu_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Ynu_e :: Double -> Double -> (Double,Double) bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Ynu(double nu,double x); +-- +-- bessel_Ynu :: Double -> Double -> Double bessel_Ynu = gsl_sf_bessel_Ynu foreign import ccall "bessel.h gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double +-- | wrapper for int gsl_sf_bessel_sequence_Jnu_e(double nu,gsl_mode_t mode,size_t size,double* v); +-- +-- +bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> Int +bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu (precCode mode) size v +foreign import ccall "bessel.h gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> Int + -- | wrapper for int gsl_sf_bessel_Inu_scaled_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Inu_scaled_e :: Double -> Double -> (Double,Double) bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Inu_scaled(double nu,double x); +-- +-- bessel_Inu_scaled :: Double -> Double -> Double bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled foreign import ccall "bessel.h gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_Inu_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Inu_e :: Double -> Double -> (Double,Double) bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Inu(double nu,double x); +-- +-- bessel_Inu :: Double -> Double -> Double bessel_Inu = gsl_sf_bessel_Inu foreign import ccall "bessel.h gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_Knu_scaled_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Knu_scaled_e :: Double -> Double -> (Double,Double) bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Knu_scaled(double nu,double x); +-- +-- bessel_Knu_scaled :: Double -> Double -> Double bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled foreign import ccall "bessel.h gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_Knu_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_Knu_e :: Double -> Double -> (Double,Double) bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x foreign import ccall "bessel.h gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_Knu(double nu,double x); +-- +-- bessel_Knu :: Double -> Double -> Double bessel_Knu = gsl_sf_bessel_Knu foreign import ccall "bessel.h gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_lnKnu_e(double nu,double x,gsl_sf_result* result); +-- +-- bessel_lnKnu_e :: Double -> Double -> (Double,Double) bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x foreign import ccall "bessel.h gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_lnKnu(double nu,double x); +-- +-- bessel_lnKnu :: Double -> Double -> Double bessel_lnKnu = gsl_sf_bessel_lnKnu foreign import ccall "bessel.h gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double -- | wrapper for int gsl_sf_bessel_zero_J0_e(int s,gsl_sf_result* result); +-- +-- bessel_zero_J0_e :: Int -> (Double,Double) bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s foreign import ccall "bessel.h gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_zero_J0(int s); +-- +-- bessel_zero_J0 :: Int -> Double bessel_zero_J0 = gsl_sf_bessel_zero_J0 foreign import ccall "bessel.h gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: Int -> Double -- | wrapper for int gsl_sf_bessel_zero_J1_e(int s,gsl_sf_result* result); +-- +-- bessel_zero_J1_e :: Int -> (Double,Double) bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s foreign import ccall "bessel.h gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_zero_J1(int s); +-- +-- bessel_zero_J1 :: Int -> Double bessel_zero_J1 = gsl_sf_bessel_zero_J1 foreign import ccall "bessel.h gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: Int -> Double -- | wrapper for int gsl_sf_bessel_zero_Jnu_e(double nu,int s,gsl_sf_result* result); +-- +-- bessel_zero_Jnu_e :: Double -> Int -> (Double,Double) bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_bessel_zero_Jnu(double nu,int s); +-- +-- bessel_zero_Jnu :: Double -> Int -> Double bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu foreign import ccall "bessel.h gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> Int -> Double diff --git a/lib/GSL/Special/Clausen.hs b/lib/GSL/Special/Clausen.hs index 33da421..57c8878 100644 --- a/lib/GSL/Special/Clausen.hs +++ b/lib/GSL/Special/Clausen.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -23,11 +23,15 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_clausen_e(double x,gsl_sf_result* result); +-- +-- clausen_e :: Double -> (Double,Double) clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x foreign import ccall "clausen.h gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_clausen(double x); +-- +-- clausen :: Double -> Double clausen = gsl_sf_clausen foreign import ccall "clausen.h gsl_sf_clausen" gsl_sf_clausen :: Double -> Double diff --git a/lib/GSL/Special/Coulomb.hs b/lib/GSL/Special/Coulomb.hs index 6995ee3..a60b724 100644 --- a/lib/GSL/Special/Coulomb.hs +++ b/lib/GSL/Special/Coulomb.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -26,56 +26,78 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_hydrogenicR_1_e(double Z,double r,gsl_sf_result* result); +-- +-- hydrogenicR_1_e :: Double -> Double -> (Double,Double) hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hydrogenicR_1(double Z,double r); +-- +-- hydrogenicR_1 :: Double -> Double -> Double hydrogenicR_1 = gsl_sf_hydrogenicR_1 foreign import ccall "coulomb.h gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double -- | wrapper for int gsl_sf_hydrogenicR_e(int n,int l,double Z,double r,gsl_sf_result* result); +-- +-- hydrogenicR_e :: Int -> Int -> Double -> Double -> (Double,Double) hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r foreign import ccall "coulomb.h gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: Int -> Int -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hydrogenicR(int n,int l,double Z,double r); +-- +-- hydrogenicR :: Int -> Int -> Double -> Double -> Double hydrogenicR = gsl_sf_hydrogenicR foreign import ccall "coulomb.h gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: Int -> Int -> Double -> Double -> Double -- | wrapper for int gsl_sf_coulomb_wave_FG_e(double eta,double x,double lam_F,int k_lam_G,gsl_sf_result* F,gsl_sf_result* Fp,gsl_sf_result* G,gsl_sf_result* Gp,double* exp_F,double* exp_G); +-- +-- coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> Int -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_coulomb_wave_F_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent); +-- +-- coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array foreign import ccall "coulomb.h gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_coulomb_wave_FG_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* gc_array,double* F_exponent,double* G_exponent); +-- +-- coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_coulomb_wave_FGp_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* fcp_array,double* gc_array,double* gcp_array,double* F_exponent,double* G_exponent); +-- +-- coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array foreign import ccall "coulomb.h gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_coulomb_wave_sphF_array(double lam_min,int kmax,double eta,double x,double* fc_array,double* F_exponent); +-- +-- coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array foreign import ccall "coulomb.h gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> Int -> Double -> Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_coulomb_CL_e(double L,double eta,gsl_sf_result* result); +-- +-- coulomb_CL_e :: Double -> Double -> (Double,Double) coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta foreign import ccall "coulomb.h gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_coulomb_CL_array(double Lmin,int kmax,double eta,double* cl); +-- +-- coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int coulomb_CL_array = gsl_sf_coulomb_CL_array foreign import ccall "coulomb.h gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> Int -> Double -> Ptr Double -> Int diff --git a/lib/GSL/Special/Dawson.hs b/lib/GSL/Special/Dawson.hs index 54671e1..69d0127 100644 --- a/lib/GSL/Special/Dawson.hs +++ b/lib/GSL/Special/Dawson.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -23,11 +23,15 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_dawson_e(double x,gsl_sf_result* result); +-- +-- dawson_e :: Double -> (Double,Double) dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x foreign import ccall "dawson.h gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_dawson(double x); +-- +-- dawson :: Double -> Double dawson = gsl_sf_dawson foreign import ccall "dawson.h gsl_sf_dawson" gsl_sf_dawson :: Double -> Double diff --git a/lib/GSL/Special/Debye.hs b/lib/GSL/Special/Debye.hs index ecb617e..55f5158 100644 --- a/lib/GSL/Special/Debye.hs +++ b/lib/GSL/Special/Debye.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -29,41 +29,57 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_debye_1_e(double x,gsl_sf_result* result); +-- +-- debye_1_e :: Double -> (Double,Double) debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x foreign import ccall "debye.h gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_debye_1(double x); +-- +-- debye_1 :: Double -> Double debye_1 = gsl_sf_debye_1 foreign import ccall "debye.h gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double -- | wrapper for int gsl_sf_debye_2_e(double x,gsl_sf_result* result); +-- +-- debye_2_e :: Double -> (Double,Double) debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x foreign import ccall "debye.h gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_debye_2(double x); +-- +-- debye_2 :: Double -> Double debye_2 = gsl_sf_debye_2 foreign import ccall "debye.h gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double -- | wrapper for int gsl_sf_debye_3_e(double x,gsl_sf_result* result); +-- +-- debye_3_e :: Double -> (Double,Double) debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x foreign import ccall "debye.h gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_debye_3(double x); +-- +-- debye_3 :: Double -> Double debye_3 = gsl_sf_debye_3 foreign import ccall "debye.h gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double -- | wrapper for int gsl_sf_debye_4_e(double x,gsl_sf_result* result); +-- +-- debye_4_e :: Double -> (Double,Double) debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x foreign import ccall "debye.h gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_debye_4(double x); +-- +-- debye_4 :: Double -> Double debye_4 = gsl_sf_debye_4 foreign import ccall "debye.h gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double diff --git a/lib/GSL/Special/Dilog.hs b/lib/GSL/Special/Dilog.hs index c7412dd..5575895 100644 --- a/lib/GSL/Special/Dilog.hs +++ b/lib/GSL/Special/Dilog.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -23,26 +23,36 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_dilog_e(double x,gsl_sf_result* result); +-- +-- dilog_e :: Double -> (Double,Double) dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x foreign import ccall "dilog.h gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_dilog(double x); +-- +-- dilog :: Double -> Double dilog = gsl_sf_dilog foreign import ccall "dilog.h gsl_sf_dilog" gsl_sf_dilog :: Double -> Double -- | wrapper for int gsl_sf_complex_dilog_xy_e(double x,double y,gsl_sf_result* result_re,gsl_sf_result* result_im); +-- +-- complex_dilog_xy_e :: Double -> Double -> Ptr Double -> (Double,Double) complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re foreign import ccall "dilog.h gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_complex_dilog_e(double r,double theta,gsl_sf_result* result_re,gsl_sf_result* result_im); +-- +-- complex_dilog_e :: Double -> Double -> Ptr Double -> (Double,Double) complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re foreign import ccall "dilog.h gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_complex_spence_xy_e(double x,double y,gsl_sf_result* real_sp,gsl_sf_result* imag_sp); +-- +-- complex_spence_xy_e :: Double -> Double -> Ptr Double -> (Double,Double) complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp foreign import ccall "dilog.h gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int) diff --git a/lib/GSL/Special/Elementary.hs b/lib/GSL/Special/Elementary.hs index 1eab1ce..da927a2 100644 --- a/lib/GSL/Special/Elementary.hs +++ b/lib/GSL/Special/Elementary.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -24,16 +24,22 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_multiply_e(double x,double y,gsl_sf_result* result); +-- +-- multiply_e :: Double -> Double -> (Double,Double) multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y foreign import ccall "elementary.h gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_multiply(double x,double y); +-- +-- multiply :: Double -> Double -> Double multiply = gsl_sf_multiply foreign import ccall "elementary.h gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double -- | wrapper for int gsl_sf_multiply_err_e(double x,double dx,double y,double dy,gsl_sf_result* result); +-- +-- multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double) multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy foreign import ccall "elementary.h gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int) diff --git a/lib/GSL/Special/Ellint.hs b/lib/GSL/Special/Ellint.hs index b277072..dddbe21 100644 --- a/lib/GSL/Special/Ellint.hs +++ b/lib/GSL/Special/Ellint.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -41,101 +41,141 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_ellint_Kcomp_e(double k,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_Kcomp_e :: Double -> Precision -> (Double,Double) ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_Kcomp(double k,gsl_mode_t mode); +-- +-- ellint_Kcomp :: Double -> Precision -> Double ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_Ecomp_e(double k,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_Ecomp_e :: Double -> Precision -> (Double,Double) ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_Ecomp(double k,gsl_mode_t mode); +-- +-- ellint_Ecomp :: Double -> Precision -> Double ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_F_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_F_e :: Double -> Double -> Precision -> (Double,Double) ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_F(double phi,double k,gsl_mode_t mode); +-- +-- ellint_F :: Double -> Double -> Precision -> Double ellint_F phi k mode = gsl_sf_ellint_F phi k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_E_e(double phi,double k,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_E_e :: Double -> Double -> Precision -> (Double,Double) ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_E(double phi,double k,gsl_mode_t mode); +-- +-- ellint_E :: Double -> Double -> Precision -> Double ellint_E phi k mode = gsl_sf_ellint_E phi k (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_P_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double) ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_P(double phi,double k,double n,gsl_mode_t mode); +-- +-- ellint_P :: Double -> Double -> Double -> Precision -> Double ellint_P phi k n mode = gsl_sf_ellint_P phi k n (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_D_e(double phi,double k,double n,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double) ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_D(double phi,double k,double n,gsl_mode_t mode); +-- +-- ellint_D :: Double -> Double -> Double -> Precision -> Double ellint_D phi k n mode = gsl_sf_ellint_D phi k n (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_RC_e(double x,double y,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_RC_e :: Double -> Double -> Precision -> (Double,Double) ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_RC(double x,double y,gsl_mode_t mode); +-- +-- ellint_RC :: Double -> Double -> Precision -> Double ellint_RC x y mode = gsl_sf_ellint_RC x y (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_RD_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double) ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_RD(double x,double y,double z,gsl_mode_t mode); +-- +-- ellint_RD :: Double -> Double -> Double -> Precision -> Double ellint_RD x y z mode = gsl_sf_ellint_RD x y z (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_RF_e(double x,double y,double z,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double) ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_RF(double x,double y,double z,gsl_mode_t mode); +-- +-- ellint_RF :: Double -> Double -> Double -> Precision -> Double ellint_RF x y z mode = gsl_sf_ellint_RF x y z (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double -- | wrapper for int gsl_sf_ellint_RJ_e(double x,double y,double z,double p,gsl_mode_t mode,gsl_sf_result* result); +-- +-- ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double) ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_ellint_RJ(double x,double y,double z,double p,gsl_mode_t mode); +-- +-- ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p (precCode mode) foreign import ccall "ellint.h gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double diff --git a/lib/GSL/Special/Erf.hs b/lib/GSL/Special/Erf.hs index 30b7817..6dc5abb 100644 --- a/lib/GSL/Special/Erf.hs +++ b/lib/GSL/Special/Erf.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -33,61 +33,85 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_erfc_e(double x,gsl_sf_result* result); +-- +-- erfc_e :: Double -> (Double,Double) erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x foreign import ccall "erf.h gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_erfc(double x); +-- +-- erfc :: Double -> Double erfc = gsl_sf_erfc foreign import ccall "erf.h gsl_sf_erfc" gsl_sf_erfc :: Double -> Double -- | wrapper for int gsl_sf_log_erfc_e(double x,gsl_sf_result* result); +-- +-- log_erfc_e :: Double -> (Double,Double) log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x foreign import ccall "erf.h gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_log_erfc(double x); +-- +-- log_erfc :: Double -> Double log_erfc = gsl_sf_log_erfc foreign import ccall "erf.h gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double -- | wrapper for int gsl_sf_erf_e(double x,gsl_sf_result* result); +-- +-- erf_e :: Double -> (Double,Double) erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x foreign import ccall "erf.h gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_erf(double x); +-- +-- erf :: Double -> Double erf = gsl_sf_erf foreign import ccall "erf.h gsl_sf_erf" gsl_sf_erf :: Double -> Double -- | wrapper for int gsl_sf_erf_Z_e(double x,gsl_sf_result* result); +-- +-- erf_Z_e :: Double -> (Double,Double) erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x foreign import ccall "erf.h gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_erf_Q_e(double x,gsl_sf_result* result); +-- +-- erf_Q_e :: Double -> (Double,Double) erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x foreign import ccall "erf.h gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_erf_Z(double x); +-- +-- erf_Z :: Double -> Double erf_Z = gsl_sf_erf_Z foreign import ccall "erf.h gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double -- | wrapper for double gsl_sf_erf_Q(double x); +-- +-- erf_Q :: Double -> Double erf_Q = gsl_sf_erf_Q foreign import ccall "erf.h gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double -- | wrapper for int gsl_sf_hazard_e(double x,gsl_sf_result* result); +-- +-- hazard_e :: Double -> (Double,Double) hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x foreign import ccall "erf.h gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hazard(double x); +-- +-- hazard :: Double -> Double hazard = gsl_sf_hazard foreign import ccall "erf.h gsl_sf_hazard" gsl_sf_hazard :: Double -> Double diff --git a/lib/GSL/Special/Expint.hs b/lib/GSL/Special/Expint.hs index 6dd5959..4e1b2b5 100644 --- a/lib/GSL/Special/Expint.hs +++ b/lib/GSL/Special/Expint.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -45,121 +45,169 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_expint_E1_e(double x,gsl_sf_result* result); +-- +-- expint_E1_e :: Double -> (Double,Double) expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x foreign import ccall "expint.h gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_E1(double x); +-- +-- expint_E1 :: Double -> Double expint_E1 = gsl_sf_expint_E1 foreign import ccall "expint.h gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double -- | wrapper for int gsl_sf_expint_E2_e(double x,gsl_sf_result* result); +-- +-- expint_E2_e :: Double -> (Double,Double) expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x foreign import ccall "expint.h gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_E2(double x); +-- +-- expint_E2 :: Double -> Double expint_E2 = gsl_sf_expint_E2 foreign import ccall "expint.h gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double -- | wrapper for int gsl_sf_expint_E1_scaled_e(double x,gsl_sf_result* result); +-- +-- expint_E1_scaled_e :: Double -> (Double,Double) expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x foreign import ccall "expint.h gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_E1_scaled(double x); +-- +-- expint_E1_scaled :: Double -> Double expint_E1_scaled = gsl_sf_expint_E1_scaled foreign import ccall "expint.h gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double -- | wrapper for int gsl_sf_expint_E2_scaled_e(double x,gsl_sf_result* result); +-- +-- expint_E2_scaled_e :: Double -> (Double,Double) expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x foreign import ccall "expint.h gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_E2_scaled(double x); +-- +-- expint_E2_scaled :: Double -> Double expint_E2_scaled = gsl_sf_expint_E2_scaled foreign import ccall "expint.h gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double -- | wrapper for int gsl_sf_expint_Ei_e(double x,gsl_sf_result* result); +-- +-- expint_Ei_e :: Double -> (Double,Double) expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x foreign import ccall "expint.h gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_Ei(double x); +-- +-- expint_Ei :: Double -> Double expint_Ei = gsl_sf_expint_Ei foreign import ccall "expint.h gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double -- | wrapper for int gsl_sf_expint_Ei_scaled_e(double x,gsl_sf_result* result); +-- +-- expint_Ei_scaled_e :: Double -> (Double,Double) expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x foreign import ccall "expint.h gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_Ei_scaled(double x); +-- +-- expint_Ei_scaled :: Double -> Double expint_Ei_scaled = gsl_sf_expint_Ei_scaled foreign import ccall "expint.h gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double -- | wrapper for int gsl_sf_Shi_e(double x,gsl_sf_result* result); +-- +-- shi_e :: Double -> (Double,Double) shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x foreign import ccall "expint.h gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_Shi(double x); +-- +-- shi :: Double -> Double shi = gsl_sf_Shi foreign import ccall "expint.h gsl_sf_Shi" gsl_sf_Shi :: Double -> Double -- | wrapper for int gsl_sf_Chi_e(double x,gsl_sf_result* result); +-- +-- chi_e :: Double -> (Double,Double) chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x foreign import ccall "expint.h gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_Chi(double x); +-- +-- chi :: Double -> Double chi = gsl_sf_Chi foreign import ccall "expint.h gsl_sf_Chi" gsl_sf_Chi :: Double -> Double -- | wrapper for int gsl_sf_expint_3_e(double x,gsl_sf_result* result); +-- +-- expint_3_e :: Double -> (Double,Double) expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x foreign import ccall "expint.h gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_expint_3(double x); +-- +-- expint_3 :: Double -> Double expint_3 = gsl_sf_expint_3 foreign import ccall "expint.h gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double -- | wrapper for int gsl_sf_Si_e(double x,gsl_sf_result* result); +-- +-- si_e :: Double -> (Double,Double) si_e x = createSFR "si_e" $ gsl_sf_Si_e x foreign import ccall "expint.h gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_Si(double x); +-- +-- si :: Double -> Double si = gsl_sf_Si foreign import ccall "expint.h gsl_sf_Si" gsl_sf_Si :: Double -> Double -- | wrapper for int gsl_sf_Ci_e(double x,gsl_sf_result* result); +-- +-- ci_e :: Double -> (Double,Double) ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x foreign import ccall "expint.h gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_Ci(double x); +-- +-- ci :: Double -> Double ci = gsl_sf_Ci foreign import ccall "expint.h gsl_sf_Ci" gsl_sf_Ci :: Double -> Double -- | wrapper for int gsl_sf_atanint_e(double x,gsl_sf_result* result); +-- +-- atanint_e :: Double -> (Double,Double) atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x foreign import ccall "expint.h gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_atanint(double x); +-- +-- atanint :: Double -> Double atanint = gsl_sf_atanint foreign import ccall "expint.h gsl_sf_atanint" gsl_sf_atanint :: Double -> Double diff --git a/lib/GSL/Special/Fermi_dirac.hs b/lib/GSL/Special/Fermi_dirac.hs index 454ce1c..18dc3b2 100644 --- a/lib/GSL/Special/Fermi_dirac.hs +++ b/lib/GSL/Special/Fermi_dirac.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -39,91 +39,127 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_fermi_dirac_m1_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_m1_e :: Double -> (Double,Double) fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_m1(double x); +-- +-- fermi_dirac_m1 :: Double -> Double fermi_dirac_m1 = gsl_sf_fermi_dirac_m1 foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_0_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_0_e :: Double -> (Double,Double) fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_0(double x); +-- +-- fermi_dirac_0 :: Double -> Double fermi_dirac_0 = gsl_sf_fermi_dirac_0 foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_1_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_1_e :: Double -> (Double,Double) fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_1(double x); +-- +-- fermi_dirac_1 :: Double -> Double fermi_dirac_1 = gsl_sf_fermi_dirac_1 foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_2_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_2_e :: Double -> (Double,Double) fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_2(double x); +-- +-- fermi_dirac_2 :: Double -> Double fermi_dirac_2 = gsl_sf_fermi_dirac_2 foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_int_e(int j,double x,gsl_sf_result* result); +-- +-- fermi_dirac_int_e :: Int -> Double -> (Double,Double) fermi_dirac_int_e j x = createSFR "fermi_dirac_int_e" $ gsl_sf_fermi_dirac_int_e j x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_int(int j,double x); +-- +-- fermi_dirac_int :: Int -> Double -> Double fermi_dirac_int = gsl_sf_fermi_dirac_int foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: Int -> Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_mhalf_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_mhalf_e :: Double -> (Double,Double) fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_mhalf(double x); +-- +-- fermi_dirac_mhalf :: Double -> Double fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_half_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_half_e :: Double -> (Double,Double) fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_half(double x); +-- +-- fermi_dirac_half :: Double -> Double fermi_dirac_half = gsl_sf_fermi_dirac_half foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_3half_e(double x,gsl_sf_result* result); +-- +-- fermi_dirac_3half_e :: Double -> (Double,Double) fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_3half(double x); +-- +-- fermi_dirac_3half :: Double -> Double fermi_dirac_3half = gsl_sf_fermi_dirac_3half foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double -- | wrapper for int gsl_sf_fermi_dirac_inc_0_e(double x,double b,gsl_sf_result* result); +-- +-- fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double) fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fermi_dirac_inc_0(double x,double b); +-- +-- fermi_dirac_inc_0 :: Double -> Double -> Double fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0 foreign import ccall "fermi_dirac.h gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double diff --git a/lib/GSL/Special/Gamma.hs b/lib/GSL/Special/Gamma.hs index 4586cb5..ae5010d 100644 --- a/lib/GSL/Special/Gamma.hs +++ b/lib/GSL/Special/Gamma.hs @@ -9,8 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - - + -} ------------------------------------------------------------ @@ -62,216 +61,302 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_lngamma_e(double x,gsl_sf_result* result); +-- +-- lngamma_e :: Double -> (Double,Double) lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x foreign import ccall "gamma.h gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lngamma(double x); +-- +-- lngamma :: Double -> Double lngamma = gsl_sf_lngamma foreign import ccall "gamma.h gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double -- | wrapper for int gsl_sf_lngamma_sgn_e(double x,gsl_sf_result* result_lg,double* sgn); +-- +-- lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int lngamma_sgn_e = gsl_sf_lngamma_sgn_e foreign import ccall "gamma.h gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_gamma_e(double x,gsl_sf_result* result); +-- +-- gamma_e :: Double -> (Double,Double) gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x foreign import ccall "gamma.h gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gamma(double x); +-- +-- gamma :: Double -> Double gamma = gsl_sf_gamma foreign import ccall "gamma.h gsl_sf_gamma" gsl_sf_gamma :: Double -> Double -- | wrapper for int gsl_sf_gammastar_e(double x,gsl_sf_result* result); +-- +-- gammastar_e :: Double -> (Double,Double) gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x foreign import ccall "gamma.h gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gammastar(double x); +-- +-- gammastar :: Double -> Double gammastar = gsl_sf_gammastar foreign import ccall "gamma.h gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double -- | wrapper for int gsl_sf_gammainv_e(double x,gsl_sf_result* result); +-- +-- gammainv_e :: Double -> (Double,Double) gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x foreign import ccall "gamma.h gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gammainv(double x); +-- +-- gammainv :: Double -> Double gammainv = gsl_sf_gammainv foreign import ccall "gamma.h gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double -- | wrapper for int gsl_sf_lngamma_complex_e(double zr,double zi,gsl_sf_result* lnr,gsl_sf_result* arg); +-- +-- lngamma_complex_e :: Double -> Double -> Ptr Double -> (Double,Double) lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr foreign import ccall "gamma.h gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_taylorcoeff_e(int n,double x,gsl_sf_result* result); +-- +-- taylorcoeff_e :: Int -> Double -> (Double,Double) taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x foreign import ccall "gamma.h gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_taylorcoeff(int n,double x); +-- +-- taylorcoeff :: Int -> Double -> Double taylorcoeff = gsl_sf_taylorcoeff foreign import ccall "gamma.h gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: Int -> Double -> Double -- | wrapper for int gsl_sf_fact_e(int n,gsl_sf_result* result); +-- +-- fact_e :: Int -> (Double,Double) fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n foreign import ccall "gamma.h gsl_sf_fact_e" gsl_sf_fact_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_fact(int n); +-- +-- fact :: Int -> Double fact = gsl_sf_fact foreign import ccall "gamma.h gsl_sf_fact" gsl_sf_fact :: Int -> Double -- | wrapper for int gsl_sf_doublefact_e(int n,gsl_sf_result* result); +-- +-- doublefact_e :: Int -> (Double,Double) doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n foreign import ccall "gamma.h gsl_sf_doublefact_e" gsl_sf_doublefact_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_doublefact(int n); +-- +-- doublefact :: Int -> Double doublefact = gsl_sf_doublefact foreign import ccall "gamma.h gsl_sf_doublefact" gsl_sf_doublefact :: Int -> Double -- | wrapper for int gsl_sf_lnfact_e(int n,gsl_sf_result* result); +-- +-- lnfact_e :: Int -> (Double,Double) lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n foreign import ccall "gamma.h gsl_sf_lnfact_e" gsl_sf_lnfact_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lnfact(int n); +-- +-- lnfact :: Int -> Double lnfact = gsl_sf_lnfact foreign import ccall "gamma.h gsl_sf_lnfact" gsl_sf_lnfact :: Int -> Double -- | wrapper for int gsl_sf_lndoublefact_e(int n,gsl_sf_result* result); +-- +-- lndoublefact_e :: Int -> (Double,Double) lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n foreign import ccall "gamma.h gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lndoublefact(int n); +-- +-- lndoublefact :: Int -> Double lndoublefact = gsl_sf_lndoublefact foreign import ccall "gamma.h gsl_sf_lndoublefact" gsl_sf_lndoublefact :: Int -> Double -- | wrapper for int gsl_sf_lnchoose_e(int n,int m,gsl_sf_result* result); +-- +-- lnchoose_e :: Int -> Int -> (Double,Double) lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m foreign import ccall "gamma.h gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: Int -> Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lnchoose(int n,int m); +-- +-- lnchoose :: Int -> Int -> Double lnchoose = gsl_sf_lnchoose foreign import ccall "gamma.h gsl_sf_lnchoose" gsl_sf_lnchoose :: Int -> Int -> Double -- | wrapper for int gsl_sf_choose_e(int n,int m,gsl_sf_result* result); +-- +-- choose_e :: Int -> Int -> (Double,Double) choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m foreign import ccall "gamma.h gsl_sf_choose_e" gsl_sf_choose_e :: Int -> Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_choose(int n,int m); +-- +-- choose :: Int -> Int -> Double choose = gsl_sf_choose foreign import ccall "gamma.h gsl_sf_choose" gsl_sf_choose :: Int -> Int -> Double -- | wrapper for int gsl_sf_lnpoch_e(double a,double x,gsl_sf_result* result); +-- +-- lnpoch_e :: Double -> Double -> (Double,Double) lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x foreign import ccall "gamma.h gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lnpoch(double a,double x); +-- +-- lnpoch :: Double -> Double -> Double lnpoch = gsl_sf_lnpoch foreign import ccall "gamma.h gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double -- | wrapper for int gsl_sf_lnpoch_sgn_e(double a,double x,gsl_sf_result* result,double* sgn); +-- +-- lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e foreign import ccall "gamma.h gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr Double -> Ptr Double -> Int -- | wrapper for int gsl_sf_poch_e(double a,double x,gsl_sf_result* result); +-- +-- poch_e :: Double -> Double -> (Double,Double) poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x foreign import ccall "gamma.h gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_poch(double a,double x); +-- +-- poch :: Double -> Double -> Double poch = gsl_sf_poch foreign import ccall "gamma.h gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double -- | wrapper for int gsl_sf_pochrel_e(double a,double x,gsl_sf_result* result); +-- +-- pochrel_e :: Double -> Double -> (Double,Double) pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x foreign import ccall "gamma.h gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_pochrel(double a,double x); +-- +-- pochrel :: Double -> Double -> Double pochrel = gsl_sf_pochrel foreign import ccall "gamma.h gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double -- | wrapper for int gsl_sf_gamma_inc_Q_e(double a,double x,gsl_sf_result* result); +-- +-- gamma_inc_Q_e :: Double -> Double -> (Double,Double) gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x foreign import ccall "gamma.h gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gamma_inc_Q(double a,double x); +-- +-- gamma_inc_Q :: Double -> Double -> Double gamma_inc_Q = gsl_sf_gamma_inc_Q foreign import ccall "gamma.h gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double -- | wrapper for int gsl_sf_gamma_inc_P_e(double a,double x,gsl_sf_result* result); +-- +-- gamma_inc_P_e :: Double -> Double -> (Double,Double) gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x foreign import ccall "gamma.h gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gamma_inc_P(double a,double x); +-- +-- gamma_inc_P :: Double -> Double -> Double gamma_inc_P = gsl_sf_gamma_inc_P foreign import ccall "gamma.h gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double -- | wrapper for int gsl_sf_gamma_inc_e(double a,double x,gsl_sf_result* result); +-- +-- gamma_inc_e :: Double -> Double -> (Double,Double) gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x foreign import ccall "gamma.h gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gamma_inc(double a,double x); +-- +-- gamma_inc :: Double -> Double -> Double gamma_inc = gsl_sf_gamma_inc foreign import ccall "gamma.h gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double -- | wrapper for int gsl_sf_lnbeta_e(double a,double b,gsl_sf_result* result); +-- +-- lnbeta_e :: Double -> Double -> (Double,Double) lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b foreign import ccall "gamma.h gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lnbeta(double a,double b); +-- +-- lnbeta :: Double -> Double -> Double lnbeta = gsl_sf_lnbeta foreign import ccall "gamma.h gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double -- | wrapper for int gsl_sf_beta_e(double a,double b,gsl_sf_result* result); +-- +-- beta_e :: Double -> Double -> (Double,Double) beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b foreign import ccall "gamma.h gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_beta(double a,double b); +-- +-- beta :: Double -> Double -> Double beta = gsl_sf_beta foreign import ccall "gamma.h gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double -- | wrapper for int gsl_sf_beta_inc_e(double a,double b,double x,gsl_sf_result* result); +-- +-- beta_inc_e :: Double -> Double -> Double -> (Double,Double) beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x foreign import ccall "gamma.h gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_beta_inc(double a,double b,double x); +-- +-- beta_inc :: Double -> Double -> Double -> Double beta_inc = gsl_sf_beta_inc foreign import ccall "gamma.h gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double diff --git a/lib/GSL/Special/Gegenbauer.hs b/lib/GSL/Special/Gegenbauer.hs index d4309db..9667042 100644 --- a/lib/GSL/Special/Gegenbauer.hs +++ b/lib/GSL/Special/Gegenbauer.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -29,46 +29,64 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_gegenpoly_1_e(double lambda,double x,gsl_sf_result* result); +-- +-- gegenpoly_1_e :: Double -> Double -> (Double,Double) gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_gegenpoly_2_e(double lambda,double x,gsl_sf_result* result); +-- +-- gegenpoly_2_e :: Double -> Double -> (Double,Double) gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_gegenpoly_3_e(double lambda,double x,gsl_sf_result* result); +-- +-- gegenpoly_3_e :: Double -> Double -> (Double,Double) gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gegenpoly_1(double lambda,double x); +-- +-- gegenpoly_1 :: Double -> Double -> Double gegenpoly_1 = gsl_sf_gegenpoly_1 foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double -- | wrapper for double gsl_sf_gegenpoly_2(double lambda,double x); +-- +-- gegenpoly_2 :: Double -> Double -> Double gegenpoly_2 = gsl_sf_gegenpoly_2 foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double -- | wrapper for double gsl_sf_gegenpoly_3(double lambda,double x); +-- +-- gegenpoly_3 :: Double -> Double -> Double gegenpoly_3 = gsl_sf_gegenpoly_3 foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double -- | wrapper for int gsl_sf_gegenpoly_n_e(int n,double lambda,double x,gsl_sf_result* result); +-- +-- gegenpoly_n_e :: Int -> Double -> Double -> (Double,Double) gegenpoly_n_e n lambda x = createSFR "gegenpoly_n_e" $ gsl_sf_gegenpoly_n_e n lambda x foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_gegenpoly_n(int n,double lambda,double x); +-- +-- gegenpoly_n :: Int -> Double -> Double -> Double gegenpoly_n = gsl_sf_gegenpoly_n foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: Int -> Double -> Double -> Double -- | wrapper for int gsl_sf_gegenpoly_array(int nmax,double lambda,double x,double* result_array); +-- +-- gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int gegenpoly_array = gsl_sf_gegenpoly_array foreign import ccall "gegenbauer.h gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: Int -> Double -> Double -> Ptr Double -> Int diff --git a/lib/GSL/Special/Hyperg.hs b/lib/GSL/Special/Hyperg.hs index afe60e6..f9551eb 100644 --- a/lib/GSL/Special/Hyperg.hs +++ b/lib/GSL/Special/Hyperg.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -43,111 +43,155 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_hyperg_0F1_e(double c,double x,gsl_sf_result* result); +-- +-- hyperg_0F1_e :: Double -> Double -> (Double,Double) hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x foreign import ccall "hyperg.h gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_0F1(double c,double x); +-- +-- hyperg_0F1 :: Double -> Double -> Double hyperg_0F1 = gsl_sf_hyperg_0F1 foreign import ccall "hyperg.h gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_1F1_int_e(int m,int n,double x,gsl_sf_result* result); +-- +-- hyperg_1F1_int_e :: Int -> Int -> Double -> (Double,Double) hyperg_1F1_int_e m n x = createSFR "hyperg_1F1_int_e" $ gsl_sf_hyperg_1F1_int_e m n x foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_1F1_int(int m,int n,double x); +-- +-- hyperg_1F1_int :: Int -> Int -> Double -> Double hyperg_1F1_int = gsl_sf_hyperg_1F1_int foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: Int -> Int -> Double -> Double -- | wrapper for int gsl_sf_hyperg_1F1_e(double a,double b,double x,gsl_sf_result* result); +-- +-- hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double) hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x foreign import ccall "hyperg.h gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_1F1(double a,double b,double x); +-- +-- hyperg_1F1 :: Double -> Double -> Double -> Double hyperg_1F1 = gsl_sf_hyperg_1F1 foreign import ccall "hyperg.h gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_U_int_e(int m,int n,double x,gsl_sf_result* result); +-- +-- hyperg_U_int_e :: Int -> Int -> Double -> (Double,Double) hyperg_U_int_e m n x = createSFR "hyperg_U_int_e" $ gsl_sf_hyperg_U_int_e m n x foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: Int -> Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_U_int(int m,int n,double x); +-- +-- hyperg_U_int :: Int -> Int -> Double -> Double hyperg_U_int = gsl_sf_hyperg_U_int foreign import ccall "hyperg.h gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: Int -> Int -> Double -> Double -- | wrapper for int gsl_sf_hyperg_U_int_e10_e(int m,int n,double x,gsl_sf_result_e10* result); +-- +-- hyperg_U_int_e10_e :: Int -> Int -> Double -> (Double,Int,Double) hyperg_U_int_e10_e m n x = createSFR_E10 "hyperg_U_int_e10_e" $ gsl_sf_hyperg_U_int_e10_e m n x foreign import ccall "hyperg.h gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: Int -> Int -> Double -> Ptr () -> IO(Int) -- | wrapper for int gsl_sf_hyperg_U_e(double a,double b,double x,gsl_sf_result* result); +-- +-- hyperg_U_e :: Double -> Double -> Double -> (Double,Double) hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x foreign import ccall "hyperg.h gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_U(double a,double b,double x); +-- +-- hyperg_U :: Double -> Double -> Double -> Double hyperg_U = gsl_sf_hyperg_U foreign import ccall "hyperg.h gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_U_e10_e(double a,double b,double x,gsl_sf_result_e10* result); +-- +-- hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double) hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x foreign import ccall "hyperg.h gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO(Int) -- | wrapper for int gsl_sf_hyperg_2F1_e(double a,double b,double c,double x,gsl_sf_result* result); +-- +-- hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double) hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_2F1(double a,double b,double c,double x); +-- +-- hyperg_2F1 :: Double -> Double -> Double -> Double -> Double hyperg_2F1 = gsl_sf_hyperg_2F1 foreign import ccall "hyperg.h gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_2F1_conj_e(double aR,double aI,double c,double x,gsl_sf_result* result); +-- +-- hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double) hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_2F1_conj(double aR,double aI,double c,double x); +-- +-- hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_2F1_renorm_e(double a,double b,double c,double x,gsl_sf_result* result); +-- +-- hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double) hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_2F1_renorm(double a,double b,double c,double x); +-- +-- hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_2F1_conj_renorm_e(double aR,double aI,double c,double x,gsl_sf_result* result); +-- +-- hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double) hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_2F1_conj_renorm(double aR,double aI,double c,double x); +-- +-- hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm foreign import ccall "hyperg.h gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double -- | wrapper for int gsl_sf_hyperg_2F0_e(double a,double b,double x,gsl_sf_result* result); +-- +-- hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double) hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x foreign import ccall "hyperg.h gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hyperg_2F0(double a,double b,double x); +-- +-- hyperg_2F0 :: Double -> Double -> Double -> Double hyperg_2F0 = gsl_sf_hyperg_2F0 foreign import ccall "hyperg.h gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double diff --git a/lib/GSL/Special/Internal.hs b/lib/GSL/Special/Internal.hs index ad1aaa2..8d81c72 100644 --- a/lib/GSL/Special/Internal.hs +++ b/lib/GSL/Special/Internal.hs @@ -20,6 +20,7 @@ module GSL.Special.Internal ( createSFR_E10, Precision(..), Gsl_mode_t, + Size_t, precCode ) where @@ -37,6 +38,8 @@ precCode PrecApprox = 2 type Gsl_mode_t = Int +type Size_t = Int + ---------------------------------------------------------------- -- | access to a sf_result createSFR :: Storable a => String -> (Ptr a -> IO Int) -> (a, a) diff --git a/lib/GSL/Special/Laguerre.hs b/lib/GSL/Special/Laguerre.hs index 61f366b..f5ab85e 100644 --- a/lib/GSL/Special/Laguerre.hs +++ b/lib/GSL/Special/Laguerre.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -29,41 +29,57 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_laguerre_1_e(double a,double x,gsl_sf_result* result); +-- +-- laguerre_1_e :: Double -> Double -> (Double,Double) laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x foreign import ccall "laguerre.h gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_laguerre_2_e(double a,double x,gsl_sf_result* result); +-- +-- laguerre_2_e :: Double -> Double -> (Double,Double) laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x foreign import ccall "laguerre.h gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for int gsl_sf_laguerre_3_e(double a,double x,gsl_sf_result* result); +-- +-- laguerre_3_e :: Double -> Double -> (Double,Double) laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x foreign import ccall "laguerre.h gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_laguerre_1(double a,double x); +-- +-- laguerre_1 :: Double -> Double -> Double laguerre_1 = gsl_sf_laguerre_1 foreign import ccall "laguerre.h gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double -- | wrapper for double gsl_sf_laguerre_2(double a,double x); +-- +-- laguerre_2 :: Double -> Double -> Double laguerre_2 = gsl_sf_laguerre_2 foreign import ccall "laguerre.h gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double -- | wrapper for double gsl_sf_laguerre_3(double a,double x); +-- +-- laguerre_3 :: Double -> Double -> Double laguerre_3 = gsl_sf_laguerre_3 foreign import ccall "laguerre.h gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double -- | wrapper for int gsl_sf_laguerre_n_e(int n,double a,double x,gsl_sf_result* result); +-- +-- laguerre_n_e :: Int -> Double -> Double -> (Double,Double) laguerre_n_e n a x = createSFR "laguerre_n_e" $ gsl_sf_laguerre_n_e n a x foreign import ccall "laguerre.h gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: Int -> Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_laguerre_n(int n,double a,double x); +-- +-- laguerre_n :: Int -> Double -> Double -> Double laguerre_n = gsl_sf_laguerre_n foreign import ccall "laguerre.h gsl_sf_laguerre_n" gsl_sf_laguerre_n :: Int -> Double -> Double -> Double diff --git a/lib/GSL/Special/Lambert.hs b/lib/GSL/Special/Lambert.hs index ded7fa0..5e8fed9 100644 --- a/lib/GSL/Special/Lambert.hs +++ b/lib/GSL/Special/Lambert.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -25,21 +25,29 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_lambert_W0_e(double x,gsl_sf_result* result); +-- +-- lambert_W0_e :: Double -> (Double,Double) lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x foreign import ccall "lambert.h gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lambert_W0(double x); +-- +-- lambert_W0 :: Double -> Double lambert_W0 = gsl_sf_lambert_W0 foreign import ccall "lambert.h gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double -- | wrapper for int gsl_sf_lambert_Wm1_e(double x,gsl_sf_result* result); +-- +-- lambert_Wm1_e :: Double -> (Double,Double) lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x foreign import ccall "lambert.h gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_lambert_Wm1(double x); +-- +-- lambert_Wm1 :: Double -> Double lambert_Wm1 = gsl_sf_lambert_Wm1 foreign import ccall "lambert.h gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double diff --git a/lib/GSL/Special/Pow_int.hs b/lib/GSL/Special/Pow_int.hs index b476a92..4142c5b 100644 --- a/lib/GSL/Special/Pow_int.hs +++ b/lib/GSL/Special/Pow_int.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -23,11 +23,15 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_pow_int_e(double x,int n,gsl_sf_result* result); +-- +-- pow_int_e :: Double -> Int -> (Double,Double) pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n foreign import ccall "pow_int.h gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_pow_int(double x,int n); +-- +-- pow_int :: Double -> Int -> Double pow_int = gsl_sf_pow_int foreign import ccall "pow_int.h gsl_sf_pow_int" gsl_sf_pow_int :: Double -> Int -> Double diff --git a/lib/GSL/Special/Psi.hs b/lib/GSL/Special/Psi.hs index 31f4f8c..bee934b 100644 --- a/lib/GSL/Special/Psi.hs +++ b/lib/GSL/Special/Psi.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -33,61 +33,85 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_psi_int_e(int n,gsl_sf_result* result); +-- +-- psi_int_e :: Int -> (Double,Double) psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n foreign import ccall "psi.h gsl_sf_psi_int_e" gsl_sf_psi_int_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi_int(int n); +-- +-- psi_int :: Int -> Double psi_int = gsl_sf_psi_int foreign import ccall "psi.h gsl_sf_psi_int" gsl_sf_psi_int :: Int -> Double -- | wrapper for int gsl_sf_psi_e(double x,gsl_sf_result* result); +-- +-- psi_e :: Double -> (Double,Double) psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x foreign import ccall "psi.h gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi(double x); +-- +-- psi :: Double -> Double psi = gsl_sf_psi foreign import ccall "psi.h gsl_sf_psi" gsl_sf_psi :: Double -> Double -- | wrapper for int gsl_sf_psi_1piy_e(double y,gsl_sf_result* result); +-- +-- psi_1piy_e :: Double -> (Double,Double) psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y foreign import ccall "psi.h gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi_1piy(double y); +-- +-- psi_1piy :: Double -> Double psi_1piy = gsl_sf_psi_1piy foreign import ccall "psi.h gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double -- | wrapper for int gsl_sf_psi_1_int_e(int n,gsl_sf_result* result); +-- +-- psi_1_int_e :: Int -> (Double,Double) psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n foreign import ccall "psi.h gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi_1_int(int n); +-- +-- psi_1_int :: Int -> Double psi_1_int = gsl_sf_psi_1_int foreign import ccall "psi.h gsl_sf_psi_1_int" gsl_sf_psi_1_int :: Int -> Double -- | wrapper for int gsl_sf_psi_1_e(double x,gsl_sf_result* result); +-- +-- psi_1_e :: Double -> (Double,Double) psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x foreign import ccall "psi.h gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi_1(double x); +-- +-- psi_1 :: Double -> Double psi_1 = gsl_sf_psi_1 foreign import ccall "psi.h gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double -- | wrapper for int gsl_sf_psi_n_e(int n,double x,gsl_sf_result* result); +-- +-- psi_n_e :: Int -> Double -> (Double,Double) psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x foreign import ccall "psi.h gsl_sf_psi_n_e" gsl_sf_psi_n_e :: Int -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_psi_n(int n,double x); +-- +-- psi_n :: Int -> Double -> Double psi_n = gsl_sf_psi_n foreign import ccall "psi.h gsl_sf_psi_n" gsl_sf_psi_n :: Int -> Double -> Double diff --git a/lib/GSL/Special/Synchrotron.hs b/lib/GSL/Special/Synchrotron.hs index 7cec281..2ed484b 100644 --- a/lib/GSL/Special/Synchrotron.hs +++ b/lib/GSL/Special/Synchrotron.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -25,21 +25,29 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_synchrotron_1_e(double x,gsl_sf_result* result); +-- +-- synchrotron_1_e :: Double -> (Double,Double) synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x foreign import ccall "synchrotron.h gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_synchrotron_1(double x); +-- +-- synchrotron_1 :: Double -> Double synchrotron_1 = gsl_sf_synchrotron_1 foreign import ccall "synchrotron.h gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double -- | wrapper for int gsl_sf_synchrotron_2_e(double x,gsl_sf_result* result); +-- +-- synchrotron_2_e :: Double -> (Double,Double) synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x foreign import ccall "synchrotron.h gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_synchrotron_2(double x); +-- +-- synchrotron_2 :: Double -> Double synchrotron_2 = gsl_sf_synchrotron_2 foreign import ccall "synchrotron.h gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double diff --git a/lib/GSL/Special/Zeta.hs b/lib/GSL/Special/Zeta.hs index 6eff537..01cfdac 100644 --- a/lib/GSL/Special/Zeta.hs +++ b/lib/GSL/Special/Zeta.hs @@ -9,7 +9,7 @@ Portability : uses ffi Wrappers for selected functions described at: - + -} ------------------------------------------------------------ @@ -35,71 +35,99 @@ import Foreign(Ptr) import GSL.Special.Internal -- | wrapper for int gsl_sf_zeta_int_e(int n,gsl_sf_result* result); +-- +-- zeta_int_e :: Int -> (Double,Double) zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n foreign import ccall "zeta.h gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_zeta_int(int n); +-- +-- zeta_int :: Int -> Double zeta_int = gsl_sf_zeta_int foreign import ccall "zeta.h gsl_sf_zeta_int" gsl_sf_zeta_int :: Int -> Double -- | wrapper for int gsl_sf_zeta_e(double s,gsl_sf_result* result); +-- +-- zeta_e :: Double -> (Double,Double) zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s foreign import ccall "zeta.h gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_zeta(double s); +-- +-- zeta :: Double -> Double zeta = gsl_sf_zeta foreign import ccall "zeta.h gsl_sf_zeta" gsl_sf_zeta :: Double -> Double -- | wrapper for int gsl_sf_zetam1_e(double s,gsl_sf_result* result); +-- +-- zetam1_e :: Double -> (Double,Double) zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s foreign import ccall "zeta.h gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_zetam1(double s); +-- +-- zetam1 :: Double -> Double zetam1 = gsl_sf_zetam1 foreign import ccall "zeta.h gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double -- | wrapper for int gsl_sf_zetam1_int_e(int s,gsl_sf_result* result); +-- +-- zetam1_int_e :: Int -> (Double,Double) zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s foreign import ccall "zeta.h gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_zetam1_int(int s); +-- +-- zetam1_int :: Int -> Double zetam1_int = gsl_sf_zetam1_int foreign import ccall "zeta.h gsl_sf_zetam1_int" gsl_sf_zetam1_int :: Int -> Double -- | wrapper for int gsl_sf_hzeta_e(double s,double q,gsl_sf_result* result); +-- +-- hzeta_e :: Double -> Double -> (Double,Double) hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q foreign import ccall "zeta.h gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_hzeta(double s,double q); +-- +-- hzeta :: Double -> Double -> Double hzeta = gsl_sf_hzeta foreign import ccall "zeta.h gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double -- | wrapper for int gsl_sf_eta_int_e(int n,gsl_sf_result* result); +-- +-- eta_int_e :: Int -> (Double,Double) eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n foreign import ccall "zeta.h gsl_sf_eta_int_e" gsl_sf_eta_int_e :: Int -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_eta_int(int n); +-- +-- eta_int :: Int -> Double eta_int = gsl_sf_eta_int foreign import ccall "zeta.h gsl_sf_eta_int" gsl_sf_eta_int :: Int -> Double -- | wrapper for int gsl_sf_eta_e(double s,gsl_sf_result* result); +-- +-- eta_e :: Double -> (Double,Double) eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s foreign import ccall "zeta.h gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr Double -> IO(Int) -- | wrapper for double gsl_sf_eta(double s); +-- +-- eta :: Double -> Double eta = gsl_sf_eta foreign import ccall "zeta.h gsl_sf_eta" gsl_sf_eta :: Double -> Double diff --git a/lib/GSL/Special/auto.hs b/lib/GSL/Special/auto.hs index a6a0f9a..0ef7d0a 100644 --- a/lib/GSL/Special/auto.hs +++ b/lib/GSL/Special/auto.hs @@ -42,9 +42,14 @@ fixC s = rep ("gsl_mode_t","int") $ rep ("gsl_sf_result","double") $ rep ("gsl_s main = do args <- getArgs - file <- readFile (args!!1) let name = args!!0 - putStrLn (args!!1) + 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) @@ -60,6 +65,10 @@ main = do writeFile (upperFirst name ++ ".hs") mod +google name = "" + modhead name = replicate 60 '-' ++ "\n" ++"{- |\n" ++"Module : GSL.Special."++upperFirst name++"\n" @@ -68,7 +77,9 @@ modhead name = replicate 60 '-' ++ "\n" ++"Maintainer : Alberto Ruiz (aruiz at um dot es)\n" ++"Stability : provisional\n" ++"Portability : uses ffi\n" - ++"\n\n\n-}\n" + ++"\nWrappers for selected functions described at:\n\n" + ++ google ( "gsl_sf_"++name++".h") + ++"\n\n-}\n" ++ replicate 60 '-' ++ "\n\n" upperFirst (x:xs) = toUpper x : xs @@ -176,7 +187,10 @@ showHt (Pointer (s:ss)) = "Ptr "++toUpper s : ss showHa (t,a) = showHt t -showFull hc h@(Header t n args) = "\n-- | wrapper for "++showC h++"\n"++ boiler h ++"\n" ++showH hc h +showFull hc h@(Header t n args) = "\n-- | wrapper for "++showC h + ++"\n--\n-- "++google n ++"\n" + ++ boiler h ++"\n" + ++showH hc h fixmd1 = rep ("Gsl_mode_t","Precision") fixmd2 = rep ("mode"," (precCode mode)") diff --git a/lib/GSL/Special/autoall.sh b/lib/GSL/Special/autoall.sh new file mode 100644 index 0000000..cb45957 --- /dev/null +++ b/lib/GSL/Special/autoall.sh @@ -0,0 +1,41 @@ +#!/bin/bash + +#Airy.hs +# include Precision (..) in the export list +#Exp.hs +# remove extern inline definition, qualify name +#Coupling +# remove deprecated INCORRECT +#Trig.hs +# qualify names +#Legendre.hs +# remove extern inline +#Log.hs +# remove extern inline, qualify name + +#runhaskell auto airy +runhaskell auto bessel +runhaskell auto clausen +runhaskell auto coulomb +#runhaskell auto coupling +runhaskell auto dawson +runhaskell auto debye +runhaskell auto dilog +runhaskell auto elementary +runhaskell auto ellint +runhaskell auto erf +#runhaskell auto exp +runhaskell auto expint +runhaskell auto fermi_dirac +runhaskell auto gamma +runhaskell auto gegenbauer +runhaskell auto hyperg +runhaskell auto laguerre +runhaskell auto lambert +#runhaskell auto legendre +#runhaskell auto log +runhaskell auto pow_int +runhaskell auto psi +runhaskell auto synchrotron +#runhaskell auto trig +runhaskell auto zeta \ No newline at end of file diff --git a/lib/GSL/Special/bessel.h b/lib/GSL/Special/bessel.h index fa166d1..5a2445d 100644 --- a/lib/GSL/Special/bessel.h +++ b/lib/GSL/Special/bessel.h @@ -81,6 +81,7 @@ int gsl_sf_bessel_Jnu_e(double nu,double x,double* result); double gsl_sf_bessel_Jnu(double nu,double x); int gsl_sf_bessel_Ynu_e(double nu,double x,double* result); double gsl_sf_bessel_Ynu(double nu,double x); +int gsl_sf_bessel_sequence_Jnu_e(double nu,int mode,size_t size,double* v); int gsl_sf_bessel_Inu_scaled_e(double nu,double x,double* result); double gsl_sf_bessel_Inu_scaled(double nu,double x); int gsl_sf_bessel_Inu_e(double nu,double x,double* result); diff --git a/lib/GSL/Special/manual.txt b/lib/GSL/Special/manual.txt deleted file mode 100644 index 1391d06..0000000 --- a/lib/GSL/Special/manual.txt +++ /dev/null @@ -1,12 +0,0 @@ -Airy.hs - include Precision (..) in the export list -Exp.hs - remove extern inline definition, qualify name -Coupling - remove deprecated INCORRECT -Trig.hs - qualify names -Legendre.hs - remove extern inline -Log.hs - remove extern inline, qualify name -- cgit v1.2.3