8 files changed, 188 insertions, 136 deletions

diff --git a/lib/Data/Packed/Matrix.hs b/lib/Data/Packed/Matrix.hs
index 9059723..2855a90 100644
--- a/lib/Data/Packed/Matrix.hs
+++ b/lib/Data/Packed/Matrix.hs
@@ -21,7 +21,7 @@
 module Data.Packed.Matrix (
     Element, RealElement, Container(..),
     Convert(..), RealOf, ComplexOf, SingleOf, DoubleOf, ElementOf,
-    Precision(..), comp, real'', complex'',
+    Precision(..), comp,
     AutoReal(..),
     Matrix,rows,cols,
     (><),
@@ -485,7 +485,10 @@ instance Precision (Complex Float) (Complex Double) where
     float2DoubleG = asComplex . float2DoubleV . asReal
 
 -- | Supported real types
-class (Element t, Element (Complex t), RealFloat t) => RealElement t
+class (Element t, Element (Complex t), RealFloat t
+--       , RealOf t ~ t, RealOf (Complex t) ~ t
+       )
+       => RealElement t
 
 instance RealElement Double
 
@@ -501,6 +504,8 @@ class Container c where
     single'      :: Precision a b => c b -> c a
     double'      :: Precision a b => c a -> c b
 
+comp x = complex' x
+
 instance Container Vector where
     toComplex = toComplexV
     fromComplex = fromComplexV
@@ -592,34 +597,23 @@ instance Convert (Complex Float) where
 
 -------------------------------------------------------------------
 
-
 -- | to be replaced by Convert
 class Convert t => AutoReal t where
-    real''' :: Container c => c Double -> c t
-    complex''' :: Container c => c t -> c (Complex Double)
+    real'' :: Container c => c Double -> c t
+    complex'' :: Container c => c t -> c (Complex Double)
 
 instance AutoReal Double where
-    real''' = real
-    complex''' = complex
+    real'' = real
+    complex'' = complex
 
 instance AutoReal (Complex Double) where
-    real''' = real
-    complex''' = complex
+    real'' = real
+    complex'' = complex
 
 instance AutoReal Float where
-    real''' = real . single
-    complex''' = double . complex
+    real'' = real . single
+    complex'' = double . complex
 
 instance AutoReal (Complex Float) where
-    real''' = real . single
-    complex''' = double . complex
-
-
-comp x = complex' x
-
--- complex'' x = double (complex x)
--- real'' x = real (single x)
-
-real'' x = real''' x
-complex'' x = complex''' x
-
+    real'' = real . single
+    complex'' = double . complex
diff --git a/lib/Numeric/GSL/Fitting.hs b/lib/Numeric/GSL/Fitting.hs
index b1f3a32..e5aa528 100644
--- a/lib/Numeric/GSL/Fitting.hs
+++ b/lib/Numeric/GSL/Fitting.hs
@@ -109,7 +109,7 @@ err (model,deriv) dat vsol = zip sol errs where
     sol = toList vsol
     c = max 1 (chi/sqrt (fromIntegral dof))
     dof = length dat - (rows cov)
-    chi = pnorm PNorm2 (fromList $ cost (resMs model) dat sol)
+    chi = norm2 (fromList $ cost (resMs model) dat sol)
     js = fromLists $ jacobian (resDs deriv) dat sol
     cov = inv $ trans js <> js
     errs = toList $ scalar c * sqrt (takeDiag cov)
diff --git a/lib/Numeric/LinearAlgebra/Algorithms.hs b/lib/Numeric/LinearAlgebra/Algorithms.hs
index 7e258de..0f3ff0e 100644
--- a/lib/Numeric/LinearAlgebra/Algorithms.hs
+++ b/lib/Numeric/LinearAlgebra/Algorithms.hs
@@ -1,5 +1,8 @@
 {-# LANGUAGE FlexibleContexts, FlexibleInstances #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE TypeFamilies #-}
 -----------------------------------------------------------------------------
 {- |
 Module      :  Numeric.LinearAlgebra.Algorithms
@@ -58,10 +61,9 @@ module Numeric.LinearAlgebra.Algorithms (
     nullspacePrec,
     nullVector,
     nullspaceSVD,
--- * Norms
-    Normed(..), NormType(..),
 -- * Misc
-    eps, i,
+    eps, peps, i,
+    Normed(..), NormType(..),
 -- * Util
     haussholder,
     unpackQR, unpackHess,
@@ -72,17 +74,15 @@ module Numeric.LinearAlgebra.Algorithms (
 
 
 import Data.Packed.Internal hiding ((//))
---import Data.Packed.Vector
 import Data.Packed.Matrix
 import Data.Complex
-import Numeric.GSL.Vector
 import Numeric.LinearAlgebra.LAPACK as LAPACK
 import Numeric.LinearAlgebra.Linear
 import Data.List(foldl1')
 import Data.Array
 
 -- | Auxiliary typeclass used to define generic computations for both real and complex matrices.
-class (AutoReal t, Prod t, Linear Vector t, Linear Matrix t) => Field t where
+class (Product t, Linear Vector t, Linear Matrix t) => Field t where
     svd'         :: Matrix t -> (Matrix t, Vector Double, Matrix t)
     thinSVD'     :: Matrix t -> (Matrix t, Vector Double, Matrix t)
     sv'          :: Matrix t -> Vector Double
@@ -172,6 +172,9 @@ thinSVD = {-# SCC "thinSVD" #-} thinSVD'
 singularValues :: Field t => Matrix t -> Vector Double
 singularValues = {-# SCC "singularValues" #-} sv'
 
+instance (Field t, RealOf t ~ Double) => Norm2 Matrix t where
+    norm2 m = singularValues m @> 0
+
 -- | A version of 'svd' which returns an appropriate diagonal matrix with the singular values.
 --
 -- If @(u,d,v) = fullSVD m@ then @m == u \<> d \<> trans v@.
@@ -379,80 +382,16 @@ ranksv teps maxdim s = k where
 eps :: Double
 eps =  2.22044604925031e-16
 
-peps :: RealFloat x => x -> x
-peps x = 2.0**(fromIntegral $ 1-floatDigits x)
+
+-- | 1 + 0.5*peps == 1,  1 + 0.6*peps /= 1
+peps :: RealFloat x => x
+peps = x where x = 2.0**(fromIntegral $ 1-floatDigits x)
 
 
 -- | The imaginary unit: @i = 0.0 :+ 1.0@
 i :: Complex Double
 i = 0:+1
 
----------------------------------------------------------------------------
-
-norm2 :: Vector Double -> Double
-norm2 = toScalarR Norm2
-
-norm1 :: Vector Double -> Double
-norm1 = toScalarR AbsSum
-
-data NormType = Infinity | PNorm1 | PNorm2 -- PNorm Int
-
-pnormRV PNorm2 = norm2
-pnormRV PNorm1 = norm1
-pnormRV Infinity = vectorMax . vectorMapR Abs
---pnormRV _ = error "pnormRV not yet defined"
-
-pnormCV PNorm2 = norm2 . asReal
-pnormCV PNorm1 = norm1 . mapVector magnitude
-pnormCV Infinity = vectorMax . mapVector magnitude
---pnormCV _ = error "pnormCV not yet defined"
-
-pnormRM PNorm2 m = singularValues m @> 0
-pnormRM PNorm1 m = vectorMax $ constant 1 (rows m) `vXm` liftMatrix (vectorMapR Abs) m
-pnormRM Infinity m = vectorMax $ liftMatrix (vectorMapR Abs) m `mXv` constant 1 (cols m)
---pnormRM _ _ = error "p norm not yet defined"
-
-pnormCM PNorm2 m = singularValues m @> 0
-pnormCM PNorm1 m = vectorMax $ constant 1 (rows m) `vXm` liftMatrix (mapVector magnitude) m
-pnormCM Infinity m = vectorMax $ liftMatrix (mapVector magnitude) m `mXv` constant 1 (cols m)
---pnormCM _ _ = error "p norm not yet defined"
-
--- | Objects which have a p-norm.
--- Using it you can define convenient shortcuts:
---
--- @norm2 x = pnorm PNorm2 x@
---
--- @frobenius m = norm2 . flatten $ m@
-class Normed t where
-    pnorm :: NormType -> t -> Double
-
-instance Normed (Vector Double) where
-    pnorm = pnormRV
-
-instance Normed (Vector (Complex Double)) where
-    pnorm = pnormCV
-
-instance Normed (Matrix Double) where
-    pnorm = pnormRM
-
-instance Normed (Matrix (Complex Double)) where
-    pnorm = pnormCM
-
------------------------------------------------------------------------
--- to be optimized
-
-instance Normed (Vector Float) where
-    pnorm t = pnorm t . double
-
-instance Normed (Vector (Complex Float)) where
-    pnorm t = pnorm t . double
-
-instance Normed (Matrix Float) where
-    pnorm t = pnorm t . double
-
-instance Normed (Matrix (Complex Float)) where
-    pnorm t = pnorm t . double
-
 -----------------------------------------------------------------------
 
 -- | The nullspace of a matrix from its SVD decomposition.
@@ -588,8 +527,8 @@ diagonalize m = if rank v == n
 --
 -- @logm = matFunc log@
 --
-matFunc :: (Field t) => (Complex Double -> Complex Double) -> Matrix t -> Matrix (Complex Double)
-matFunc f m = case diagonalize (complex'' m) of
+matFunc :: (Complex Double -> Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)
+matFunc f m = case diagonalize m of
     Just (l,v) -> v `mXm` diag (mapVector f l) `mXm` inv v
     Nothing -> error "Sorry, matFunc requires a diagonalizable matrix" 
 
@@ -607,7 +546,7 @@ epslist = [ (fromIntegral k, golubeps k k) | k <- [1..]]
 geps delta = head [ k | (k,g) <- epslist, g<delta]
 
 expGolub m = iterate msq f !! j
-    where j = max 0 $ floor $ log2 $ pnorm Infinity m
+    where j = max 0 $ floor $ log2 $ normInf m
           log2 x = log x / log 2
           a = m */ fromIntegral ((2::Int)^j)
           q = geps eps -- 7 steps
@@ -630,7 +569,7 @@ expGolub m = iterate msq f !! j
 {- | Matrix exponential. It uses a direct translation of Algorithm 11.3.1 in Golub & Van Loan,
      based on a scaled Pade approximation.
 -}
-expm :: (Normed (Matrix t), Field t) => Matrix t -> Matrix t
+expm :: (Norm Vector t, Field t) => Matrix t -> Matrix t
 expm = expGolub
 
 --------------------------------------------------------------
@@ -646,11 +585,11 @@ It only works with invertible matrices that have a real solution. For diagonaliz
  [ 2.0, 2.25
  , 0.0,  2.0 ]@
 -}
-sqrtm ::  (Normed (Matrix t), Field t) => Matrix t -> Matrix t
+sqrtm ::  (Norm Vector t, Field t) => Matrix t -> Matrix t
 sqrtm = sqrtmInv
 
 sqrtmInv x = fst $ fixedPoint $ iterate f (x, ident (rows x))
-    where fixedPoint (a:b:rest) | pnorm PNorm1 (fst a |-| fst b) < eps   = a
+    where fixedPoint (a:b:rest) | norm1 (fst a |-| fst b) < peps   = a
                                 | otherwise = fixedPoint (b:rest)
           fixedPoint _ = error "fixedpoint with impossible inputs"
           f (y,z) = (0.5 .* (y |+| inv z),
@@ -691,4 +630,35 @@ luFact (l_u,perm) | r <= c    = (l ,u ,p, s)
     (|+|) = add
     (|*|) = mul
 
---------------------------------------------------
+---------------------------------------------------------------------------
+
+data NormType = Infinity | PNorm1 | PNorm2
+
+-- | Old class
+class Normed t where
+    pnorm :: NormType -> t -> Double
+
+instance Norm Vector t => Normed (Vector t) where
+    pnorm PNorm1   = realToFrac . norm1
+    pnorm PNorm2   = realToFrac . normFrob
+    pnorm Infinity = realToFrac . normInf
+
+instance Normed (Matrix Double) where
+    pnorm PNorm1   = norm1
+    pnorm PNorm2   = norm2
+    pnorm Infinity = normInf
+
+instance Normed (Matrix (Complex Double)) where
+    pnorm PNorm1   = norm1
+    pnorm PNorm2   = norm2
+    pnorm Infinity = normInf
+
+instance Normed (Matrix Float) where
+    pnorm PNorm1   = realToFrac . norm1
+    pnorm PNorm2   = norm2 . double -- not yet optimized for Float
+    pnorm Infinity = realToFrac . normInf
+
+instance Normed (Matrix (Complex Float)) where
+    pnorm PNorm1   = realToFrac . norm1
+    pnorm PNorm2   = norm2 . double -- not yet optimized for Float
+    pnorm Infinity = realToFrac . normInf
diff --git a/lib/Numeric/LinearAlgebra/Interface.hs b/lib/Numeric/LinearAlgebra/Interface.hs
index 542d76e..ec08694 100644
--- a/lib/Numeric/LinearAlgebra/Interface.hs
+++ b/lib/Numeric/LinearAlgebra/Interface.hs
@@ -1,4 +1,5 @@
 {-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE UndecidableInstances #-}
 -----------------------------------------------------------------------------
 {- |
 Module      :  Numeric.LinearAlgebra.Interface
@@ -18,7 +19,7 @@ In the context of the standard numeric operators, one-component vectors and matr
 -----------------------------------------------------------------------------
 
 module Numeric.LinearAlgebra.Interface(
-    (<>),(<.>),
+    (<>),(<.>),mulG, Adapt, adaptElements,
     (<\>),
     (.*),(*/),
     (<|>),(<->),
@@ -28,22 +29,28 @@ import Data.Packed.Vector
 import Data.Packed.Matrix
 import Numeric.LinearAlgebra.Algorithms
 import Numeric.LinearAlgebra.Linear
+import Data.Complex
+import Control.Arrow((***))
 
 --import Numeric.GSL.Vector
 
 class Mul a b c | a b -> c where
  infixl 7 <>
  -- | Matrix-matrix, matrix-vector, and vector-matrix products.
- (<>) :: Prod t => a t -> b t -> c t
+ (<>)  :: Product t => a t -> b t -> c t
+ mulG :: (Element r, Element s, Adapt r s t t, Product t) => a r -> b s -> c t
 
 instance Mul Matrix Matrix Matrix where
-    (<>) = multiply
+    (<>) = mXm
+    mulG a b = uncurry mXm (curry adapt a b)
 
 instance Mul Matrix Vector Vector where
     (<>) m v = flatten $ m <> (asColumn v)
+    mulG m v = flatten $ m `mulG` (asColumn v)
 
 instance Mul Vector Matrix Vector where
     (<>) v m = flatten $ (asRow v) <> m
+    mulG v m = flatten $ (asRow v) `mulG` m
 
 ---------------------------------------------------
 
@@ -120,3 +127,45 @@ a <-> b = joinV a b
 
 ----------------------------------------------------
 
+class Adapt a b c d | a b -> c, a b -> d where
+    adapt :: Container k => (k a, k b) -> (k c, k d) 
+
+--instance Adapt a a a a where
+--    adapt = id *** id
+
+instance Adapt Float Float Float Float where
+    adapt = id *** id
+
+instance Adapt Double Double Double Double where
+    adapt = id *** id
+
+instance Adapt (Complex Float) (Complex Float) (Complex Float) (Complex Float) where
+    adapt = id *** id
+
+instance Adapt Float Double Double Double where
+    adapt = double *** id
+
+instance Adapt Double Float Double Double where
+    adapt = id *** double
+
+instance Adapt Float (Complex Float) (Complex Float) (Complex Float) where
+    adapt = complex *** id
+
+instance Adapt (Complex Float) Float (Complex Float) (Complex Float) where
+    adapt = id *** complex
+
+instance (Convert a, Convert (DoubleOf a), ComplexOf (DoubleOf a) ~ Complex Double) => Adapt a (Complex Double) (Complex Double) (Complex Double) where
+    adapt = complex.double *** id
+
+instance (Convert a, Convert (DoubleOf a), ComplexOf (DoubleOf a) ~ Complex Double) => Adapt (Complex Double) a (Complex Double) (Complex Double) where
+    adapt = id *** complex.double
+
+instance Adapt Double (Complex Float) (Complex Double) (Complex Double) where
+    adapt = complex *** double
+
+instance Adapt (Complex Float) Double (Complex Double) (Complex Double) where
+    adapt = double *** complex
+
+adaptElements:: (Adapt a b c d, Container k) => (k a, k b) -> (k c, k d)
+adaptElements p = adapt p
+
diff --git a/lib/Numeric/LinearAlgebra/Linear.hs b/lib/Numeric/LinearAlgebra/Linear.hs
index 67921d8..6c21a16 100644
--- a/lib/Numeric/LinearAlgebra/Linear.hs
+++ b/lib/Numeric/LinearAlgebra/Linear.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE UndecidableInstances, MultiParamTypeClasses, FlexibleInstances #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies #-}
 -----------------------------------------------------------------------------
 {- |
 Module      :  Numeric.LinearAlgebra.Linear
@@ -20,9 +21,11 @@ module Numeric.LinearAlgebra.Linear (
     Vectors(..),
     Linear(..),
     -- * Products
-    Prod(..),
+    Product(..),
     mXm,mXv,vXm,
     outer, kronecker,
+    -- * Norms
+    Norm(..), Norm2(..),
     -- * Creation of numeric vectors
     constant, linspace
 ) where
@@ -190,38 +193,38 @@ linspace n (a,b) = addConstant a $ scale s $ fromList [0 .. fromIntegral n-1]
 
 ----------------------------------------------------
 
-class Element t => Prod t where
+class Element t => Product t where
     multiply :: Matrix t -> Matrix t -> Matrix t
     ctrans :: Matrix t -> Matrix t
 
-instance Prod Double where
+instance Product Double where
     multiply = multiplyR
     ctrans = trans
 
-instance Prod (Complex Double) where
+instance Product (Complex Double) where
     multiply = multiplyC
     ctrans = conj . trans
 
-instance Prod Float where
+instance Product Float where
     multiply = multiplyF
     ctrans = trans
 
-instance Prod (Complex Float) where
+instance Product (Complex Float) where
     multiply = multiplyQ
     ctrans = conj . trans
 
 ----------------------------------------------------------
 
 -- synonym for matrix product
-mXm :: Prod t => Matrix t -> Matrix t -> Matrix t
+mXm :: Product t => Matrix t -> Matrix t -> Matrix t
 mXm = multiply
 
 -- matrix - vector product
-mXv :: Prod t => Matrix t -> Vector t -> Vector t
+mXv :: Product t => Matrix t -> Vector t -> Vector t
 mXv m v = flatten $ m `mXm` (asColumn v)
 
 -- vector - matrix product
-vXm :: Prod t => Vector t -> Matrix t -> Vector t
+vXm :: Product t => Vector t -> Matrix t -> Vector t
 vXm v m = flatten $ (asRow v) `mXm` m
 
 {- | Outer product of two vectors.
@@ -232,7 +235,7 @@ vXm v m = flatten $ (asRow v) `mXm` m
  , 10.0, 4.0, 6.0
  , 15.0, 6.0, 9.0 ]@
 -}
-outer :: (Prod t) => Vector t -> Vector t -> Matrix t
+outer :: (Product t) => Vector t -> Vector t -> Matrix t
 outer u v = asColumn u `multiply` asRow v
 
 {- | Kronecker product of two matrices.
@@ -257,9 +260,47 @@ m2=(4><3)
  ,  0.0,  0.0,  0.0,  -7.0,  -8.0,  -9.0, 21.0, 24.0, 27.0
  ,  0.0,  0.0,  0.0, -10.0, -11.0, -12.0, 30.0, 33.0, 36.0 ]@
 -}
-kronecker :: (Prod t) => Matrix t -> Matrix t -> Matrix t
+kronecker :: (Product t) => Matrix t -> Matrix t -> Matrix t
 kronecker a b = fromBlocks
               . splitEvery (cols a)
               . map (reshape (cols b))
               . toRows
               $ flatten a `outer` flatten b
+
+--------------------------------------------------
+
+-- | simple norms
+class (Element t, RealFloat (RealOf t)) => Norm c t where
+    norm1   :: c t -> RealOf t
+    normInf  :: c t -> RealOf t
+    normFrob :: c t -> RealOf t
+
+instance Norm Vector Double where
+    normFrob = toScalarR Norm2
+    norm1 = toScalarR AbsSum
+    normInf = vectorMax . vectorMapR Abs
+
+instance Norm Vector Float where
+    normFrob = toScalarF Norm2
+    norm1 = toScalarF AbsSum
+    normInf = vectorMax . vectorMapF Abs
+
+instance (Norm Vector t, Vectors Vector t, RealElement t
+         , RealOf t ~ t, RealOf (Complex t) ~ t
+         ) => Norm Vector (Complex t) where
+    normFrob = normFrob . asReal
+    norm1 = norm1 . mapVector magnitude
+    normInf = vectorMax . mapVector magnitude
+
+instance Norm Vector t => Norm Matrix t where
+    normFrob = normFrob . flatten
+    norm1 = maximum . map norm1 . toColumns
+    normInf = norm1 . trans
+
+class Norm2 c t where
+    norm2 :: c t -> RealOf t
+
+instance Norm Vector t => Norm2 Vector t where
+    norm2 = normFrob
+
+-- (the instance Norm2 Matrix t requires singular values and is defined later)
diff --git a/lib/Numeric/LinearAlgebra/Tests.hs b/lib/Numeric/LinearAlgebra/Tests.hs
index 91f6742..77bb2f7 100644
--- a/lib/Numeric/LinearAlgebra/Tests.hs
+++ b/lib/Numeric/LinearAlgebra/Tests.hs
@@ -168,7 +168,7 @@ fittingTest = utest "levmar" (ok1 && ok2)
     sol = fst $ fitModel 1E-4 1E-4 20 (expModel, expModelDer) dat [1,0,0]
 
     ok1 = and (zipWith f sols [5,0.1,1]) where f (x,d) r = abs (x-r)<2*d
-    ok2 = pnorm PNorm2 (fromList (map fst sols) - fromList sol) < 1E-5
+    ok2 = norm2 (fromList (map fst sols) - fromList sol) < 1E-5
 
 -----------------------------------------------------
 
@@ -318,7 +318,7 @@ runTests n = do
     test (cholProp   . rPosDef)
     test (cholProp   . cPosDef)
     putStrLn "------ expm"
-    test (expmDiagProp . rSqWC)
+    test (expmDiagProp . complex. rSqWC)
     test (expmDiagProp . cSqWC)
     putStrLn "------ fft"
     test (\v -> ifft (fft v) |~| v)
diff --git a/lib/Numeric/LinearAlgebra/Tests/Instances.hs b/lib/Numeric/LinearAlgebra/Tests/Instances.hs
index aaaff28..21a6f88 100644
--- a/lib/Numeric/LinearAlgebra/Tests/Instances.hs
+++ b/lib/Numeric/LinearAlgebra/Tests/Instances.hs
@@ -27,13 +27,10 @@ module Numeric.LinearAlgebra.Tests.Instances(
 ) where
 
 
-import Numeric.LinearAlgebra hiding (real,complex)
+import Numeric.LinearAlgebra
 import Control.Monad(replicateM)
 #include "quickCheckCompat.h"
 
-real x = real'' x
-complex x = complex'' x
-
 #if MIN_VERSION_QuickCheck(2,0,0)
 shrinkListElementwise :: (Arbitrary a) => [a] -> [[a]]
 shrinkListElementwise []     = []
@@ -72,7 +69,7 @@ instance (Field a, Arbitrary a) => Arbitrary (Vector a) where
 #if MIN_VERSION_QuickCheck(2,0,0)
     -- shrink any one of the components
     shrink = map fromList . shrinkListElementwise . toList
-                              
+
 #else
     coarbitrary = undefined
 #endif
@@ -140,7 +137,7 @@ instance (Field a, Arbitrary a, Num (Vector a)) => Arbitrary (Her a) where
 
 -- a well-conditioned general matrix (the singular values are between 1 and 100)
 newtype (WC a) = WC (Matrix a) deriving Show
-instance (Field a, Arbitrary a) => Arbitrary (WC a) where
+instance (AutoReal a, Field a, Arbitrary a) => Arbitrary (WC a) where
     arbitrary = do
         m <- arbitrary
         let (u,_,v) = svd m
@@ -149,7 +146,7 @@ instance (Field a, Arbitrary a) => Arbitrary (WC a) where
             n = min r c
         sv' <- replicateM n (choose (1,100))
         let s = diagRect (fromList sv') r c
-        return $ WC (u <> real s <> trans v)
+        return $ WC (u <> real'' s <> trans v)
 
 #if MIN_VERSION_QuickCheck(2,0,0)
 #else
@@ -159,14 +156,14 @@ instance (Field a, Arbitrary a) => Arbitrary (WC a) where
 
 -- a well-conditioned square matrix (the singular values are between 1 and 100)
 newtype (SqWC a) = SqWC (Matrix a) deriving Show
-instance (Field a, Arbitrary a) => Arbitrary (SqWC a) where
+instance (AutoReal a, Field a, Arbitrary a) => Arbitrary (SqWC a) where
     arbitrary = do
         Sq m <- arbitrary
         let (u,_,v) = svd m
             n = rows m
         sv' <- replicateM n (choose (1,100))
         let s = diag (fromList sv')
-        return $ SqWC (u <> real s <> trans v)
+        return $ SqWC (u <> real'' s <> trans v)
 
 #if MIN_VERSION_QuickCheck(2,0,0)
 #else
@@ -176,14 +173,14 @@ instance (Field a, Arbitrary a) => Arbitrary (SqWC a) where
 
 -- a positive definite square matrix (the eigenvalues are between 0 and 100)
 newtype (PosDef a) = PosDef (Matrix a) deriving Show
-instance (Field a, Arbitrary a, Num (Vector a)) => Arbitrary (PosDef a) where
+instance (AutoReal a, Field a, Arbitrary a, Num (Vector a)) => Arbitrary (PosDef a) where
     arbitrary = do
         Her m <- arbitrary
         let (_,v) = eigSH m
             n = rows m
         l <- replicateM n (choose (0,100))
         let s = diag (fromList l)
-            p = v <> real s <> ctrans v
+            p = v <> real'' s <> ctrans v
         return $ PosDef (0.5 * p + 0.5 * ctrans p)
 
 #if MIN_VERSION_QuickCheck(2,0,0)
@@ -243,3 +240,4 @@ cPosDef (PosDef m) = m :: CM
 
 rConsist (Consistent (a,b)) = (a,b::RM)
 cConsist (Consistent (a,b)) = (a,b::CM)
+
diff --git a/lib/Numeric/LinearAlgebra/Tests/Properties.hs b/lib/Numeric/LinearAlgebra/Tests/Properties.hs
index 9891d8a..d6bb338 100644
--- a/lib/Numeric/LinearAlgebra/Tests/Properties.hs
+++ b/lib/Numeric/LinearAlgebra/Tests/Properties.hs
@@ -54,15 +54,15 @@ complex x = complex'' x
 debug x = trace (show x) x
 
 -- relative error
-dist :: (Normed t, Num t) => t -> t -> Double
+--dist :: (Normed t, Num t) => t -> t -> Double
 dist a b = r
-    where norm = pnorm Infinity
+    where norm = normInf
           na = norm a
           nb = norm b
           nab = norm (a-b)
           mx = max na nb
           mn = min na nb
-          r = if mn < eps
+          r = if mn < peps
                 then mx
                 else nab/mx
 
@@ -71,7 +71,7 @@ a |~| b = a :~10~: b
 --a |~| b = dist a b < 10^^(-10)
 
 data Aprox a = (:~) a Int
-(~:) :: (Normed a, Num a) => Aprox a -> a -> Bool
+-- (~:) :: (Normed a, Num a) => Aprox a -> a -> Bool
 a :~n~: b = dist a b < 10^^(-n)
 
 ------------------------------------------------------