CInt in all imports

5 files changed, 65 insertions, 79 deletions

diff --git a/lib/Data/Packed/Internal/Common.hs b/lib/Data/Packed/Internal/Common.hs
index 8930cbb..5ac4f5a 100644
--- a/lib/Data/Packed/Internal/Common.hs
+++ b/lib/Data/Packed/Internal/Common.hs
@@ -59,6 +59,10 @@ common f = commonval . map f where
 infixl 0 //
 (//) = flip ($)
 
+-- | specialized fromIntegral
+fi :: Int -> CInt
+fi = fromIntegral
+
 -- hmm..
 ww2 w1 o1 w2 o2 f = w1 o1 $ \a1 -> w2 o2 $ \a2 -> f a1 a2
 ww3 w1 o1 w2 o2 w3 o3 f = w1 o1 $ \a1 -> ww2 w2 o2 w3 o3 (f a1)
@@ -103,37 +107,45 @@ foreign import ccall "auxi.h gsl_strerror" gsl_strerror :: CInt -> IO (Ptr CChar
 -- ugly, but my haddock version doesn't understand
 -- yet infix type constructors
 ---------------------------------------------------
----------- signatures of the C functions -------
-------------------------------------------------
-type PD = Ptr Double                          --
-type PC = Ptr (Complex Double)                --
-type TV = Int -> PD -> IO CInt                --
-type TVV = Int -> PD -> TV                    --
-type TVVV = Int -> PD -> TVV                  --
-type TM = Int -> Int -> PD -> IO CInt         --
-type TMM =  Int -> Int -> PD -> TM            --
-type TMMM =  Int -> Int -> PD -> TMM          --
-type TVM = Int -> PD -> TM                    --
-type TVVM = Int -> PD -> TVM                  --
-type TMV = Int -> Int -> PD -> TV             --
-type TMVM = Int -> Int -> PD -> TVM           --
-type TMMVM = Int -> Int -> PD -> TMVM         --
-type TCM = Int -> Int -> PC -> IO CInt        --
-type TCVCM = Int -> PC -> TCM                 --
-type TCMCVCM = Int -> Int -> PC -> TCVCM      --
-type TMCMCVCM = Int -> Int -> PD -> TCMCVCM   --
-type TCMCMCVCM = Int -> Int -> PC -> TCMCVCM  --
-type TCMCM = Int -> Int -> PC -> TCM          --
-type TVCM = Int -> PD -> TCM                  --
-type TCMVCM = Int -> Int -> PC -> TVCM        --
-type TCMCMVCM = Int -> Int -> PC -> TCMVCM    --
-type TCMCMCM = Int -> Int -> PC -> TCMCM      --
-type TCV = Int -> PC -> IO CInt               --
-type TCVCV = Int -> PC -> TCV                 --
-type TCVCVCV = Int -> PC -> TCVCV             --
-type TCMCV = Int -> Int -> PC -> TCV          --
-type TVCV = Int -> PD -> TCV                  --
-type TCVM = Int -> PC -> TM                   --
-type TMCVM = Int -> Int -> PD -> TCVM         --
-type TMMCVM = Int -> Int -> PD -> TMCVM       --
-------------------------------------------------
+---------- signatures of the C functions ---------
+--------------------------------------------------
+type PD = Ptr Double                            --
+type PC = Ptr (Complex Double)                  --
+type TV = CInt -> PD -> IO CInt                 --
+type TVV = CInt -> PD -> TV                     --
+type TVVV = CInt -> PD -> TVV                   --
+type TM = CInt -> CInt -> PD -> IO CInt         --
+type TMM =  CInt -> CInt -> PD -> TM            --
+type TVMM = CInt -> PD -> TMM                   --
+type TMVMM = CInt -> CInt -> PD -> TVMM         --
+type TMMM =  CInt -> CInt -> PD -> TMM          --
+type TVM = CInt -> PD -> TM                     --
+type TVVM = CInt -> PD -> TVM                   --
+type TMV = CInt -> CInt -> PD -> TV             --
+type TMMV = CInt -> CInt -> PD -> TMV           --
+type TMVM = CInt -> CInt -> PD -> TVM           --
+type TMMVM = CInt -> CInt -> PD -> TMVM         --
+type TCM = CInt -> CInt -> PC -> IO CInt        --
+type TCVCM = CInt -> PC -> TCM                  --
+type TCMCVCM = CInt -> CInt -> PC -> TCVCM      --
+type TMCMCVCM = CInt -> CInt -> PD -> TCMCVCM   --
+type TCMCMCVCM = CInt -> CInt -> PC -> TCMCVCM  --
+type TCMCM = CInt -> CInt -> PC -> TCM          --
+type TVCM = CInt -> PD -> TCM                   --
+type TCMVCM = CInt -> CInt -> PC -> TVCM        --
+type TCMCMVCM = CInt -> CInt -> PC -> TCMVCM    --
+type TCMCMCM = CInt -> CInt -> PC -> TCMCM      --
+type TCV = CInt -> PC -> IO CInt                --
+type TCVCV = CInt -> PC -> TCV                  --
+type TCVCVCV = CInt -> PC -> TCVCV              --
+type TCMCV = CInt -> CInt -> PC -> TCV          --
+type TVCV = CInt -> PD -> TCV                   --
+type TCVM = CInt -> PC -> TM                    --
+type TMCVM = CInt -> CInt -> PD -> TCVM         --
+type TMMCVM = CInt -> CInt -> PD -> TMCVM       --
+--------------------------------------------------
+
+type TauxMul a = CInt -> CInt -> CInt -> Ptr a
+               -> CInt -> CInt -> CInt -> Ptr a
+               -> CInt -> CInt -> Ptr a
+               -> IO CInt
diff --git a/lib/Data/Packed/Internal/Matrix.hs b/lib/Data/Packed/Internal/Matrix.hs
index c20726b..86c5915 100644
--- a/lib/Data/Packed/Internal/Matrix.hs
+++ b/lib/Data/Packed/Internal/Matrix.hs
@@ -83,13 +83,13 @@ mat = withMatrix
 withMatrix MC {rows = r, cols = c, cdat = d } f =
     withForeignPtr (fptr d) $ \p -> do
         let m g = do
-            g r c p
+            g (fi r) (fi c) p
         f m
 
 withMatrix MF {rows = r, cols = c, fdat = d } f =
     withForeignPtr (fptr d) $ \p -> do
         let m g = do
-            g r c p
+            g (fi r) (fi c) p
         f m
 
 {- | Creates a vector by concatenation of rows
@@ -247,22 +247,20 @@ transdataAux fun c1 d c2 =
             v <- createVector (dim d)
             withForeignPtr (fptr d) $ \pd ->
                 withForeignPtr (fptr v) $ \pv ->
-                    fun r1 c1 pd r2 c2 pv // check "transdataAux"
+                    fun (fi r1) (fi c1) pd (fi r2) (fi c2) pv // check "transdataAux"
             -- putStrLn $ "---> transdataAux" ++ show (toList d) ++ show (toList v)
             return v
   where r1 = dim d `div` c1
         r2 = dim d `div` c2
         noneed = r1 == 1 || c1 == 1
 
-foreign import ccall unsafe "auxi.h transR"
-    ctransR :: TMM -- Double ::> Double ::> IO Int
-foreign import ccall unsafe "auxi.h transC"
-    ctransC :: TCMCM -- Complex Double ::> Complex Double ::> IO Int
+foreign import ccall unsafe "auxi.h transR" ctransR :: TMM
+foreign import ccall unsafe "auxi.h transC" ctransC :: TCMCM
 
 ------------------------------------------------------------------
 
-gmatC MF { rows = r, cols = c } p f = f 1 c r p
-gmatC MC { rows = r, cols = c } p f = f 0 r c p
+gmatC MF { rows = r, cols = c } p f = f 1 (fi c) (fi r) p
+gmatC MC { rows = r, cols = c } p f = f 0 (fi r) (fi c) p
 
 dtt MC { cdat = d } = d
 dtt MF { fdat = d } = d
@@ -277,18 +275,10 @@ multiplyAux fun a b = unsafePerformIO $ do
     return r
 
 multiplyR = multiplyAux cmultiplyR
-foreign import ccall unsafe "auxi.h multiplyR"
-    cmultiplyR :: Int -> Int -> Int -> Ptr Double
-               -> Int -> Int -> Int -> Ptr Double
-               -> Int -> Int -> Ptr Double
-               -> IO CInt
+foreign import ccall unsafe "auxi.h multiplyR" cmultiplyR :: TauxMul Double
 
 multiplyC = multiplyAux cmultiplyC
-foreign import ccall unsafe "auxi.h multiplyC"
-    cmultiplyC :: Int -> Int -> Int -> Ptr (Complex Double)
-               -> Int -> Int -> Int -> Ptr (Complex Double)
-               -> Int -> Int -> Ptr (Complex Double)
-               -> IO CInt
+foreign import ccall unsafe "auxi.h multiplyC" cmultiplyC :: TauxMul (Complex Double)
 
 -- | matrix product
 multiply :: (Element a) => Matrix a -> Matrix a -> Matrix a
@@ -301,9 +291,9 @@ subMatrixR :: (Int,Int) -> (Int,Int) -> Matrix Double -> Matrix Double
 subMatrixR (r0,c0) (rt,ct) x' = unsafePerformIO $ do
     r <- createMatrix RowMajor rt ct
     let x = cmat x'
-    app2 (c_submatrixR r0 (r0+rt-1) c0 (c0+ct-1)) mat x mat r "subMatrixR"
+    app2 (c_submatrixR (fi r0) (fi $ r0+rt-1) (fi c0) (fi $ c0+ct-1)) mat x mat r "subMatrixR"
     return r
-foreign import ccall "auxi.h submatrixR" c_submatrixR :: Int -> Int -> Int -> Int -> TMM
+foreign import ccall "auxi.h submatrixR" c_submatrixR :: CInt -> CInt -> CInt -> CInt -> TMM
 
 -- | extraction of a submatrix from a complex matrix
 subMatrixC :: (Int,Int) -> (Int,Int) -> Matrix (Complex Double) -> Matrix (Complex Double)
@@ -353,13 +343,11 @@ constantAux fun x n = unsafePerformIO $ do
 
 constantR :: Double -> Int -> Vector Double
 constantR = constantAux cconstantR
-foreign import ccall "auxi.h constantR"
-    cconstantR :: Ptr Double -> TV -- Double :> IO Int
+foreign import ccall "auxi.h constantR" cconstantR :: Ptr Double -> TV
 
 constantC :: Complex Double -> Int -> Vector (Complex Double)
 constantC = constantAux cconstantC
-foreign import ccall "auxi.h constantC"
-    cconstantC :: Ptr (Complex Double) -> TCV -- Complex Double :> IO Int
+foreign import ccall "auxi.h constantC" cconstantC :: Ptr (Complex Double) -> TCV
 
 {- | creates a vector with a given number of equal components:
 
diff --git a/lib/Data/Packed/Internal/Vector.hs b/lib/Data/Packed/Internal/Vector.hs
index ac6588b..1075e64 100644
--- a/lib/Data/Packed/Internal/Vector.hs
+++ b/lib/Data/Packed/Internal/Vector.hs
@@ -26,20 +26,11 @@ data Vector t = V { dim  :: Int              -- ^ number of elements
                   , fptr :: ForeignPtr t     -- ^ foreign pointer to the memory block
                   }
 
---ptr (V _ fptr) = unsafeForeignPtrToPtr fptr
-
--- | signature of foreign functions admitting C-style vectors
-type Vc t s = Int -> Ptr t -> s
--- not yet admitted by my haddock version
--- infixr 5 :>
--- type t :> s = Vc t s
-
-
 vec = withVector
 
 withVector (V n fp) f = withForeignPtr fp $ \p -> do
     let v g = do
-        g n p
+        g (fi n) p
     f v
 
 -- | allocates memory for a new vector
diff --git a/lib/Numeric/GSL/Matrix.hs b/lib/Numeric/GSL/Matrix.hs
index d51728e..acf4e77 100644
--- a/lib/Numeric/GSL/Matrix.hs
+++ b/lib/Numeric/GSL/Matrix.hs
@@ -179,10 +179,6 @@ unpackQR' (qrp,tau) = unsafePerformIO $ do
         c = cols qrp
 foreign import ccall "gsl-aux.h QRunpack" c_qrUnpack :: TMVMM
 
-
-type TMMV = Int -> Int -> PD -> TMV
-type TMVMM = Int -> Int -> PD -> Int -> PD -> TMM
-
 {- | Cholesky decomposition of a symmetric positive definite real matrix using /gsl_linalg_cholesky_decomp/.
 
 @\> chol $ (2><2) [1,2,
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
index 65705cc..b84da06 100644
--- a/lib/Numeric/GSL/Minimization.hs
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -86,7 +86,7 @@ minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do
     fp <- mkVecfun (iv (f.toList))
     rawpath <- ww2 withVector xiv withVector szv $ \xiv' szv' ->
                    createMIO maxit (n+3)
-                         (c_minimizeNMSimplex fp tol (fromIntegral maxit) // xiv' // szv')
+                         (c_minimizeNMSimplex fp tol (fi maxit) // xiv' // szv')
                          "minimizeNMSimplex"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
@@ -96,8 +96,7 @@ minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do
 
 
 foreign import ccall "gsl-aux.h minimize"
-    c_minimizeNMSimplex:: FunPtr (CInt -> Ptr Double -> Double) -> Double -> CInt
-                       -> TVVM
+    c_minimizeNMSimplex:: FunPtr (CInt -> Ptr Double -> Double) -> Double -> CInt -> TVVM
 
 ----------------------------------------------------------------------------------
 
@@ -152,7 +151,7 @@ minimizeConjugateGradient istep minimpar tol maxit f df xi = unsafePerformIO $ d
     dfp <- mkVecVecfun (aux_vTov df')
     rawpath <- withVector xiv $ \xiv' ->
                     createMIO maxit (n+2)
-                         (c_minimizeConjugateGradient fp dfp istep minimpar tol (fromIntegral maxit) // xiv')
+                         (c_minimizeConjugateGradient fp dfp istep minimpar tol (fi maxit) // xiv')
                          "minimizeDerivV"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
@@ -172,7 +171,7 @@ foreign import ccall "gsl-aux.h minimizeWithDeriv"
 iv :: (Vector Double -> Double) -> (CInt -> Ptr Double -> Double)
 iv f n p = f (createV (fromIntegral n) copy "iv") where
     copy n' q = do
-        copyArray q p n'
+        copyArray q p (fromIntegral n')
         return 0
 
 -- | conversion of Haskell functions into function pointers that can be used in the C side
@@ -190,7 +189,7 @@ aux_vTov f n p r = g where
     V {fptr = pr} = f x
     x = createV (fromIntegral n) copy "aux_vTov"
     copy n' q = do
-        copyArray q p n'
+        copyArray q p (fromIntegral n')
         return 0
     g = withForeignPtr pr $ \p' -> copyArray r p' (fromIntegral n)