1 files changed, 42 insertions, 42 deletions

diff --git a/packages/base/src/Internal/Element.hs b/packages/base/src/Internal/Element.hs
index 2e330ee..80eda8d 100644
--- a/packages/base/src/Internal/Element.hs
+++ b/packages/base/src/Internal/Element.hs
@@ -33,14 +33,14 @@ import Data.List.Split(chunksOf)
 import Foreign.Storable(Storable)
 import System.IO.Unsafe(unsafePerformIO)
 import Control.Monad(liftM)
-import Foreign.C.Types(CInt)
+import Data.Int
 
 -------------------------------------------------------------------
 
 
 import Data.Binary
 
-instance (Binary (Vector a), Element a) => Binary (Matrix a) where
+instance (Binary (Vector a), Storable a) => Binary (Matrix a) where
     put m = do
             put (cols m)
             put (flatten m)
@@ -52,7 +52,7 @@ instance (Binary (Vector a), Element a) => Binary (Matrix a) where
 
 -------------------------------------------------------------------
 
-instance (Show a, Element a) => (Show (Matrix a)) where
+instance (Show a, Storable a) => (Show (Matrix a)) where
     show m | rows m == 0 || cols m == 0 = sizes m ++" []"
     show m = (sizes m++) . dsp . map (map show) . toLists $ m
 
@@ -70,7 +70,7 @@ dsp as = (++" ]") . (" ["++) . init . drop 2 . unlines . map (" , "++) . map unw
 
 ------------------------------------------------------------------
 
-instance (Element a, Read a) => Read (Matrix a) where
+instance (Storable a, Read a) => Read (Matrix a) where
     readsPrec _ s = [((rs><cs) . read $ listnums, rest)]
         where (thing,rest) = breakAt ']' s
               (dims,listnums) = breakAt ')' thing
@@ -133,13 +133,13 @@ ppext (DropLast n) = printf "DropLast %d" n
 
 -}
 infixl 9 ??
-(??)  :: Element t => Matrix t -> (Extractor,Extractor) -> Matrix t
+(??)  :: Storable t => Matrix t -> (Extractor,Extractor) -> Matrix t
 
-minEl :: Vector CInt -> CInt
+minEl :: Vector Int32 -> Int32
 minEl = toScalarI Min
-maxEl :: Vector CInt -> CInt
+maxEl :: Vector Int32 -> Int32
 maxEl = toScalarI Max
-cmodi :: Foreign.C.Types.CInt -> Vector Foreign.C.Types.CInt -> Vector Foreign.C.Types.CInt
+cmodi :: Int32 -> Vector Int32 -> Vector Int32
 cmodi = vectorMapValI ModVS
 
 extractError :: Matrix t1 -> (Extractor, Extractor) -> t
@@ -181,7 +181,7 @@ m ?? (e, TakeLast n) = m ?? (e, Drop (cols m - n))
 m ?? (DropLast n, e) = m ?? (Take (rows m - n), e)
 m ?? (e, DropLast n) = m ?? (e, Take (cols m - n))
 
-m ?? (er,ec) = unsafePerformIO $ extractR (orderOf m) m moder rs modec cs
+m ?? (er,ec) = unsafePerformIO $ extractAux (orderOf m) m moder rs modec cs
   where
     (moder,rs) = mkExt (rows m) er
     (modec,cs) = mkExt (cols m) ec
@@ -209,14 +209,14 @@ common f = commonval . map f
 
 
 -- | creates a matrix from a vertical list of matrices
-joinVert :: Element t => [Matrix t] -> Matrix t
+joinVert :: Storable t => [Matrix t] -> Matrix t
 joinVert [] = emptyM 0 0
 joinVert ms = case common cols ms of
     Nothing -> error "(impossible) joinVert on matrices with different number of columns"
     Just c  -> matrixFromVector RowMajor (sum (map rows ms)) c $ vjoin (map flatten ms)
 
 -- | creates a matrix from a horizontal list of matrices
