12 files changed, 276 insertions, 136 deletions

diff --git a/hmatrix.cabal b/hmatrix.cabal
index 736c443..de7b1cb 100644
--- a/hmatrix.cabal
+++ b/hmatrix.cabal
@@ -123,7 +123,7 @@ library
        cpp-options:     -DVECTOR
 
     if flag(tests)
-       Build-Depends:   QuickCheck, HUnit
+       Build-Depends:   QuickCheck, HUnit, random
        exposed-modules: Numeric.LinearAlgebra.Tests
        other-modules:   Numeric.LinearAlgebra.Tests.Instances,
                         Numeric.LinearAlgebra.Tests.Properties
diff --git a/lib/Data/Packed/Internal/Matrix.hs b/lib/Data/Packed/Internal/Matrix.hs
index 100b8ea..e66817e 100644
--- a/lib/Data/Packed/Internal/Matrix.hs
+++ b/lib/Data/Packed/Internal/Matrix.hs
@@ -29,7 +29,6 @@ module Data.Packed.Internal.Matrix(
     liftMatrix, liftMatrix2,
     (@@>),
     saveMatrix,
-    fromComplexV, toComplexV, conjV,
     singleton
 ) where
 
@@ -386,21 +385,6 @@ subMatrix' (r0,c0) (rt,ct) m = trans $ subMatrix' (c0,r0) (ct,rt) (trans m)
 
 --------------------------------------------------------------------------
 
--- | obtains the complex conjugate of a complex vector
-conjV :: (Storable a, RealFloat a) => Vector (Complex a) -> Vector (Complex a)
-conjV = mapVector conjugate
-
--- | creates a complex vector from vectors with real and imaginary parts
-toComplexV :: (RealFloat a, Element a) => (Vector a, Vector a) ->  Vector (Complex a)
-toComplexV (r,i) = asComplex $ flatten $ fromColumns [r,i]
-
--- | the inverse of 'toComplex'
-fromComplexV :: (RealFloat a, Element a) => Vector (Complex a) -> (Vector a, Vector a)
-fromComplexV z = (r,i) where
-    [r,i] = toColumns $ reshape 2 $ asReal z
-
---------------------------------------------------------------------------
-
 -- | Saves a matrix as 2D ASCII table.
 saveMatrix :: FilePath
            -> String     -- ^ format (%f, %g, %e)
diff --git a/lib/Data/Packed/Matrix.hs b/lib/Data/Packed/Matrix.hs
index b860cb1..03e5889 100644
--- a/lib/Data/Packed/Matrix.hs
+++ b/lib/Data/Packed/Matrix.hs
@@ -55,6 +55,7 @@ import Control.Monad(replicateM)
 --import Control.Arrow((***))
 --import GHC.Float(double2Float,float2Double)
 
+
 -------------------------------------------------------------------
 
 instance (Binary a, Element a, Storable a) => Binary (Matrix a) where
diff --git a/lib/Data/Packed/Vector.hs b/lib/Data/Packed/Vector.hs
index ad690f9..253f2fa 100644
--- a/lib/Data/Packed/Vector.hs
+++ b/lib/Data/Packed/Vector.hs
@@ -72,7 +72,6 @@ instance (Binary a, Storable a) => Binary (Vector a) where
 
 -------------------------------------------------------------------
 
