8 files changed, 45 insertions, 46 deletions

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