-joinHoriz :: Element t => [Matrix t] -> Matrix t
+joinHoriz :: Storable t => [Matrix t] -> Matrix t
 joinHoriz ms = trans. joinVert . map trans $ ms
 
 {- | Create a matrix from blocks given as a list of lists of matrices.
@@ -240,13 +240,13 @@ disp = putStr . dispf 2
 3  3  3  3  3  0  0  3   0   0
 
 -}
-fromBlocks :: Element t => [[Matrix t]] -> Matrix t
+fromBlocks :: Storable t => [[Matrix t]] -> Matrix t
 fromBlocks = fromBlocksRaw . adaptBlocks
 
-fromBlocksRaw :: Element t => [[Matrix t]] -> Matrix t
+fromBlocksRaw :: Storable t => [[Matrix t]] -> Matrix t
 fromBlocksRaw mms = joinVert . map joinHoriz $ mms
 
-adaptBlocks :: Element t => [[Matrix t]] -> [[Matrix t]]
+adaptBlocks :: Storable t => [[Matrix t]] -> [[Matrix t]]
 adaptBlocks ms = ms' where
     bc = case common length ms of
           Just c -> c
@@ -258,7 +258,7 @@ adaptBlocks ms = ms' where
 
     g [Just nr,Just nc] m
                 | nr == r && nc == c = m
-                | r == 1 && c == 1 = matrixFromVector RowMajor nr nc (constantD x (nr*nc))
+                | r == 1 && c == 1 = matrixFromVector RowMajor nr nc (constantAux x (nr*nc))
                 | r == 1 = fromRows (replicate nr (flatten m))
                 | otherwise = fromColumns (replicate nc (flatten m))
       where
@@ -288,7 +288,7 @@ adaptBlocks ms = ms' where
  , 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0 ]
 
 -}
-diagBlock :: (Element t, Num t) => [Matrix t] -> Matrix t
+diagBlock :: (Storable t, Num t) => [Matrix t] -> Matrix t
 diagBlock ms = fromBlocks $ zipWith f ms [0..]
   where
     f m k = take n $ replicate k z ++ m : repeat z
@@ -299,13 +299,13 @@ diagBlock ms = fromBlocks $ zipWith f ms [0..]
 
 
 -- | Reverse rows
-flipud :: Element t => Matrix t -> Matrix t
+flipud :: Storable t => Matrix t -> Matrix t
 flipud m = extractRows [r-1,r-2 .. 0] $ m
   where
     r = rows m
 
 -- | Reverse columns
-fliprl :: Element t => Matrix t -> Matrix t
+fliprl :: Storable t => Matrix t -> Matrix t
 fliprl m = extractColumns [c-1,c-2 .. 0] $ m
   where
     c = cols m
@@ -330,7 +330,7 @@ diagRect z v r c = ST.runSTMatrix $ do
         return m
 
 -- | extracts the diagonal from a rectangular matrix
-takeDiag :: (Element t) => Matrix t -> Vector t
+takeDiag :: (Storable t) => Matrix t -> Vector t
 takeDiag m = fromList [flatten m @> (k*cols m+k) | k <- [0 .. min (rows m) (cols m) -1]]
 
 ------------------------------------------------------------
@@ -363,32 +363,32 @@ r >< c = f where
 
 ----------------------------------------------------------------
 
-takeRows :: Element t => Int -> Matrix t -> Matrix t
+takeRows :: Storable t => Int -> Matrix t -> Matrix t
 takeRows n mt = subMatrix (0,0) (n, cols mt) mt
 
 -- | Creates a matrix with the last n rows of another matrix
-takeLastRows :: Element t => Int -> Matrix t -> Matrix t
+takeLastRows :: Storable t => Int -> Matrix t -> Matrix t
 takeLastRows n mt = subMatrix (rows mt - n, 0) (n, cols mt) mt
 
-dropRows :: Element t => Int -> Matrix t -> Matrix t
+dropRows :: Storable t => Int -> Matrix t -> Matrix t
 dropRows n mt = subMatrix (n,0) (rows mt - n, cols mt) mt
 
 -- | Creates a copy of a matrix without the last n rows