-
 {-
 vectorFMax :: Vector Float -> Float
 vectorFMax = toScalarF Max
diff --git a/lib/Numeric/Container.hs b/lib/Numeric/Container.hs
index 010235f..a0e489b 100644
--- a/lib/Numeric/Container.hs
+++ b/lib/Numeric/Container.hs
@@ -19,11 +19,13 @@
 -----------------------------------------------------------------------------
 
 module Numeric.Container (
-    Container(..), RealElement, Precision, NumericContainer(..), comp,
-    Convert(..), AutoReal(..),
-    RealOf, ComplexOf, SingleOf, DoubleOf,
+    Linear(..),
+    Container(..), RealElement, Precision(..), NumericContainer(..), comp, 
+--    Complexable(..), Precisionable(..),
+    Convert(..), --AutoReal(..), 
+    RealOf, ComplexOf, SingleOf, DoubleOf, 
 
---    ElementOf,
+--    ElementOf, 
 
     IndexOf,
 
@@ -33,11 +35,10 @@ module Numeric.Container (
 import Data.Packed.Vector
 import Data.Packed.Matrix
 import Data.Packed.Internal.Vector
-import Data.Packed.Internal.Matrix
+--import Data.Packed.Internal.Matrix
 --import qualified Data.Packed.ST as ST
 
-import Control.Arrow((***))
-
+--import Control.Arrow((***))
 import Data.Complex
 
 -------------------------------------------------------------------
@@ -71,7 +72,7 @@ class NumericContainer c where
     fromComplex :: (RealElement e) => c (Complex e) -> (c e, c e)
     complex'    :: (RealElement e) => c e -> c (Complex e)
     conj        :: (RealElement e) => c (Complex e) -> c (Complex e)
-    cmap        :: (Element a, Element b) => (a -> b) -> c a -> c b
+--    cmap        :: (Element a, Element b) => (a -> b) -> c a -> c b
     single'      :: Precision a b => c b -> c a
     double'      :: Precision a b => c a -> c b
 
@@ -79,25 +80,6 @@ class NumericContainer c where
 comp :: (NumericContainer c, RealElement e) => c e -> c (Complex e)
 comp x = complex' x
 
-instance NumericContainer Vector where
-    toComplex = toComplexV
-    fromComplex = fromComplexV
-    complex' v = toComplex (v,constantD 0 (dim v))
-    conj = conjV
-    cmap = mapVector
-    single' = double2FloatG
-    double' = float2DoubleG
-
-instance NumericContainer Matrix where
-    toComplex = uncurry $ liftMatrix2 $ curry toComplex
-    fromComplex z = (reshape c *** reshape c) . fromComplex . flatten $ z
-        where c = cols z
-    complex' = liftMatrix complex'
-    conj = liftMatrix conj
-    cmap f = liftMatrix (cmap f)
-    single' = liftMatrix single'
-    double' = liftMatrix double'
-
 -------------------------------------------------------------------
 
 type family RealOf x
@@ -141,14 +123,78 @@ type instance IndexOf Vector = Int
 type instance IndexOf Matrix = (Int,Int)
 
 -------------------------------------------------------------------
+{-
+-- | Supported single-double precision type pairs
+class (Element e) => V_Precision e where
+    v_double2FloatG :: Vector e -> Vector (SingleOf e)
+    v_float2DoubleG :: Vector (SingleOf e) -> Vector e
+{-
+instance V_Precision Float where
+    v_double2FloatG = double2FloatV
+    v_float2DoubleG = float2DoubleV
+-}
+instance V_Precision Double where
+    v_double2FloatG = double2FloatV
+    v_float2DoubleG = float2DoubleV
+{-
+instance V_Precision (Complex Float) where
+    v_double2FloatG = asComplex . double2FloatV . asReal
+    v_float2DoubleG = asComplex . float2DoubleV . asReal
+-}
+instance V_Precision (Complex Double) where
+    v_double2FloatG = asComplex . double2FloatV . asReal
+    v_float2DoubleG = asComplex . float2DoubleV . asReal
+-}
+-------------------------------------------------------------------
+{-
+-- | converting to/from complex containers
+class RealElement t => Complexable c t where
+    v_toComplex   :: (c t, c t) -> c (Complex t)
+    v_fromComplex :: c (Complex t) -> (c t, c t)
+    v_complex'    :: c t -> c (Complex t)
+    v_conj        :: c (Complex t) -> c (Complex t)
+
+-- | converting to/from single/double precision numbers
+class (Element (SingleOf t), Element t, RealElement (RealOf t)) => Precisionable c t where
+    v_single'      :: (V_Precision (DoubleOf t)) => c t -> c (SingleOf t)
+    v_double'      :: (V_Precision (DoubleOf t)) => c t -> c (DoubleOf t)
 
 -- | generic conversion functions
-class Convert t where
+class (Element t, RealElement (RealOf t)) => V_Convert t where
+    -- | real/complex
+    v_real    :: Complexable c (RealOf t) => c (RealOf t) -> c t    -- from the instances, this looks like it turns a real object into a complex object WHEN the context is a complex object
+    v_complex :: Complexable c (RealOf t) => c t -> c (ComplexOf t)
+    -- | single/double
+    v_single  :: Precisionable c t => c t -> c (SingleOf t)
+    v_double  :: Precisionable c t => c t -> c (DoubleOf t)
+-}
+-------------------------------------------------------------------
+{-
+instance Precisionable Vector Float where
+    v_single' = id
+    v_double' = float2DoubleG
+
+instance Precisionable Vector Double where
+    v_single' = double2FloatG
+    v_double' = id
+
+instance Precisionable Vector (Complex Float) where
+    v_single' = id
+    v_double' = float2DoubleG
+
+instance Precisionable Vector (Complex Double) where
+    v_single' = double2FloatG
+    v_double' = id
+-}
+-------------------------------------------------------------------
+
+class (Element t, Element (RealOf t)) => Convert t where
     real    :: NumericContainer c => c (RealOf t) -> c t
     complex :: NumericContainer c => c t -> c (ComplexOf t)
     single  :: NumericContainer c => c t -> c (SingleOf t)
     double  :: NumericContainer c => c t -> c (DoubleOf t)
 
+
 instance Convert Double where
     real = id
     complex = complex'
@@ -180,6 +226,7 @@ class Convert t => AutoReal t where
     real'' :: NumericContainer c => c Double -> c t
     complex'' :: NumericContainer c => c t -> c (Complex Double)
 
+
 instance AutoReal Double where
     real'' = real
     complex'' = complex
@@ -198,13 +245,60 @@ instance AutoReal (Complex Float) where
 
 -------------------------------------------------------------------
 
--- | Basic element-by-element functions.
+-- | Basic element-by-element functions for numeric containers
 class (Element e) => Container c e where
+{-
+    -- | create a structure with a single element
+    scalar      :: e -> c e
+    -- | multiply every element by a scalar
+    scale       :: e -> c e -> c e
+    -- | scale the element by element reciprocal of the object:
+    --
+    -- @scaleRecip 2 (fromList [5,i]) == 2 |> [0.4 :+ 0.0,0.0 :+ (-2.0)]@
+    scaleRecip  :: e -> c e -> c e
+    -- | add a constant to each element
+    addConstant :: e -> c e -> c e
+    add         :: c e -> c e -> c e
+    sub         :: c e -> c e -> c e
+    -- | element by element multiplication
+    mul         :: c e -> c e -> c e
+    -- | element by element division
+    divide      :: c e -> c e -> c e
+    equal       :: c e -> c e -> Bool
+-}
+    -- | cannot implement instance Functor because of Element class constraint
+    cmap        :: (Element a, Element b) => (a -> b) -> c a -> c b
+    --
+    -- | indexing function
+    atIndex     :: c e -> IndexOf c -> e
+    -- | index of min/max element
     minIndex    :: c e -> IndexOf c
     maxIndex    :: c e -> IndexOf c
+    -- | value of min/max element
     minElement  :: c e -> e
     maxElement  :: c e -> e
+    -- the C functions sumX/prodX are twice as fast as using foldVector
+    -- | the sum/product of elements (faster than using @fold@
+    sumElements :: c e -> e
+    prodElements :: c e -> e
 
+-- | Basic element-by-element functions.
+class (Element e, Container c e) => Linear c e where
+    -- | create a structure with a single element
+    scalar      :: e -> c e
+    scale       :: e -> c e -> c e
+    -- | scale the element by element reciprocal of the object:
+    --
+    -- @scaleRecip 2 (fromList [5,i]) == 2 |> [0.4 :+ 0.0,0.0 :+ (-2.0)]@
+    scaleRecip  :: e -> c e -> c e
+    addConstant :: e -> c e -> c e
+    add         :: c e -> c e -> c e
+    sub         :: c e -> c e -> c e
+    -- | element by element multiplication
+    mul         :: c e -> c e -> c e
+    -- | element by element division
+    divide      :: c e -> c e -> c e
+    equal       :: c e -> c e -> Bool
 
 
 
diff --git a/lib/Numeric/LinearAlgebra/Algorithms.hs b/lib/Numeric/LinearAlgebra/Algorithms.hs
index ac46847..8306961 100644
--- a/lib/Numeric/LinearAlgebra/Algorithms.hs
+++ b/lib/Numeric/LinearAlgebra/Algorithms.hs
@@ -85,7 +85,7 @@ import Numeric.Vector
 import Numeric.Matrix()
 
 -- | Auxiliary typeclass used to define generic computations for both real and complex matrices.
-class (Product t, Linear Vector t, Linear Matrix t) => Field t where
+class (Product t, Linear Vector t, Container Vector t, Container 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
diff --git a/lib/Numeric/LinearAlgebra/LAPACK.hs b/lib/Numeric/LinearAlgebra/LAPACK.hs
index 8888712..5d0154d 100644
--- a/lib/Numeric/LinearAlgebra/LAPACK.hs
+++ b/lib/Numeric/LinearAlgebra/LAPACK.hs
@@ -44,6 +44,7 @@ module Numeric.LinearAlgebra.LAPACK (
 import Data.Packed.Internal
 import Data.Packed.Matrix
 import Data.Complex
+import Numeric.Vector()
 import Numeric.Container
 import Numeric.GSL.Vector(vectorMapValR, FunCodeSV(Scale))
 import Foreign
diff --git a/lib/Numeric/LinearAlgebra/Linear.hs b/lib/Numeric/LinearAlgebra/Linear.hs
index 952661d..775060e 100644
--- a/lib/Numeric/LinearAlgebra/Linear.hs
+++ b/lib/Numeric/LinearAlgebra/Linear.hs
@@ -18,7 +18,7 @@ Basic optimized operations on vectors and matrices.
 
 module Numeric.LinearAlgebra.Linear (
     -- * Linear Algebra Typeclasses
-    Vectors(..), Linear(..),
+    Vectors(..),
     -- * Products
     Product(..),
     mXm,mXv,vXm,
@@ -34,22 +34,52 @@ import Data.Packed.Matrix
 import Data.Packed.Vector
 import Data.Complex
 import Numeric.Container
---import Numeric.Vector
---import Numeric.Matrix
---import Numeric.GSL.Vector
+import Numeric.Vector()
+import Numeric.Matrix()
+import Numeric.GSL.Vector
 import Numeric.LinearAlgebra.LAPACK(multiplyR,multiplyC,multiplyF,multiplyQ)
 
--- | basic Vector functions
+-- | Linear algebraic properties of objects
 class Num e => Vectors a e where
-    -- the C functions sumX are twice as fast as using foldVector
-    vectorSum  :: a e -> e
-    vectorProd :: a e -> e
-    absSum     :: a e -> e
+    -- | dot (inner) product
     dot        :: a e -> a e -> e
+    -- | sum of absolute value of elements (differs in complex case from @norm1@
+    absSum     :: a e -> e
+    -- | sum of absolute value of elements
     norm1      :: a e -> e
+    -- | euclidean norm
     norm2      :: a e -> e
+    -- | element of maximum magnitude
     normInf    :: a e -> e
 
+instance Vectors Vector Float where
+    norm2      = toScalarF Norm2
+    absSum     = toScalarF AbsSum
+    dot        = dotF
+    norm1      = toScalarF AbsSum
+    normInf    = maxElement . vectorMapF Abs
+
+instance Vectors Vector Double where
+    norm2      = toScalarR Norm2
+    absSum     = toScalarR AbsSum
+    dot        = dotR
+    norm1      = toScalarR AbsSum
+    normInf    = maxElement . vectorMapR Abs
+
+instance Vectors Vector (Complex Float) where
+    norm2      = (:+ 0) . toScalarQ Norm2
+    absSum     = (:+ 0) . toScalarQ AbsSum
+    dot        = dotQ
+    norm1      = (:+ 0) . sumElements . fst . fromComplex . vectorMapQ Abs
+    normInf    = (:+ 0) . maxElement . fst . fromComplex . vectorMapQ Abs
+
+instance Vectors Vector (Complex Double) where
+    norm2      = (:+ 0) . toScalarC Norm2
+    absSum     = (:+ 0) . toScalarC AbsSum
+    dot        = dotC
+    norm1      = (:+ 0) . sumElements . fst . fromComplex . vectorMapC Abs
+    normInf    = (:+ 0) . maxElement . fst . fromComplex . vectorMapC Abs
+
 ----------------------------------------------------
 
 class Element t => Product t where
@@ -128,22 +158,3 @@ kronecker a b = fromBlocks
 
 
 -------------------------------------------------------------------
-
-
--- | Basic element-by-element functions.
-class (Element e, Container c e) => Linear c e where
-    -- | create a structure with a single element
-    scalar      :: e -> c e
-    scale       :: e -> c e -> c e
-    -- | scale the element by element reciprocal of the object:
-    --
-    -- @scaleRecip 2 (fromList [5,i]) == 2 |> [0.4 :+ 0.0,0.0 :+ (-2.0)]@
-    scaleRecip  :: e -> c e -> c e
-    addConstant :: e -> c e -> c e
-    add         :: c e -> c e -> c e
-    sub         :: c e -> c e -> c e
-    -- | element by element multiplication
-    mul         :: c e -> c e -> c e
-    -- | element by element division
-    divide      :: c e -> c e -> c e
-    equal       :: c e -> c e -> Bool
diff --git a/lib/Numeric/LinearAlgebra/Tests/Instances.hs b/lib/Numeric/LinearAlgebra/Tests/Instances.hs
index 21a6f88..6046ccb 100644
--- a/lib/Numeric/LinearAlgebra/Tests/Instances.hs
+++ b/lib/Numeric/LinearAlgebra/Tests/Instances.hs
@@ -26,6 +26,7 @@ module Numeric.LinearAlgebra.Tests.Instances(
     FM,ZM, fM,zM
 ) where
 
+import System.Random
 
 import Numeric.LinearAlgebra
 import Control.Monad(replicateM)
@@ -137,7 +138,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 (AutoReal a, Field a, Arbitrary a) => Arbitrary (WC a) where
+instance (Convert a, Field a, Arbitrary a, Random (RealOf a)) => Arbitrary (WC a) where
     arbitrary = do
         m <- arbitrary
         let (u,_,v) = svd m
@@ -146,7 +147,7 @@ instance (AutoReal a, 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
@@ -156,14 +157,14 @@ instance (AutoReal a, 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 (AutoReal a, Field a, Arbitrary a) => Arbitrary (SqWC a) where
+instance (Convert a, Field a, Arbitrary a, Random (RealOf 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
@@ -173,14 +174,15 @@ instance (AutoReal a, 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 (AutoReal a, Field a, Arbitrary a, Num (Vector a)) => Arbitrary (PosDef a) where
+instance (Convert a, Field a, Arbitrary a, Num (Vector a), Random (RealOf 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)
diff --git a/lib/Numeric/LinearAlgebra/Tests/Properties.hs b/lib/Numeric/LinearAlgebra/Tests/Properties.hs
index d312e52..b96f53e 100644
--- a/lib/Numeric/LinearAlgebra/Tests/Properties.hs
+++ b/lib/Numeric/LinearAlgebra/Tests/Properties.hs
@@ -42,14 +42,14 @@ module Numeric.LinearAlgebra.Tests.Properties (
     linearSolveProp, linearSolveProp2
 ) where
 
-import Numeric.LinearAlgebra hiding (real,complex)
+import Numeric.LinearAlgebra --hiding (real,complex)
 import Numeric.LinearAlgebra.LAPACK
 import Debug.Trace
 #include "quickCheckCompat.h"
 
 
-real x = real'' x
-complex x = complex'' x
+--real x = real'' x
+--complex x = complex'' x
 
 debug x = trace (show x) x
 
diff --git a/lib/Numeric/Matrix.hs b/lib/Numeric/Matrix.hs
index f240384..73515c1 100644
--- a/lib/Numeric/Matrix.hs
+++ b/lib/Numeric/Matrix.hs
@@ -27,11 +27,13 @@ module Numeric.Matrix (
 import Data.Packed.Vector
 import Data.Packed.Matrix
 import Numeric.Container
-import Numeric.LinearAlgebra.Linear
---import Numeric.Vector
+--import Numeric.LinearAlgebra.Linear
+import Numeric.Vector()
 
 import Control.Monad(ap)
 
+import Control.Arrow((***))
+
 -------------------------------------------------------------------
 
 instance Linear Matrix a => Eq (Matrix a) where
@@ -75,7 +77,34 @@ instance (Linear Vector a, Floating (Vector a), Fractional (Matrix a)) => Floati
 
 ---------------------------------------------------------------
 
-instance (Linear Vector a, NumericContainer Matrix) => (Linear Matrix a) where
+instance NumericContainer Matrix where
+    toComplex = uncurry $ liftMatrix2 $ curry toComplex
+    fromComplex z = (reshape c *** reshape c) . fromComplex . flatten $ z
+        where c = cols z
+    complex' = liftMatrix complex'
+    conj = liftMatrix conj
+--    cmap f = liftMatrix (cmap f)
+    single' = liftMatrix single'
+    double' = liftMatrix double'
+
+---------------------------------------------------------------
+{-
+instance (RealElement e, Complexable Vector e) => Complexable Matrix e where
+    v_toComplex = uncurry $ liftMatrix2 $ curry toComplex
+    v_fromComplex z = (reshape c *** reshape c) . fromComplex . flatten $ z
+        where c = cols z
+    v_conj = liftMatrix conj
+    v_complex' = liftMatrix complex'
+
+---------------------------------------------------------------
+
+instance (Precisionable Vector e) => Precisionable Matrix e where
+    v_single' = liftMatrix single'
+    v_double' = liftMatrix double'
+-}
+---------------------------------------------------------------
+
+instance (Linear Vector a, Container Matrix a) => Linear Matrix a where
     scale x = liftMatrix (scale x)
     scaleRecip x = liftMatrix (scaleRecip x)
     addConstant x = liftMatrix (addConstant x)
@@ -85,16 +114,19 @@ instance (Linear Vector a, NumericContainer Matrix) => (Linear Matrix a) where
     divide = liftMatrix2 divide
     equal a b = cols a == cols b && flatten a `equal` flatten b
     scalar x = (1><1) [x]
-
-
-instance (Linear Vector a, NumericContainer Matrix) => (Container Matrix a) where
+    --
+instance (Container Vector a) => Container Matrix a where
+    cmap f = liftMatrix (mapVector f)
+    atIndex = (@@>)
     minIndex m = let (r,c) = (rows m,cols m)
-                     i = 1 + (minIndex $ flatten m)
-                 in (i `div` r,i `mod` r)
+                     i = (minIndex $ flatten m)
+                 in (i `div` c,(i `mod` c) + 1)
     maxIndex m = let (r,c) = (rows m,cols m)
-                     i = 1 + (maxIndex $ flatten m)
-                 in (i `div` r,i `mod` r)
+                     i = (maxIndex $ flatten m)
+                 in (i `div` c,(i `mod` c) + 1)
     minElement = ap (@@>) minIndex
     maxElement = ap (@@>) maxIndex
+    sumElements = sumElements . flatten
+    prodElements = prodElements . flatten
 
 ----------------------------------------------------
diff --git a/lib/Numeric/Vector.hs b/lib/Numeric/Vector.hs
index d92a5e4..5cc51ac 100644
--- a/lib/Numeric/Vector.hs
+++ b/lib/Numeric/Vector.hs
@@ -30,10 +30,12 @@ import Control.Monad(ap)
 
 import Data.Packed.Vector
 import Data.Packed.Internal.Matrix(Element(..))
+import Data.Packed.Internal.Vector(asComplex,asReal)
+import Data.Packed.Matrix(toColumns,fromColumns,flatten,reshape)
 import Numeric.GSL.Vector
 
 import Numeric.Container
-import Numeric.LinearAlgebra.Linear
+--import Numeric.LinearAlgebra.Linear
 
 -------------------------------------------------------------------
 
@@ -254,6 +256,40 @@ instance Floating (Vector (Complex Float)) where
 
 ---------------------------------------------------------------
 
+-- | obtains the complex conjugate of a complex vector
+conjV :: (RealElement a) => Vector (Complex a) -> Vector (Complex a)
+conjV = mapVector conjugate
+
+-- | creates a complex vector from vectors with real and imaginary parts
+toComplexV :: (RealElement a) => (Vector a, Vector a) ->  Vector (Complex a)
+toComplexV (r,i) = asComplex $ flatten $ fromColumns [r,i]
+
+-- | the inverse of 'toComplex'
+fromComplexV :: (RealElement a) => Vector (Complex a) -> (Vector a, Vector a)
+fromComplexV z = (r,i) where
+    [r,i] = toColumns $ reshape 2 $ asReal z
+
+--------------------------------------------------------------------------
+
+instance NumericContainer Vector where
+    toComplex = toComplexV
+    fromComplex = fromComplexV
+    complex' v = toComplex (v,constant 0 (dim v))
+    conj = conjV
+--    cmap = mapVector
+    single' = double2FloatG
+    double' = float2DoubleG
+
+--------------------------------------------------------------------------
+{-
+instance RealElement e => Complexable Vector e where
+    v_toComplex = toComplexV
+    v_fromComplex = fromComplexV
+    v_conj = conjV
+    v_complex' v = toComplex (v,constantD 0 (dim v))
+-}
+-------------------------------------------------------------------
+
 instance Linear Vector Float where
     scale = vectorMapValF Scale
     scaleRecip = vectorMapValF Recip
@@ -264,12 +300,16 @@ instance Linear Vector Float where
     divide = vectorZipF Div
     equal u v = dim u == dim v && maxElement (vectorMapF Abs (sub u v)) == 0.0
     scalar x = fromList [x]
-
+    --
 instance Container Vector Float where
+    cmap = mapVector
+    atIndex = (@>)
     minIndex     = round . toScalarF MinIdx
     maxIndex     = round . toScalarF MaxIdx
     minElement  = toScalarF Min
     maxElement  = toScalarF Max
+    sumElements  = sumF
+    prodElements = prodF
 
 instance Linear Vector Double where
     scale = vectorMapValR Scale
@@ -281,12 +321,16 @@ instance Linear Vector Double where
     divide = vectorZipR Div
     equal u v = dim u == dim v && maxElement (vectorMapR Abs (sub u v)) == 0.0
     scalar x = fromList [x]
-
+    --
 instance Container Vector Double where
+    cmap = mapVector
+    atIndex = (@>)
     minIndex     = round . toScalarR MinIdx
     maxIndex     = round . toScalarR MaxIdx
     minElement  = toScalarR Min
     maxElement  = toScalarR Max
+    sumElements  = sumR
+    prodElements = prodR
 
 instance Linear Vector (Complex Double) where
     scale = vectorMapValC Scale
@@ -298,12 +342,16 @@ instance Linear Vector (Complex Double) where
     divide = vectorZipC Div
     equal u v = dim u == dim v && maxElement (mapVector magnitude (sub u v)) == 0.0
     scalar x = fromList [x]
-
+    --
 instance Container Vector (Complex Double) where
+    cmap = mapVector
+    atIndex = (@>)
     minIndex     = minIndex . fst . fromComplex . (zipVectorWith (*) `ap` mapVector conjugate)
     maxIndex     = maxIndex . fst . fromComplex . (zipVectorWith (*) `ap` mapVector conjugate)
     minElement  = ap (@>) minIndex
     maxElement  = ap (@>) maxIndex
+    sumElements  = sumC
+    prodElements = prodC
 
 instance Linear Vector (Complex Float) where
     scale = vectorMapValQ Scale
@@ -315,47 +363,15 @@ instance Linear Vector (Complex Float) where
     divide = vectorZipQ Div
     equal u v = dim u == dim v && maxElement (mapVector magnitude (sub u v)) == 0.0
     scalar x = fromList [x]
-
+    --
 instance Container Vector (Complex Float) where
+    cmap = mapVector
+    atIndex = (@>)
     minIndex     = minIndex . fst . fromComplex . (zipVectorWith (*) `ap` mapVector conjugate)
     maxIndex     = maxIndex . fst . fromComplex . (zipVectorWith (*) `ap` mapVector conjugate)
     minElement  = ap (@>) minIndex
     maxElement  = ap (@>) maxIndex
+    sumElements  = sumQ
+    prodElements = prodQ
 
 ---------------------------------------------------------------
-
-instance Vectors Vector Float where
-    vectorSum  = sumF
-    vectorProd = prodF
-    norm2      = toScalarF Norm2
-    absSum     = toScalarF AbsSum
-    dot        = dotF
-    norm1      = toScalarF AbsSum
-    normInf    = maxElement . vectorMapF Abs
-
-instance Vectors Vector Double where
-    vectorSum  = sumR
-    vectorProd = prodR
-    norm2      = toScalarR Norm2
-    absSum     = toScalarR AbsSum
-    dot        = dotR
-    norm1      = toScalarR AbsSum
-    normInf    = maxElement . vectorMapR Abs
-
-instance Vectors Vector (Complex Float) where
-    vectorSum  = sumQ
-    vectorProd = prodQ
-    norm2      = (:+ 0) . toScalarQ Norm2
-    absSum     = (:+ 0) . toScalarQ AbsSum
-    dot        = dotQ
-    norm1      = (:+ 0) . vectorSum . fst . fromComplex . vectorMapQ Abs
-    normInf    = (:+ 0) . maxElement . fst . fromComplex . vectorMapQ Abs
-
-instance Vectors Vector (Complex Double) where
-    vectorSum  = sumC
-    vectorProd = prodC
-    norm2      = (:+ 0) . toScalarC Norm2
-    absSum     = (:+ 0) . toScalarC AbsSum
-    dot        = dotC
-    norm1      = (:+ 0) . vectorSum . fst . fromComplex . vectorMapC Abs
-    normInf    = (:+ 0) . maxElement . fst . fromComplex . vectorMapC Abs
\ No newline at end of file