14 files changed, 71 insertions, 80 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:
diff --git a/lib/Graphics/Plot.hs b/lib/Graphics/Plot.hs
index c763294..d2c96a6 100644
--- a/lib/Graphics/Plot.hs
+++ b/lib/Graphics/Plot.hs
@@ -32,8 +32,6 @@ import Numeric.LinearAlgebra.Linear(outer)
 import Numeric.GSL.Vector(FunCodeS(Max,Min),toScalarR)
 import Data.List(intersperse)
 import System
-import Data.IORef
-import System.Exit
 import Foreign hiding (rotate)
 
 
@@ -107,10 +105,7 @@ mplot m = gnuplotX (commands++dats) where
     dats = concat (replicate (length m-1) dat)
 
 
-
-
-
-
+{-
 mplot' m = do
     writeFile "plot-gnu-command" (commands++endcmd)
     toFile "plot-tmp.txt" (fromColumns m)
@@ -125,6 +120,7 @@ mplot' m = do
     plots = concat $ intersperse ", " (map cmd [2 .. length m])
     cmd k = "\"plot-tmp.txt\" using 1:"++show k++" with lines"
     endcmd = "pause -1"
+-}
 
 -- apply several functions to one object
 mapf fs x = map ($ x) fs
diff --git a/lib/Numeric/GSL/Differentiation.hs b/lib/Numeric/GSL/Differentiation.hs
index 09236bd..071704a 100644
--- a/lib/Numeric/GSL/Differentiation.hs
+++ b/lib/Numeric/GSL/Differentiation.hs
@@ -34,7 +34,7 @@ derivGen ::
 derivGen c h f x = unsafePerformIO $ do
     r <- malloc
     e <- malloc
-    fp <- mkfun (\x _ -> f x) 
+    fp <- mkfun (\y _ -> f y) 
     c_deriv c fp x h r e // check "deriv"
     vr <- peek r
     ve <- peek e
diff --git a/lib/Numeric/GSL/Matrix.hs b/lib/Numeric/GSL/Matrix.hs
index 07d4660..d51728e 100644
--- a/lib/Numeric/GSL/Matrix.hs
+++ b/lib/Numeric/GSL/Matrix.hs
@@ -17,13 +17,13 @@ module Numeric.GSL.Matrix(
     eigSg, eigHg,
     svdg,
     qr, qrPacked, unpackQR,
-    cholR, -- cholC,
+    cholR, cholC,
     luSolveR, luSolveC,
     luR, luC
 ) where
 
 import Data.Packed.Internal
-import Data.Packed.Matrix(fromLists,ident,takeDiag)
+import Data.Packed.Matrix(ident)
 import Numeric.GSL.Vector
 import Foreign
 import Complex
@@ -44,7 +44,7 @@ import Complex
 
 -}
 eigSg :: Matrix Double -> (Vector Double, Matrix Double)
-eigSg = eigSg . cmat
+eigSg = eigSg' . cmat
 
 eigSg' m
     | r == 1 = (fromList [cdat m `at` 0], singleton 1)
@@ -159,24 +159,24 @@ qrPacked :: Matrix Double -> (Matrix Double, Vector Double)
 qrPacked = qrPacked' . cmat
 
 qrPacked' x = unsafePerformIO $ do
-    qr <- createMatrix RowMajor r c
+    qrp <- createMatrix RowMajor r c
     tau <- createVector (min r c)
-    app3 c_qrPacked mat x mat qr vec tau "qrUnpacked"
-    return (qr,tau)
+    app3 c_qrPacked mat x mat qrp vec tau "qrUnpacked"
+    return (qrp,tau)
   where r = rows x
         c = cols x
 foreign import ccall "gsl-aux.h QRpacked" c_qrPacked :: TMMV
 
 unpackQR :: (Matrix Double, Vector Double) -> (Matrix Double, Matrix Double)
-unpackQR (qr,tau) = unpackQR' (cmat qr, tau)
+unpackQR (qrp,tau) = unpackQR' (cmat qrp, tau)
 
-unpackQR' (qr,tau) = unsafePerformIO $ do
+unpackQR' (qrp,tau) = unsafePerformIO $ do
     q <- createMatrix RowMajor r r
     res <- createMatrix RowMajor r c