-dropLastRows :: Element t => Int -> Matrix t -> Matrix t
+dropLastRows :: Storable t => Int -> Matrix t -> Matrix t
 dropLastRows n mt = subMatrix (0,0) (rows mt - n, cols mt) mt
 
-takeColumns :: Element t => Int -> Matrix t -> Matrix t
+takeColumns :: Storable t => Int -> Matrix t -> Matrix t
 takeColumns n mt = subMatrix (0,0) (rows mt, n) mt
 
 -- |Creates a matrix with the last n columns of another matrix
-takeLastColumns :: Element t => Int -> Matrix t -> Matrix t
+takeLastColumns :: Storable t => Int -> Matrix t -> Matrix t
 takeLastColumns n mt = subMatrix (0, cols mt - n) (rows mt, n) mt
 
-dropColumns :: Element t => Int -> Matrix t -> Matrix t
+dropColumns :: Storable t => Int -> Matrix t -> Matrix t
 dropColumns n mt = subMatrix (0,n) (rows mt, cols mt - n) mt
 
 -- | Creates a copy of a matrix without the last n columns
-dropLastColumns :: Element t => Int -> Matrix t -> Matrix t
+dropLastColumns :: Storable t => Int -> Matrix t -> Matrix t
 dropLastColumns n mt = subMatrix (0,0) (rows mt, cols mt - n) mt
 
 ----------------------------------------------------------------
@@ -402,7 +402,7 @@ dropLastColumns n mt = subMatrix (0,0) (rows mt, cols mt - n) mt
  , 5.0, 6.0 ]
 
 -}
-fromLists :: Element t => [[t]] -> Matrix t
+fromLists :: Storable t => [[t]] -> Matrix t
 fromLists = fromRows . map fromList
 
 -- | creates a 1-row matrix from a vector
@@ -443,7 +443,7 @@ Hilbert matrix of order N:
 @hilb n = buildMatrix n n (\\(i,j)->1/(fromIntegral i + fromIntegral j +1))@
 
 -}
-buildMatrix :: Element a => Int -> Int -> ((Int, Int) -> a) -> Matrix a
+buildMatrix :: Storable a => Int -> Int -> ((Int, Int) -> a) -> Matrix a
 buildMatrix rc cc f =
     fromLists $ map (map f)
         $ map (\ ri -> map (\ ci -> (ri, ci)) [0 .. (cc - 1)]) [0 .. (rc - 1)]
@@ -458,11 +458,11 @@ fromArray2D m = (r><c) (elems m)
 
 
 -- | rearranges the rows of a matrix according to the order given in a list of integers.
-extractRows :: Element t => [Int] -> Matrix t -> Matrix t
+extractRows :: Storable t => [Int] -> Matrix t -> Matrix t
 extractRows l m = m ?? (Pos (idxs l), All)
 
 -- | rearranges the rows of a matrix according to the order given in a list of integers.
-extractColumns :: Element t => [Int] -> Matrix t -> Matrix t
+extractColumns :: Storable t => [Int] -> Matrix t -> Matrix t
 extractColumns l m = m ?? (All, Pos (idxs l))
 
 
@@ -476,13 +476,13 @@ extractColumns l m = m ?? (All, Pos (idxs l))
  , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 ]
 
 -}
-repmat :: (Element t) => Matrix t -> Int -> Int -> Matrix t
+repmat :: (Storable t) => Matrix t -> Int -> Int -> Matrix t
 repmat m r c
     | r == 0 || c == 0 = emptyM (r*rows m) (c*cols m)
     | otherwise = fromBlocks $ replicate r $ replicate c $ m
 
 -- | A version of 'liftMatrix2' which automatically adapt matrices with a single row or column to match the dimensions of the other matrix.
-liftMatrix2Auto :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t
+liftMatrix2Auto :: (Storable t, Storable a, Storable b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t
 liftMatrix2Auto f m1 m2
     | compat' m1 m2 = lM f m1  m2
     | ok            = lM f m1' m2'
@@ -499,7 +499,7 @@ liftMatrix2Auto f m1 m2
     m2' = conformMTo (r,c) m2
 
 -- FIXME do not flatten if equal order
-lM :: (Storable t, Element t1, Element t2)
+lM :: (Storable t, Storable t1, Storable t2)
    => (Vector t1 -> Vector t2 -> Vector t)
    -> Matrix t1 -> Matrix t2 -> Matrix t
 lM f m1 m2 = matrixFromVector
@@ -520,7 +520,7 @@ compat' m1 m2 = s1 == (1,1) || s2 == (1,1) || s1 == s2
 
 ------------------------------------------------------------
 
-toBlockRows :: Element t => [Int] -> Matrix t -> [Matrix t]
+toBlockRows :: Storable t => [Int] -> Matrix t -> [Matrix t]
 toBlockRows [r] m
     | r == rows m = [m]
 toBlockRows rs m
@@ -530,13 +530,13 @@ toBlockRows rs m
     szs = map (* cols m) rs
     g k = (k><0)[]
 
-toBlockCols :: Element t => [Int] -> Matrix t -> [Matrix t]
+toBlockCols :: Storable t => [Int] -> Matrix t -> [Matrix t]
 toBlockCols [c] m | c == cols m = [m]
 toBlockCols cs m = map trans . toBlockRows cs . trans $ m
 
 -- | Partition a matrix into blocks with the given numbers of rows and columns.
 -- The remaining rows and columns are discarded.
-toBlocks :: (Element t) => [Int] -> [Int] -> Matrix t -> [[Matrix t]]
+toBlocks :: (Storable t) => [Int] -> [Int] -> Matrix t -> [[Matrix t]]
 toBlocks rs cs m
     | ok = map (toBlockCols cs) . toBlockRows rs $ m
     | otherwise = error $ "toBlocks: bad partition: "++show rs++" "++show cs
@@ -546,7 +546,7 @@ toBlocks rs cs m
 
 -- | Fully partition a matrix into blocks of the same size. If the dimensions are not
 -- a multiple of the given size the last blocks will be smaller.
-toBlocksEvery :: (Element t) => Int -> Int -> Matrix t -> [[Matrix t]]
+toBlocksEvery :: (Storable t) => Int -> Int -> Matrix t -> [[Matrix t]]
 toBlocksEvery r c m
     | r < 1 || c < 1 = error $ "toBlocksEvery expects block sizes > 0, given "++show r++" and "++ show c
     | otherwise = toBlocks rs cs m
@@ -576,7 +576,7 @@ m[1,2] = 6
 
 -}
 mapMatrixWithIndexM_
-  :: (Element a, Num a, Monad m) =>
+  :: (Storable a, Num a, Monad m) =>
       ((Int, Int) -> a -> m ()) -> Matrix a -> m ()
 mapMatrixWithIndexM_ g m = mapVectorWithIndexM_ (mk c g) . flatten $ m
   where
@@ -592,7 +592,7 @@ Just (3><3)
 
 -}
 mapMatrixWithIndexM
-  :: (Element a, Storable b, Monad m) =>
+  :: (Storable a, Storable b, Monad m) =>
       ((Int, Int) -> a -> m b) -> Matrix a -> m (Matrix b)
 mapMatrixWithIndexM g m = liftM (reshape c) . mapVectorWithIndexM (mk c g) . flatten $ m
     where
@@ -608,11 +608,11 @@ mapMatrixWithIndexM g m = liftM (reshape c) . mapVectorWithIndexM (mk c g) . fla
 
  -}
 mapMatrixWithIndex
-  :: (Element a, Storable b) =>
+  :: (Storable a, Storable b) =>
       ((Int, Int) -> a -> b) -> Matrix a -> Matrix b
 mapMatrixWithIndex g m = reshape c . mapVectorWithIndex (mk c g) . flatten $ m
     where
       c = cols m
 
-mapMatrix :: (Element a, Element b) => (a -> b) -> Matrix a -> Matrix b
+mapMatrix :: (Storable a, Storable b) => (a -> b) -> Matrix a -> Matrix b
 mapMatrix f = liftMatrix (mapVector f)