5 files changed, 24 insertions, 28 deletions

diff --git a/lib/Data/Packed/Internal/Common.hs b/lib/Data/Packed/Internal/Common.hs
index dc1c2b4..7305d8c 100644
--- a/lib/Data/Packed/Internal/Common.hs
+++ b/lib/Data/Packed/Internal/Common.hs
@@ -20,9 +20,6 @@ import Foreign
 import Complex
 import Control.Monad(when)
 import Debug.Trace
-import Data.List(transpose,intersperse)
-import Data.Typeable
-import Data.Maybe(fromJust)
 import Foreign.C.String(peekCString)
 import Foreign.C.Types
 
diff --git a/lib/Data/Packed/Internal/Matrix.hs b/lib/Data/Packed/Internal/Matrix.hs
index 0519603..4cc94b7 100644
--- a/lib/Data/Packed/Internal/Matrix.hs
+++ b/lib/Data/Packed/Internal/Matrix.hs
@@ -22,7 +22,6 @@ import Data.Packed.Internal.Vector
 import Foreign hiding (xor)
 import Complex
 import Control.Monad(when)
-import Data.Maybe(fromJust)
 import Foreign.C.String
 import Foreign.C.Types
 import Data.List(transpose)
@@ -83,14 +82,14 @@ mat = withMatrix
 
 withMatrix MC {rows = r, cols = c, cdat = d } f =
     withForeignPtr (fptr d) $ \p -> do
-        let m f = do
-            f r c p
+        let m g = do
+            g r c p
         f m
 
 withMatrix MF {rows = r, cols = c, fdat = d } f =
     withForeignPtr (fptr d) $ \p -> do
