4 files changed, 37 insertions, 16 deletions

diff --git a/examples/benchmarks.hs b/examples/benchmarks.hs
index bffa221..f5ca550 100644
--- a/examples/benchmarks.hs
+++ b/examples/benchmarks.hs
@@ -46,6 +46,16 @@ bench1 = do
     time $ print $ constant (1::Double) 5000001 @> 7
     time $ print $ constant           i 5000001 @> 7
     time $ print $ conj (constant i 5000001) @> 7
+    putStrLn "some zips:"
+    time $ print $ (w / w2) @> 7
+    time $ print $ (zipVector (/) w w2) @> 7
+    putStrLn "some folds:"
+    let t = constant (1::Double) 5000002
+    print $ t @> 7
+    time $ print $ foldVector max (t@>0) t
+    time $ print $ vectorMax t
+    time $ print $ sqrt $ foldVector (\v s -> v*v+s) 0 t
+    time $ print $ pnorm PNorm2 t
 
 sumVH v = go (d - 1) 0
      where
@@ -56,7 +66,7 @@ sumVH v = go (d - 1) 0
 
 innerH u v = go (d - 1) 0
      where
-       d = dim u
+       d = min (dim u) (dim v)
        go :: Int -> Double -> Double
        go 0 s = s + (u @> 0) * (v @> 0)
        go !j !s = go (j - 1) (s + (u @> j) * (v @> j))
diff --git a/lib/Data/Packed/Internal/Vector.hs b/lib/Data/Packed/Internal/Vector.hs
index dd9b9b6..d410c4d 100644
--- a/lib/Data/Packed/Internal/Vector.hs
+++ b/lib/Data/Packed/Internal/Vector.hs
@@ -180,13 +180,9 @@ asComplex v = V { dim = dim v `div` 2, fptr =  castForeignPtr (fptr v) }
 
 ----------------------------------------------------------------
 
--- | map on Vectors
-liftVector :: (Storable a, Storable b) => (a-> b) -> Vector a -> Vector b
-liftVector = mapVector
+liftVector f x = mapVector f x
 
--- | zipWith for Vectors
-liftVector2 :: (Storable a, Storable b, Storable c) => (a-> b -> c) -> Vector a -> Vector b -> Vector c
-liftVector2 f u v = fromList $ zipWith f (toList u) (toList v)
+liftVector2 f u v = zipVector f u v
 
 -----------------------------------------------------------------
 
@@ -199,6 +195,8 @@ cloneVector (v@V {dim=n}) = do
 
 ------------------------------------------------------------------
 
+-- | map on Vectors
+mapVector :: (Storable a, Storable b) => (a-> b) -> Vector a -> Vector b
 mapVector f v = unsafePerformIO $ do
     w <- createVector (dim v)
     withForeignPtr (fptr v) $ \p ->
@@ -211,6 +209,23 @@ mapVector f v = unsafePerformIO $ do
     return w
 {-# INLINE mapVector #-}
 
+-- | zipWith for Vectors
+zipVector :: (Storable a, Storable b, Storable c) => (a-> b -> c) -> Vector a -> Vector b -> Vector c
+zipVector f u v = unsafePerformIO $ do
+    let n = min (dim u) (dim v)
+    w <- createVector n
+    withForeignPtr (fptr u) $ \pu ->
+        withForeignPtr (fptr v) $ \pv ->
+            withForeignPtr (fptr w) $ \pw -> do
+                let go (-1) = return ()
+                    go !k = do x <- peekElemOff pu k
+                               y <- peekElemOff pv k
+                               pokeElemOff      pw k (f x y)
+                               go (k-1)
+                go (n -1)
+    return w
+{-# INLINE zipVector #-}
+
 foldVector f x v = unsafePerformIO $
     withForeignPtr (fptr (v::Vector Double)) $ \p -> do
         let go (-1) s = return s
diff --git a/lib/Data/Packed/Vector.hs b/lib/Data/Packed/Vector.hs
index b85f0bd..e53d455 100644
--- a/lib/Data/Packed/Vector.hs
+++ b/lib/Data/Packed/Vector.hs
@@ -20,7 +20,7 @@ module Data.Packed.Vector (
     constant, linspace,
     vectorMax, vectorMin, vectorMaxIndex, vectorMinIndex,
     liftVector, liftVector2,
-    foldLoop, foldVector, foldVectorG, mapVector
+    foldLoop, foldVector, foldVectorG, mapVector, zipVector
 ) where
 
 import Data.Packed.Internal
diff --git a/lib/Graphics/Plot.hs b/lib/Graphics/Plot.hs
index bcb1fb3..9b64a1d 100644
--- a/lib/Graphics/Plot.hs
+++ b/lib/Graphics/Plot.hs
@@ -1,7 +1,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Graphics.Plot
--- Copyright   :  (c) Alberto Ruiz 2005
+-- Copyright   :  (c) Alberto Ruiz 2005-8
 -- License     :  GPL-style
 -- 
 -- Maintainer  :  Alberto Ruiz (aruiz at um dot es)
@@ -28,14 +28,10 @@ module Graphics.Plot(
 
 ) where
 
-import Data.Packed.Vector
-import Data.Packed.Matrix
+import Data.Packed
 import Numeric.LinearAlgebra(outer)
-import Numeric.GSL.Vector(FunCodeS(Max,Min),toScalarR)
 import Data.List(intersperse)
 import System
-import Foreign hiding (rotate)
-
 
 size = dim
 
@@ -154,8 +150,8 @@ matrixToPGM m = header ++ unlines (map unwords ll) where
     r = rows m
     header = "P2 "++show c++" "++show r++" "++show (round maxgray :: Int)++"\n"
     maxgray = 255.0
-    maxval = toScalarR Max $ flatten $ m
-    minval = toScalarR Min $ flatten $ m
+    maxval = vectorMax $ flatten $ m
+    minval = vectorMin $ flatten $ m
     scale = if (maxval == minval) 
         then 0.0
         else maxgray / (maxval - minval)