-    app4 c_qrUnpack mat qr vec tau mat q mat res "qrUnpack"
+    app4 c_qrUnpack mat qrp vec tau mat q mat res "qrUnpack"
     return (q,res)
-  where r = rows qr
-        c = cols qr
+  where r = rows qrp
+        c = cols qrp
 foreign import ccall "gsl-aux.h QRunpack" c_qrUnpack :: TMVMM
 
 
@@ -259,7 +259,6 @@ luRaux' x = unsafePerformIO $ do
     app2 c_luRaux mat x vec res "luRaux"
     return res
   where r = rows x
-        c = cols x
 foreign import ccall "gsl-aux.h luRaux" c_luRaux :: TMV
 
 {- | lu decomposition of complex matrix (packed as a vector including l, u, the permutation and sign)
@@ -272,7 +271,6 @@ luCaux' x = unsafePerformIO $ do
     app2 c_luCaux mat x vec res "luCaux"
     return res
   where r = rows x
-        c = cols x
 foreign import ccall "gsl-aux.h luCaux" c_luCaux :: TCMCV
 
 {- | The LU decomposition of a square matrix. Is based on /gsl_linalg_LU_decomp/ and  /gsl_linalg_complex_LU_decomp/ as described in <http://www.gnu.org/software/Numeric.GSL/manual/Numeric.GSL-ref_13.html#SEC223>.
diff --git a/lib/Numeric/GSL/Minimization.hs b/lib/Numeric/GSL/Minimization.hs
index 235a88f..98c0ca9 100644
--- a/lib/Numeric/GSL/Minimization.hs
+++ b/lib/Numeric/GSL/Minimization.hs
@@ -24,7 +24,6 @@ module Numeric.GSL.Minimization (
 import Data.Packed.Internal
 import Data.Packed.Matrix
 import Foreign
-import Complex
 
 -------------------------------------------------------------------------
 
@@ -84,9 +83,9 @@ minimizeNMSimplex f xi sz tol maxit = unsafePerformIO $ do
         szv = fromList sz
         n   = dim xiv
     fp <- mkVecfun (iv (f.toList))
-    rawpath <- ww2 withVector xiv withVector szv $ \xiv szv ->
+    rawpath <- ww2 withVector xiv withVector szv $ \xiv' szv' ->
                    createMIO maxit (n+3)
-                         (c_minimizeNMSimplex fp tol maxit // xiv // szv)
+                         (c_minimizeNMSimplex fp tol maxit // xiv' // szv')
                          "minimizeNMSimplex"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
@@ -150,9 +149,9 @@ minimizeConjugateGradient istep minimpar tol maxit f df xi = unsafePerformIO $ d
         df' = (fromList . df . toList)
     fp <- mkVecfun (iv f')
     dfp <- mkVecVecfun (aux_vTov df')
-    rawpath <- withVector xiv $ \xiv ->
+    rawpath <- withVector xiv $ \xiv' ->
                     createMIO maxit (n+2)
-                         (c_minimizeConjugateGradient fp dfp istep minimpar tol maxit // xiv)
+                         (c_minimizeConjugateGradient fp dfp istep minimpar tol maxit // xiv')
                          "minimizeDerivV"
     let it = round (rawpath @@> (maxit-1,0))
         path = takeRows it rawpath
@@ -171,8 +170,8 @@ foreign import ccall "gsl-aux.h minimizeWithDeriv"
 ---------------------------------------------------------------------
 iv :: (Vector Double -> Double) -> (Int -> Ptr Double -> Double)
 iv f n p = f (createV n copy "iv") where
-    copy n q = do 
-        copyArray q p n
+    copy n' q = do
+        copyArray q p n'
         return 0
 
 -- | conversion of Haskell functions into function pointers that can be used in the C side
@@ -187,12 +186,12 @@ foreign import ccall "wrapper"
 
 aux_vTov :: (Vector Double -> Vector Double) -> (Int -> Ptr Double -> Ptr Double -> IO())
 aux_vTov f n p r = g where
-    v@V {fptr = pr} = f x
+    V {fptr = pr} = f x
     x = createV n copy "aux_vTov"
-    copy n q = do
-        copyArray q p n
+    copy n' q = do
+        copyArray q p n'
         return 0
-    g = withForeignPtr pr $ \p -> copyArray r p n
+    g = withForeignPtr pr $ \p' -> copyArray r p' n
 
 --------------------------------------------------------------------
 
@@ -202,6 +201,6 @@ createV n fun msg = unsafePerformIO $ do
     return r
 
 createMIO r c fun msg = do
-    r <- createMatrix RowMajor r c
-    app1 fun mat r msg
-    return r
+    res <- createMatrix RowMajor r c
+    app1 fun mat res msg
+    return res
diff --git a/lib/Numeric/GSL/Special.hs b/lib/Numeric/GSL/Special.hs
index b6cea2b..3fd2ac2 100644
--- a/lib/Numeric/GSL/Special.hs
+++ b/lib/Numeric/GSL/Special.hs
@@ -44,8 +44,6 @@ module Numeric.GSL.Special (
 )
 where
 
-import Foreign
-import Numeric.GSL.Special.Internal
 import Numeric.GSL.Special.Airy
 import Numeric.GSL.Special.Bessel
 import Numeric.GSL.Special.Clausen
diff --git a/lib/Numeric/LinearAlgebra.hs b/lib/Numeric/LinearAlgebra.hs
index f3190a2..c14d4e4 100644
--- a/lib/Numeric/LinearAlgebra.hs
+++ b/lib/Numeric/LinearAlgebra.hs
@@ -23,5 +23,5 @@ module Numeric.LinearAlgebra (
 import Data.Packed
 import Numeric.LinearAlgebra.Linear
 import Numeric.LinearAlgebra.Algorithms
-import Numeric.LinearAlgebra.Instances
+import Numeric.LinearAlgebra.Instances()
 import Numeric.LinearAlgebra.Interface
diff --git a/lib/Numeric/LinearAlgebra/Algorithms.hs b/lib/Numeric/LinearAlgebra/Algorithms.hs
index fd16973..069d9a3 100644
--- a/lib/Numeric/LinearAlgebra/Algorithms.hs
+++ b/lib/Numeric/LinearAlgebra/Algorithms.hs
@@ -165,8 +165,8 @@ pinv m = linearSolveSVD m (ident (rows m))
 -- If @(u,d,v) = full svd m@ then @m == u \<> d \<> trans v@.
 full :: Element t 
      => (Matrix t -> (Matrix t, Vector Double, Matrix t)) -> Matrix t -> (Matrix t, Matrix Double, Matrix t)
-full svd m = (u, d ,v) where
-    (u,s,v) = svd m
+full svd' m = (u, d ,v) where
+    (u,s,v) = svd' m
     d = diagRect s r c
     r = rows m
     c = cols m
@@ -176,12 +176,12 @@ full svd m = (u, d ,v) where
 -- If @(u,s,v) = economy svd m@ then @m == u \<> diag s \<> trans v@.
 economy :: Element t 
         => (Matrix t -> (Matrix t, Vector Double, Matrix t)) -> Matrix t -> (Matrix t, Vector Double, Matrix t)
-economy svd m = (u', subVector 0 d s, v') where
-    (u,s,v) = svd m
+economy svd' m = (u', subVector 0 d s, v') where
+    (u,s,v) = svd' m
     sl@(g:_) = toList s
     s' = fromList . filter (>tol) $ sl
     t = 1
-    tol = (fromIntegral (max (rows m) (cols m)) * g * t * eps)
+    tol = (fromIntegral (max r c) * g * t * eps)
     r = rows m
     c = cols m
     d = dim s'
@@ -273,8 +273,8 @@ nullspacePrec t m = ns where
     (_,s,v) = svd m
     sl@(g:_) = toList s
     tol = (fromIntegral (max (rows m) (cols m)) * g * t * eps)
-    rank = length (filter (> g*tol) sl)
-    ns = drop rank $ toRows $ ctrans v
+    rank' = length (filter (> g*tol) sl)
+    ns = drop rank' $ toRows $ ctrans v
 
 -- | The nullspace of a matrix, assumed to be one-dimensional, with default tolerance (shortcut for @last . nullspacePrec 1@).
 nullVector :: Field t => Matrix t -> Vector t
@@ -306,7 +306,7 @@ pinvTol t m = v' `mXm` diag s' `mXm` trans u' where
     sl@(g:_) = toList s
     s' = fromList . map rec $ sl
     rec x = if x < g*tol then 1 else 1/x
-    tol = (fromIntegral (max (rows m) (cols m)) * g * t * eps)
+    tol = (fromIntegral (max r c) * g * t * eps)
     r = rows m
     c = cols m
     d = dim s
@@ -368,10 +368,12 @@ rank :: Field t => Matrix t -> Int
 rank m | pnorm PNorm1 m < eps = 0
        | otherwise = dim s where (_,s,_) = economy svd m
 
+{-
 expm' m = case diagonalize (complex m) of
     Just (l,v) -> v `mXm` diag (exp l) `mXm` inv v
     Nothing -> error "Sorry, expm not yet implemented for non-diagonalizable matrices"
   where exp = vectorMapC Exp
+-}
 
 diagonalize m = if rank v == n
                     then Just (l,v)
@@ -406,7 +408,7 @@ geps delta = head [ k | (k,g) <- epslist, g<delta]
 expGolub m = iterate msq f !! j
     where j = max 0 $ floor $ log2 $ pnorm Infinity m
           log2 x = log x / log 2
-          a = m */ fromIntegral (2^j)
+          a = m */ fromIntegral ((2::Int)^j)
           q = geps eps -- 7 steps
           eye = ident (rows m)
           work (k,c,x,n,d) = (k',c',x',n',d')
@@ -415,9 +417,9 @@ expGolub m = iterate msq f !! j
                     x' = a <> x
                     n' = n |+| (c' .* x')
                     d' = d |+| (((-1)^k * c') .* x')
-          (_,_,_,n,d) = iterate work (1,1,eye,eye,eye) !! q
-          f = linearSolve d n
-          msq m = m <> m
+          (_,_,_,nf,df) = iterate work (1,1,eye,eye,eye) !! q
+          f = linearSolve df nf
+          msq x = x <> x
 
           (<>) = multiply
           v */ x = scale (recip x) v
@@ -446,9 +448,10 @@ It only works with invertible matrices that have a real solution. For diagonaliz
 sqrtm :: Field t => Matrix t -> Matrix t
 sqrtm = sqrtmInv
 
-sqrtmInv a = fst $ fixedPoint $ iterate f (a, ident (rows a))
+sqrtmInv x = fst $ fixedPoint $ iterate f (x, ident (rows x))
     where fixedPoint (a:b:rest) | pnorm PNorm1 (fst a |-| fst b) < eps   = a
                                 | otherwise = fixedPoint (b:rest)
+          fixedPoint _ = error "fixedpoint with impossible inputs"
           f (y,z) = (0.5 .* (y |+| inv z),
                      0.5 .* (inv y |+| z))
           (.*) = scale
diff --git a/lib/Numeric/LinearAlgebra/LAPACK.hs b/lib/Numeric/LinearAlgebra/LAPACK.hs
index 936cb19..cacad87 100644
--- a/lib/Numeric/LinearAlgebra/LAPACK.hs
+++ b/lib/Numeric/LinearAlgebra/LAPACK.hs
@@ -120,11 +120,12 @@ eigRaux m
   where r = rows m
 
 fixeig  []  _ =  []
-fixeig [r] [v] = [comp v]
+fixeig [_] [v] = [comp v]
 fixeig ((r1:+i1):(r2:+i2):r) (v1:v2:vs)
     | r1 == r2 && i1 == (-i2) = toComplex (v1,v2) : toComplex (v1,scale (-1) v2) : fixeig r vs
     | otherwise = comp v1 : fixeig ((r2:+i2):r) (v2:vs)
   where scale = vectorMapValR Scale
+fixeig _ _ = error "fixeig with impossible inputs"
 
 -----------------------------------------------------------------------------
 
diff --git a/lib/Numeric/LinearAlgebra/Linear.hs b/lib/Numeric/LinearAlgebra/Linear.hs
index 3403591..a39df50 100644
--- a/lib/Numeric/LinearAlgebra/Linear.hs
+++ b/lib/Numeric/LinearAlgebra/Linear.hs
@@ -20,7 +20,7 @@ module Numeric.LinearAlgebra.Linear (
 ) where
 
 
-import Data.Packed.Internal(multiply,at,partit)
+import Data.Packed.Internal(multiply,partit)
 import Data.Packed
 import Numeric.GSL.Vector
 import Complex