-        let m f = do
-            f r c p
+        let m g = do
+            g r c p
         f m
 
 {- | Creates a vector by concatenation of rows
@@ -262,8 +261,8 @@ foreign import ccall safe "auxi.h transC"
 
 ------------------------------------------------------------------
 
-gmatC MF {rows = r, cols = c, fdat = d} p f = f 1 c r p
-gmatC MC {rows = r, cols = c, cdat = d} p f = f 0 r c p
+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
 
 dtt MC { cdat = d } = d
 dtt MF { fdat = d } = d
@@ -273,8 +272,8 @@ multiplyAux fun a b = unsafePerformIO $ do
                                       show (rows a,cols a) ++ " x " ++ show (rows b, cols b)
     r <- createMatrix RowMajor (rows a) (cols b)
     withForeignPtr (fptr (dtt a)) $ \pa -> withForeignPtr (fptr (dtt b)) $ \pb ->
-        withMatrix r $ \r ->
-            fun // gmatC a pa // gmatC b pb // r // check "multiplyAux"
+        withMatrix r $ \r' ->
+            fun // gmatC a pa // gmatC b pb // r' // check "multiplyAux"
     return r
 
 multiplyR = multiplyAux cmultiplyR
@@ -421,7 +420,7 @@ diagG v = matrixFromVector RowMajor c $ fromList $ [ l!!(i-1) * delta k i | k <-
                     | otherwise = 0
 -}
 
-transdataG c1 d c2 = fromList . concat . transpose . partit c1 . toList $ d
+transdataG c1 d _ = fromList . concat . transpose . partit c1 . toList $ d
 
 dotL a b = sum (zipWith (*) a b)
 
diff --git a/lib/Data/Packed/Internal/Vector.hs b/lib/Data/Packed/Internal/Vector.hs
index 7eee5fe..ac6588b 100644
--- a/lib/Data/Packed/Internal/Vector.hs
+++ b/lib/Data/Packed/Internal/Vector.hs
@@ -20,7 +20,6 @@ import Data.Packed.Internal.Common
 import Foreign
 import Complex
 import Control.Monad(when)
-import Data.List(transpose)
 
 -- | A one-dimensional array of objects stored in a contiguous memory block.
 data Vector t = V { dim  :: Int              -- ^ number of elements
@@ -39,8 +38,8 @@ type Vc t s = Int -> Ptr t -> s
 vec = withVector
 
 withVector (V n fp) f = withForeignPtr fp $ \p -> do
-    let v f = do
-        f n p
+    let v g = do
+        g n p
     f v
 
 -- | allocates memory for a new vector
@@ -132,7 +131,7 @@ join as = unsafePerformIO $ do
         joiner as tot ptr
     return r
   where joiner [] _ _ = return ()
-        joiner (r@V {dim = n, fptr = b} : cs) _ p = do
+        joiner (V {dim = n, fptr = b} : cs) _ p = do
             withForeignPtr b $ \pb -> copyArray p pb n
             joiner cs 0 (advancePtr p n)
 
diff --git a/lib/Data/Packed/Matrix.hs b/lib/Data/Packed/Matrix.hs
index 7b6bf29..62d28b1 100644
--- a/lib/Data/Packed/Matrix.hs
+++ b/lib/Data/Packed/Matrix.hs
@@ -33,10 +33,7 @@ module Data.Packed.Matrix (
 ) where
 
 import Data.Packed.Internal
-import Foreign(Storable)
-import Complex
 import Data.Packed.Vector
-import Numeric(showGFloat)
 import Data.List(transpose,intersperse)
 import Data.Array
 
@@ -89,8 +86,8 @@ diagRect s r c
     | dim s < min r c = error "diagRect"
     | r == c    = diag s
     | r < c     = trans $ diagRect s c r
-    | r > c     = joinVert  [diag s , zeros (r-c,c)]
-    where zeros (r,c) = reshape c $ constantD 0 (r*c)
+    | otherwise = joinVert  [diag s , zeros (r-c,c)]
+    where zeros (r',c') = reshape c' $ constantD 0 (r'*c')
 
 -- | extracts the diagonal from a rectangular matrix
 takeDiag :: (Element t) => Matrix t -> Vector t
@@ -123,16 +120,16 @@ r >< c = f where
 
 -- | Creates a matrix with the first n rows of another matrix
 takeRows :: Element t => Int -> Matrix t -> Matrix t
-takeRows n mat = subMatrix (0,0) (n, cols mat) mat
+takeRows n mt = subMatrix (0,0) (n, cols mt) mt
 -- | Creates a copy of a matrix without the first n rows
 dropRows :: Element t => Int -> Matrix t -> Matrix t
-dropRows n mat = subMatrix (n,0) (rows mat - n, cols mat) mat
+dropRows n mt = subMatrix (n,0) (rows mt - n, cols mt) mt
 -- |Creates a matrix with the first n columns of another matrix
 takeColumns :: Element t => Int -> Matrix t -> Matrix t
-takeColumns n mat = subMatrix (0,0) (rows mat, n) mat
+takeColumns n mt = subMatrix (0,0) (rows mt, n) mt
 -- | Creates a copy of a matrix without the first n columns
 dropColumns :: Element t => Int -> Matrix t -> Matrix t
-dropColumns n mat = subMatrix (0,n) (rows mat, cols mat - n) mat
+dropColumns n mt = subMatrix (0,n) (rows mt, cols mt - n) mt
 
 ----------------------------------------------------------------
 
@@ -164,6 +161,7 @@ fromArray2D m = (r><c) (elems m)
           c = c1-c0+1
 
 ------------------------------------------------------
+{-
 -- shows a Double with n digits after the decimal point    
 shf :: (RealFloat a) => Int -> a -> String     
 shf dec n | abs n < 1e-10 = "0."
@@ -177,6 +175,8 @@ shfc n z@ (a:+b)
     | b > 0         = shf n a ++"+"++shf n b ++"i"
     | otherwise     = shf n a ++shf n b ++"i"         
 
+-}
+
 dsp' :: String -> [[String]] -> String
 dsp' sep as = unlines . map unwords' $ transpose mtp where 
     mt = transpose as
@@ -196,6 +196,7 @@ this function the user can easily define any desired display function:
 format :: (Element t) => String -> (t -> String) -> Matrix t -> String
 format sep f m = dsp' sep . map (map f) . toLists $ m
 
+{-
 disp m f = putStrLn $ "matrix ("++show (rows m) ++"x"++ show (cols m) ++")\n"++format " | " f m
 
 dispR :: Int -> Matrix Double -> IO ()
@@ -203,6 +204,7 @@ dispR d m = disp m (shf d)
 
 dispC :: Int -> Matrix (Complex Double) -> IO ()
 dispC d m = disp m (shfc d)
+-}
 
 -- | creates a matrix from a table of numbers.
 readMatrix :: String -> Matrix Double
@@ -211,7 +213,7 @@ readMatrix = fromLists . map (map read). map words . filter (not.null) . lines
 -- | 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 l m = fromRows $ extract (toRows $ m) l
-    where extract l is = [l!!i |i<-is]
+    where extract l' is = [l'!!i |i<-is]
 
 {- | creates matrix by repetition of a matrix a given number of rows and columns
 
diff --git a/lib/Data/Packed/Vector.hs b/lib/Data/Packed/Vector.hs
index 60fa7c1..6415c5c 100644
--- a/lib/Data/Packed/Vector.hs
+++ b/lib/Data/Packed/Vector.hs
@@ -23,7 +23,6 @@ module Data.Packed.Vector (
 ) where
 
 import Data.Packed.Internal
-import Complex
 import Numeric.GSL.Vector
 
 {- | Creates a real vector containing a range of values: