1 files changed, 71 insertions, 62 deletions

diff --git a/packages/base/src/Internal/Vectorized.hs b/packages/base/src/Internal/Vectorized.hs
index 32430c6..ede3826 100644
--- a/packages/base/src/Internal/Vectorized.hs
+++ b/packages/base/src/Internal/Vectorized.hs
@@ -18,10 +18,12 @@ module Internal.Vectorized where
 import Internal.Vector
 import Internal.Devel
 import Data.Complex
+import Data.Function
+import Data.Int
 import Foreign.Marshal.Alloc(free,malloc)
 import Foreign.Marshal.Array(newArray,copyArray)
 import Foreign.Ptr(Ptr)
-import Foreign.Storable(peek,Storable)
+import Foreign.Storable(peek,pokeElemOff,Storable)
 import Foreign.C.Types
 import Foreign.C.String
 import System.IO.Unsafe(unsafePerformIO)
@@ -36,8 +38,8 @@ a # b = applyRaw a b
 a #! b = a # b # id
 {-# INLINE (#!) #-}
 
-fromei :: Enum a => a -> CInt
-fromei x = fromIntegral (fromEnum x) :: CInt
+fromei :: Enum a => a -> Int32
+fromei x = fromIntegral (fromEnum x) :: Int32
 
 data FunCodeV = Sin
               | Cos
@@ -103,20 +105,20 @@ sumQ = sumg c_sumQ
 sumC :: Vector (Complex Double) -> Complex Double
 sumC = sumg c_sumC
 
-sumI :: ( TransRaw c (CInt -> Ptr a -> IO CInt) ~ (CInt -> Ptr I -> I :> Ok)
+sumI :: ( TransRaw c (Int32 -> Ptr a -> IO Int32) ~ (Int32 -> Ptr I -> I :> Ok)
         , TransArray c
         , Storable a
         )
      => I -> c -> a
 sumI m = sumg (c_sumI m)
 
-sumL :: ( TransRaw c (CInt -> Ptr a -> IO CInt) ~ (CInt -> Ptr Z -> Z :> Ok)
+sumL :: ( TransRaw c (Int32 -> Ptr a -> IO Int32) ~ (Int32 -> Ptr Z -> Z :> Ok)
         , TransArray c
         , Storable a
         ) => Z -> c -> a
 sumL m = sumg (c_sumL m)
 
-sumg :: (TransArray c, Storable a) => TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
+sumg :: (TransArray c, Storable a) => TransRaw c (Int32 -> Ptr a -> IO Int32) -> c -> a
 sumg f x = unsafePerformIO $ do
     r <- createVector 1
     (x #! r) f #| "sum"
@@ -154,7 +156,7 @@ prodL :: Z-> Vector Z -> Z
 prodL = prodg . c_prodL
 
 prodg :: (TransArray c, Storable a)
-      => TransRaw c (CInt -> Ptr a -> IO CInt) -> c -> a
+      => TransRaw c (Int32 -> Ptr a -> IO Int32) -> c -> a
 prodg f x = unsafePerformIO $ do
     r <- createVector 1
     (x #! r) f #| "prod"
@@ -171,7 +173,7 @@ foreign import ccall unsafe "prodL" c_prodL :: Z -> TVV Z
 ------------------------------------------------------------------
 
 toScalarAux :: (Enum a, TransArray c, Storable a1)
-            => (CInt -> TransRaw c (CInt -> Ptr a1 -> IO CInt)) -> a -> c -> a1
+            => (Int32 -> TransRaw c (Int32 -> Ptr a1 -> IO Int32)) -> a -> c -> a1
 toScalarAux fun code v = unsafePerformIO $ do
     r <- createVector 1
     (v #! r) (fun (fromei code)) #|"toScalarAux"
@@ -179,7 +181,7 @@ toScalarAux fun code v = unsafePerformIO $ do
 
 
 vectorMapAux :: (Enum a, Storable t, Storable a1)
-             => (CInt -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
+             => (Int32 -> Int32 -> Ptr t -> Int32 -> Ptr a1 -> IO Int32)
              -> a -> Vector t -> Vector a1
 vectorMapAux fun code v = unsafePerformIO $ do
     r <- createVector (dim v)
@@ -187,7 +189,7 @@ vectorMapAux fun code v = unsafePerformIO $ do
     return r
 
 vectorMapValAux :: (Enum a, Storable a2, Storable t, Storable a1)
-                => (CInt -> Ptr a2 -> CInt -> Ptr t -> CInt -> Ptr a1 -> IO CInt)
+                => (Int32 -> Ptr a2 -> Int32 -> Ptr t -> Int32 -> Ptr a1 -> IO Int32)
                 -> a -> a2 -> Vector t -> Vector a1
 vectorMapValAux fun code val v = unsafePerformIO $ do
     r <- createVector (dim v)
@@ -197,7 +199,7 @@ vectorMapValAux fun code val v = unsafePerformIO $ do
     return r
 
 vectorZipAux :: (Enum a, TransArray c, Storable t, Storable a1)
-             => (CInt -> CInt -> Ptr t -> TransRaw c (CInt -> Ptr a1 -> IO CInt))
+             => (Int32 -> Int32 -> Ptr t -> TransRaw c (Int32 -> Ptr a1 -> IO Int32))
              -> a -> Vector t -> c -> Vector a1
 vectorZipAux fun code u v = unsafePerformIO $ do
     r <- createVector (dim u)
@@ -210,37 +212,37 @@ vectorZipAux fun code u v = unsafePerformIO $ do
 toScalarR :: FunCodeS -> Vector Double -> Double
 toScalarR oper =  toScalarAux c_toScalarR (fromei oper)
 
-foreign import ccall unsafe "toScalarR" c_toScalarR :: CInt -> TVV Double
+foreign import ccall unsafe "toScalarR" c_toScalarR :: Int32 -> TVV Double
 
 -- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
 toScalarF :: FunCodeS -> Vector Float -> Float
 toScalarF oper =  toScalarAux c_toScalarF (fromei oper)
 
-foreign import ccall unsafe "toScalarF" c_toScalarF :: CInt -> TVV Float
+foreign import ccall unsafe "toScalarF" c_toScalarF :: Int32 -> TVV Float
 
 -- | obtains different functions of a vector: only norm1, norm2
 toScalarC :: FunCodeS -> Vector (Complex Double) -> Double
 toScalarC oper =  toScalarAux c_toScalarC (fromei oper)
 
-foreign import ccall unsafe "toScalarC" c_toScalarC :: CInt -> Complex Double :> Double :> Ok
+foreign import ccall unsafe "toScalarC" c_toScalarC :: Int32 -> Complex Double :> Double :> Ok
 
 -- | obtains different functions of a vector: only norm1, norm2
 toScalarQ :: FunCodeS -> Vector (Complex Float) -> Float
 toScalarQ oper =  toScalarAux c_toScalarQ (fromei oper)
 
-foreign import ccall unsafe "toScalarQ" c_toScalarQ :: CInt -> Complex Float :> Float :> Ok
+foreign import ccall unsafe "toScalarQ" c_toScalarQ :: Int32 -> Complex Float :> Float :> Ok
 
 -- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
-toScalarI :: FunCodeS -> Vector CInt -> CInt
+toScalarI :: FunCodeS -> Vector Int32 -> Int32
 toScalarI oper =  toScalarAux c_toScalarI (fromei oper)
 
-foreign import ccall unsafe "toScalarI" c_toScalarI :: CInt -> TVV CInt
+foreign import ccall unsafe "toScalarI" c_toScalarI :: Int32 -> TVV Int32
 
 -- | obtains different functions of a vector: norm1, norm2, max, min, posmax, posmin, etc.
 toScalarL :: FunCodeS -> Vector Z -> Z
 toScalarL oper =  toScalarAux c_toScalarL (fromei oper)
 
-foreign import ccall unsafe "toScalarL" c_toScalarL :: CInt -> TVV Z
+foreign import ccall unsafe "toScalarL" c_toScalarL :: Int32 -> TVV Z
 
 
 ------------------------------------------------------------------
@@ -249,37 +251,37 @@ foreign import ccall unsafe "toScalarL" c_toScalarL :: CInt -> TVV Z
 vectorMapR :: FunCodeV -> Vector Double -> Vector Double
 vectorMapR = vectorMapAux c_vectorMapR
 
-foreign import ccall unsafe "mapR" c_vectorMapR :: CInt -> TVV Double
+foreign import ccall unsafe "mapR" c_vectorMapR :: Int32 -> TVV Double
 
 -- | map of complex vectors with given function
 vectorMapC :: FunCodeV -> Vector (Complex Double) -> Vector (Complex Double)
 vectorMapC oper = vectorMapAux c_vectorMapC (fromei oper)
 
-foreign import ccall unsafe "mapC" c_vectorMapC :: CInt -> TVV (Complex Double)
+foreign import ccall unsafe "mapC" c_vectorMapC :: Int32 -> TVV (Complex Double)
 
 -- | map of real vectors with given function
 vectorMapF :: FunCodeV -> Vector Float -> Vector Float
 vectorMapF = vectorMapAux c_vectorMapF
 
-foreign import ccall unsafe "mapF" c_vectorMapF :: CInt -> TVV Float
+foreign import ccall unsafe "mapF" c_vectorMapF :: Int32 -> TVV Float
 
 -- | map of real vectors with given function
 vectorMapQ :: FunCodeV -> Vector (Complex Float) -> Vector (Complex Float)
 vectorMapQ = vectorMapAux c_vectorMapQ
 
-foreign import ccall unsafe "mapQ" c_vectorMapQ :: CInt -> TVV (Complex Float)
+foreign import ccall unsafe "mapQ" c_vectorMapQ :: Int32 -> TVV (Complex Float)
 
 -- | map of real vectors with given function
-vectorMapI :: FunCodeV -> Vector CInt -> Vector CInt
+vectorMapI :: FunCodeV -> Vector Int32 -> Vector Int32
 vectorMapI = vectorMapAux c_vectorMapI
 
-foreign import ccall unsafe "mapI" c_vectorMapI :: CInt -> TVV CInt
+foreign import ccall unsafe "mapI" c_vectorMapI :: Int32 -> TVV Int32
 
 -- | map of real vectors with given function
 vectorMapL :: FunCodeV -> Vector Z -> Vector Z
 vectorMapL = vectorMapAux c_vectorMapL
 
-foreign import ccall unsafe "mapL" c_vectorMapL :: CInt -> TVV Z
+foreign import ccall unsafe "mapL" c_vectorMapL :: Int32 -> TVV Z
 
 -------------------------------------------------------------------
 
@@ -287,37 +289,37 @@ foreign import ccall unsafe "mapL" c_vectorMapL :: CInt -> TVV Z
 vectorMapValR :: FunCodeSV -> Double -> Vector Double -> Vector Double
 vectorMapValR oper = vectorMapValAux c_vectorMapValR (fromei oper)
 
-foreign import ccall unsafe "mapValR" c_vectorMapValR :: CInt -> Ptr Double -> TVV Double
+foreign import ccall unsafe "mapValR" c_vectorMapValR :: Int32 -> Ptr Double -> TVV Double
 
 -- | map of complex vectors with given function
 vectorMapValC :: FunCodeSV -> Complex Double -> Vector (Complex Double) -> Vector (Complex Double)
 vectorMapValC = vectorMapValAux c_vectorMapValC
 
-foreign import ccall unsafe "mapValC" c_vectorMapValC :: CInt -> Ptr (Complex Double) -> TVV (Complex Double)
+foreign import ccall unsafe "mapValC" c_vectorMapValC :: Int32 -> Ptr (Complex Double) -> TVV (Complex Double)
 
 -- | map of real vectors with given function
 vectorMapValF :: FunCodeSV -> Float -> Vector Float -> Vector Float
 vectorMapValF oper = vectorMapValAux c_vectorMapValF (fromei oper)
 
-foreign import ccall unsafe "mapValF" c_vectorMapValF :: CInt -> Ptr Float -> TVV Float
+foreign import ccall unsafe "mapValF" c_vectorMapValF :: Int32 -> Ptr Float -> TVV Float
 
 -- | map of complex vectors with given function
 vectorMapValQ :: FunCodeSV -> Complex Float -> Vector (Complex Float) -> Vector (Complex Float)
 vectorMapValQ oper = vectorMapValAux c_vectorMapValQ (fromei oper)
 
-foreign import ccall unsafe "mapValQ" c_vectorMapValQ :: CInt -> Ptr (Complex Float) -> TVV (Complex Float)
+foreign import ccall unsafe "mapValQ" c_vectorMapValQ :: Int32 -> Ptr (Complex Float) -> TVV (Complex Float)
 
 -- | map of real vectors with given function
-vectorMapValI :: FunCodeSV -> CInt -> Vector CInt -> Vector CInt
+vectorMapValI :: FunCodeSV -> Int32 -> Vector Int32 -> Vector Int32
 vectorMapValI oper = vectorMapValAux c_vectorMapValI (fromei oper)
 
-foreign import ccall unsafe "mapValI" c_vectorMapValI :: CInt -> Ptr CInt -> TVV CInt
+foreign import ccall unsafe "mapValI" c_vectorMapValI :: Int32 -> Ptr Int32 -> TVV Int32
 
 -- | map of real vectors with given function
 vectorMapValL :: FunCodeSV -> Z -> Vector Z -> Vector Z
 vectorMapValL oper = vectorMapValAux c_vectorMapValL (fromei oper)
 
-foreign import ccall unsafe "mapValL" c_vectorMapValL :: CInt -> Ptr Z -> TVV Z
+foreign import ccall unsafe "mapValL" c_vectorMapValL :: Int32 -> Ptr Z -> TVV Z
 
 
 -------------------------------------------------------------------
@@ -328,42 +330,42 @@ type TVVV t = t :> t :> t :> Ok
 vectorZipR :: FunCodeVV -> Vector Double -> Vector Double -> Vector Double
 vectorZipR = vectorZipAux c_vectorZipR
 
-foreign import ccall unsafe "zipR" c_vectorZipR :: CInt -> TVVV Double
+foreign import ccall unsafe "zipR" c_vectorZipR :: Int32 -> TVVV Double
 
 -- | elementwise operation on complex vectors
 vectorZipC :: FunCodeVV -> Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)
 vectorZipC = vectorZipAux c_vectorZipC
 
-foreign import ccall unsafe "zipC" c_vectorZipC :: CInt -> TVVV (Complex Double)
+foreign import ccall unsafe "zipC" c_vectorZipC :: Int32 -> TVVV (Complex Double)
 
 -- | elementwise operation on real vectors
 vectorZipF :: FunCodeVV -> Vector Float -> Vector Float -> Vector Float
 vectorZipF = vectorZipAux c_vectorZipF
 
-foreign import ccall unsafe "zipF" c_vectorZipF :: CInt -> TVVV Float
+foreign import ccall unsafe "zipF" c_vectorZipF :: Int32 -> TVVV Float
 
 -- | elementwise operation on complex vectors
 vectorZipQ :: FunCodeVV -> Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float)
 vectorZipQ = vectorZipAux c_vectorZipQ
 
-foreign import ccall unsafe "zipQ" c_vectorZipQ :: CInt -> TVVV (Complex Float)
+foreign import ccall unsafe "zipQ" c_vectorZipQ :: Int32 -> TVVV (Complex Float)
 
--- | elementwise operation on CInt vectors
-vectorZipI :: FunCodeVV -> Vector CInt -> Vector CInt -> Vector CInt
+-- | elementwise operation on Int32 vectors
+vectorZipI :: FunCodeVV -> Vector Int32 -> Vector Int32 -> Vector Int32
 vectorZipI = vectorZipAux c_vectorZipI
 
-foreign import ccall unsafe "zipI" c_vectorZipI :: CInt -> TVVV CInt
+foreign import ccall unsafe "zipI" c_vectorZipI :: Int32 -> TVVV Int32
 
--- | elementwise operation on CInt vectors
+-- | elementwise operation on Int32 vectors
 vectorZipL :: FunCodeVV -> Vector Z -> Vector Z -> Vector Z
 vectorZipL = vectorZipAux c_vectorZipL
 
-foreign import ccall unsafe "zipL" c_vectorZipL :: CInt -> TVVV Z
+foreign import ccall unsafe "zipL" c_vectorZipL :: Int32 -> TVVV Z
 
 --------------------------------------------------------------------------------
 
 foreign import ccall unsafe "vectorScan" c_vectorScan
-    :: CString -> Ptr CInt -> Ptr (Ptr Double) -> IO CInt
+    :: CString -> Ptr Int32 -> Ptr (Ptr Double) -> IO Int32
 
 vectorScan :: FilePath -> IO (Vector Double)
 vectorScan s = do
@@ -401,7 +403,7 @@ randomVector seed dist n = unsafePerformIO $ do
     (r # id) (c_random_vector (fi seed) ((fi.fromEnum) dist)) #|"randomVector"
     return r
 
-foreign import ccall unsafe "random_vector" c_random_vector :: CInt -> CInt -> Double :> Ok
+foreign import ccall unsafe "random_vector" c_random_vector :: Int32 -> Int32 -> Double :> Ok
 
 --------------------------------------------------------------------------------
 
@@ -426,7 +428,7 @@ range n = unsafePerformIO $ do
     (r # id) c_range_vector #|"range"
     return r
 
-foreign import ccall unsafe "range_vector" c_range_vector :: CInt :> Ok
+foreign import ccall unsafe "range_vector" c_range_vector :: Int32 :> Ok
 
 
 float2DoubleV :: Vector Float -> Vector Double
@@ -435,10 +437,10 @@ float2DoubleV = tog c_float2double
 double2FloatV :: Vector Double -> Vector Float
 double2FloatV = tog c_double2float
 
-double2IntV :: Vector Double -> Vector CInt
+double2IntV :: Vector Double -> Vector Int32
 double2IntV = tog c_double2int
 
-int2DoubleV :: Vector CInt -> Vector Double
+int2DoubleV :: Vector Int32 -> Vector Double
 int2DoubleV = tog c_int2double
 
 double2longV :: Vector Double -> Vector Z
@@ -448,10 +450,10 @@ long2DoubleV :: Vector Z -> Vector Double
 long2DoubleV = tog c_long2double
 
 
-float2IntV :: Vector Float -> Vector CInt
+float2IntV :: Vector Float -> Vector Int32
 float2IntV = tog c_float2int
 
-int2floatV :: Vector CInt -> Vector Float
+int2floatV :: Vector Int32 -> Vector Float
 int2floatV = tog c_int2float
 
 int2longV :: Vector I -> Vector Z
@@ -462,7 +464,7 @@ long2intV = tog c_long2int
 
 
 tog :: (Storable t, Storable a)
-    => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
+    => (Int32 -> Ptr t -> Int32 -> Ptr a -> IO Int32) -> Vector t -> Vector a
 tog f v = unsafePerformIO $ do
     r <- createVector (dim v)
     (v #! r) f #|"tog"
@@ -470,12 +472,12 @@ tog f v = unsafePerformIO $ do
 
 foreign import ccall unsafe "float2double" c_float2double :: Float :> Double :> Ok
 foreign import ccall unsafe "double2float" c_double2float :: Double :> Float :> Ok
-foreign import ccall unsafe "int2double"   c_int2double   :: CInt :> Double :> Ok
-foreign import ccall unsafe "double2int"   c_double2int   :: Double :> CInt :> Ok
+foreign import ccall unsafe "int2double"   c_int2double   :: Int32 :> Double :> Ok
+foreign import ccall unsafe "double2int"   c_double2int   :: Double :> Int32 :> Ok
 foreign import ccall unsafe "long2double"  c_long2double   :: Z :> Double :> Ok
 foreign import ccall unsafe "double2long"  c_double2long   :: Double :> Z :> Ok
-foreign import ccall unsafe "int2float"    c_int2float    :: CInt :> Float :> Ok
-foreign import ccall unsafe "float2int"    c_float2int    :: Float :> CInt :> Ok
+foreign import ccall unsafe "int2float"    c_int2float    :: Int32 :> Float :> Ok
+foreign import ccall unsafe "float2int"    c_float2int    :: Float :> Int32 :> Ok
 foreign import ccall unsafe "int2long"    c_int2long    :: I :> Z :> Ok
 foreign import ccall unsafe "long2int"    c_long2int    :: Z :> I :> Ok
 
@@ -483,7 +485,7 @@ foreign import ccall unsafe "long2int"    c_long2int    :: Z :> I :> Ok
 ---------------------------------------------------------------
 
 stepg :: (Storable t, Storable a)
-      => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
+      => (Int32 -> Ptr t -> Int32 -> Ptr a -> IO Int32) -> Vector t -> Vector a
 stepg f v = unsafePerformIO $ do
     r <- createVector (dim v)
     (v #! r) f #|"step"
@@ -495,7 +497,7 @@ stepD = stepg c_stepD
 stepF :: Vector Float -> Vector Float
 stepF = stepg c_stepF
 
-stepI :: Vector CInt -> Vector CInt
+stepI :: Vector Int32 -> Vector Int32
 stepI = stepg c_stepI
 
 stepL :: Vector Z -> Vector Z
@@ -504,13 +506,13 @@ stepL = stepg c_stepL
 
 foreign import ccall unsafe "stepF" c_stepF :: TVV Float
 foreign import ccall unsafe "stepD" c_stepD :: TVV Double
-foreign import ccall unsafe "stepI" c_stepI :: TVV CInt
+foreign import ccall unsafe "stepI" c_stepI :: TVV Int32
 foreign import ccall unsafe "stepL" c_stepL :: TVV Z
 
 --------------------------------------------------------------------------------
 
 conjugateAux :: (Storable t, Storable a)
-             => (CInt -> Ptr t -> CInt -> Ptr a -> IO CInt) -> Vector t -> Vector a
+             => (Int32 -> Ptr t -> Int32 -> Ptr a -> IO Int32) -> Vector t -> Vector a
 conjugateAux fun x = unsafePerformIO $ do
     v <- createVector (dim x)
     (x #! v) fun #|"conjugateAux"
@@ -536,22 +538,29 @@ cloneVector v = do
 
 --------------------------------------------------------------------------------
 
-constantAux :: (Storable a1, Storable a)
-            => (Ptr a1 -> CInt -> Ptr a -> IO CInt) -> a1 -> Int -> Vector a
-constantAux fun x n = unsafePerformIO $ do
+constantAux :: Storable a => a -> Int -> Vector a
+constantAux x n = unsafePerformIO $ do
     v <- createVector n
     px <- newArray [x]
-    (v # id) (fun px) #|"constantAux"
+    (v # id) (constantStorable px) #|"constantAux"
     free px
     return v
 
+constantStorable :: Storable a => Ptr a -> Int32 -> Ptr a -> IO Int32
+constantStorable pval n p = do
+    val <- peek pval
+    ($ 0) $ fix $ \iloop i -> when (i<n) $ do
+        pokeElemOff p (fromIntegral i) val
+        iloop $! succ i
+    return 0
+
 type TConst t = Ptr t -> t :> Ok
 
 foreign import ccall unsafe "constantF" cconstantF :: TConst Float
 foreign import ccall unsafe "constantR" cconstantR :: TConst Double
 foreign import ccall unsafe "constantQ" cconstantQ :: TConst (Complex Float)
 foreign import ccall unsafe "constantC" cconstantC :: TConst (Complex Double)
-foreign import ccall unsafe "constantI" cconstantI :: TConst CInt
+foreign import ccall unsafe "constantI" cconstantI :: TConst Int32
 foreign import ccall unsafe "constantL" cconstantL :: TConst Z
 
 ----------------------------------------------------------------------