1 files changed, 19 insertions, 122 deletions

diff --git a/lib/Numeric/Vector.hs b/lib/Numeric/Vector.hs
index 55d645a..9427243 100644
--- a/lib/Numeric/Vector.hs
+++ b/lib/Numeric/Vector.hs
@@ -14,24 +14,26 @@
 -- Stability   :  provisional
 -- Portability :  portable
 --
--- Numeric instances and functions for 'Data.Packed.Vector's
+-- Numeric instances and functions for 'Vector'.
 --
 -----------------------------------------------------------------------------
 
 module Numeric.Vector (
-                       -- * Vector creation
-                       constant, linspace,
-                       module Data.Packed.Vector
+    -- * Basic vector functions
+    module Data.Packed.Vector,
+    module Numeric.Container,
+    -- * Vector creation
+    constant, linspace,
+    -- * Operators
+    (<.>)
                       ) where
 
 import Data.Complex
 
-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 Data.Packed.Internal.Matrix
+--import Data.Packed.Internal.Vector(asComplex,asReal)
+--import Data.Packed.Matrix(toColumns,fromColumns,flatten,reshape)
 import Numeric.GSL.Vector
 
 import Numeric.Container
@@ -92,10 +94,15 @@ Logarithmic spacing can be defined as follows:
 
 @logspace n (a,b) = 10 ** linspace n (a,b)@
 -}
-linspace :: (Enum e, Linear Vector e) => Int -> (e, e) -> Vector e
+linspace :: (Enum e, Container Vector e) => Int -> (e, e) -> Vector e
 linspace n (a,b) = addConstant a $ scale s $ fromList [0 .. fromIntegral n-1]
     where s = (b-a)/fromIntegral (n-1)
 
+-- | Dot product: @u \<.\> v = dot u v@
+(<.>) :: Vectors Vector t => Vector t -> Vector t -> t
+infixl 7 <.>
+(<.>) = dot
+
 ------------------------------------------------------------------
 
 adaptScalar f1 f2 f3 x y
@@ -107,7 +114,7 @@ adaptScalar f1 f2 f3 x y
 
 #ifndef VECTOR
 
-instance Linear Vector a => Eq (Vector a) where
+instance Container Vector a => Eq (Vector a) where
     (==) = equal
 
 #endif
@@ -146,7 +153,7 @@ instance Num (Vector (Complex Float)) where
 
 ---------------------------------------------------
 
-instance (Linear Vector a, Num (Vector a)) => Fractional (Vector a) where
+instance (Container Vector a, Num (Vector a)) => Fractional (Vector a) where
     fromRational n = fromList [fromRational n]
     (/) = adaptScalar f divide g where
         r `f` v = scaleRecip r v
@@ -254,116 +261,6 @@ instance Floating (Vector (Complex Float)) where
 -- instance (NFData a, Element a) => NFData (Matrix a) where
 --     rnf = rnf . flatten
 
----------------------------------------------------------------
-
--- | 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 Linear Vector Float where
-    scale = vectorMapValF Scale
-    scaleRecip = vectorMapValF Recip
-    addConstant = vectorMapValF AddConstant
-    add = vectorZipF Add
-    sub = vectorZipF Sub
-    mul = vectorZipF Mul
-    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
-    scaleRecip = vectorMapValR Recip
-    addConstant = vectorMapValR AddConstant
-    add = vectorZipR Add
-    sub = vectorZipR Sub
-    mul = vectorZipR Mul
-    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
-    scaleRecip = vectorMapValC Recip
-    addConstant = vectorMapValC AddConstant
-    add = vectorZipC Add
-    sub = vectorZipC Sub
-    mul = vectorZipC Mul
-    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
-    scaleRecip = vectorMapValQ Recip
-    addConstant = vectorMapValQ AddConstant
-    add = vectorZipQ Add
-    sub = vectorZipQ Sub
-    mul = vectorZipQ Mul
-    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
-
----------------------------------------------------------------