5 files changed, 41 insertions, 5 deletions

diff --git a/lib/Data/Packed/Internal/Matrix.hs b/lib/Data/Packed/Internal/Matrix.hs
index 003e8ee..7b3b305 100644
--- a/lib/Data/Packed/Internal/Matrix.hs
+++ b/lib/Data/Packed/Internal/Matrix.hs
@@ -257,6 +257,10 @@ class (Storable a, Floating a) => Element a where
     constantD  :: a -> Int -> Vector a
     constantD = constant'
 
+instance Element Float where
+    transdata  = transdataAux ctransF
+    constantD  = constantAux cconstantF
+
 instance Element Double where
     transdata  = transdataAux ctransR
     constantD  = constantAux cconstantR
@@ -308,6 +312,7 @@ transdataAux fun c1 d c2 =
         r2 = dim d `div` c2
         noneed = r1 == 1 || c1 == 1
 
+foreign import ccall "transF" ctransF :: TFMFM
 foreign import ccall "transR" ctransR :: TMM
 foreign import ccall "transC" ctransC :: TCMCM
 ----------------------------------------------------------------------
@@ -329,6 +334,10 @@ constantAux fun x n = unsafePerformIO $ do
     free px
     return v
 
+constantF :: Float -> Int -> Vector Float
+constantF = constantAux cconstantF
+foreign import ccall "constantF" cconstantF :: Ptr Float -> TF
+
 constantR :: Double -> Int -> Vector Double
 constantR = constantAux cconstantR
 foreign import ccall "constantR" cconstantR :: Ptr Double -> TV
@@ -368,15 +377,15 @@ subMatrix' (r0,c0) (rt,ct) m = trans $ subMatrix' (c0,r0) (ct,rt) (trans m)
 --------------------------------------------------------------------------
 
 -- | obtains the complex conjugate of a complex vector
-conjV :: Vector (Complex Double) -> Vector (Complex Double)
+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 :: (Vector Double, Vector Double) ->  Vector (Complex Double)
+toComplexV :: Element a => (Vector a, Vector a) ->  Vector (Complex a)
 toComplexV (r,i) = asComplex $ flatten $ fromColumns [r,i]
 
 -- | the inverse of 'toComplex'
-fromComplexV :: Vector (Complex Double) -> (Vector Double, Vector Double)
+fromComplexV :: Element a => Vector (Complex a) -> (Vector a, Vector a)
 fromComplexV z = (r,i) where
     [r,i] = toColumns $ reshape 2 $ asReal z
 
diff --git a/lib/Data/Packed/Internal/Signatures.hs b/lib/Data/Packed/Internal/Signatures.hs
index d3ce121..4d984e3 100644
--- a/lib/Data/Packed/Internal/Signatures.hs
+++ b/lib/Data/Packed/Internal/Signatures.hs
@@ -18,11 +18,17 @@ import Foreign
 import Data.Complex
 import Foreign.C.Types
 
+type PF = Ptr Float                             --
 type PD = Ptr Double                            --
 type PC = Ptr (Complex Double)                  --
+type TF = CInt -> PF -> IO CInt                 --
+type TFF = CInt -> PF -> TF                     --
+type TFFF = CInt -> PF -> TFF                   --
 type TV = CInt -> PD -> IO CInt                 --
 type TVV = CInt -> PD -> TV                     --
 type TVVV = CInt -> PD -> TVV                   --
+type TFM = CInt -> CInt -> PF -> IO CInt        --
+type TFMFM =  CInt -> CInt -> PF -> TFM         --
 type TM = CInt -> CInt -> PD -> IO CInt         --
 type TMM =  CInt -> CInt -> PD -> TM            --
 type TVMM = CInt -> PD -> TMM                   --
diff --git a/lib/Data/Packed/Internal/Vector.hs b/lib/Data/Packed/Internal/Vector.hs
index a6868d9..d97a86d 100644
--- a/lib/Data/Packed/Internal/Vector.hs
+++ b/lib/Data/Packed/Internal/Vector.hs
@@ -264,13 +264,13 @@ takesV ms w | sum ms > dim w = error $ "takesV " ++ show ms ++ " on dim = " ++ (
 ---------------------------------------------------------------
 
 -- | transforms a complex vector into a real vector with alternating real and imaginary parts 
-asReal :: Vector (Complex Double) -> Vector Double
+asReal :: Vector (Complex a) -> Vector a
 --asReal v = V { ioff = 2*ioff v, idim = 2*dim v, fptr =  castForeignPtr (fptr v) }
 asReal v = unsafeFromForeignPtr (castForeignPtr fp) (2*i) (2*n)
     where (fp,i,n) = unsafeToForeignPtr v
 
 -- | transforms a real vector into a complex vector with alternating real and imaginary parts
-asComplex :: Vector Double -> Vector (Complex Double)
+asComplex :: Vector a -> Vector (Complex a)
 --asComplex v = V { ioff = ioff v `div` 2, idim = dim v `div` 2, fptr =  castForeignPtr (fptr v) }
 asComplex v = unsafeFromForeignPtr (castForeignPtr fp) (i `div` 2) (n `div` 2)
     where (fp,i,n) = unsafeToForeignPtr v
diff --git a/lib/Data/Packed/Matrix.hs b/lib/Data/Packed/Matrix.hs
index 0c21b97..c6d8a90 100644
--- a/lib/Data/Packed/Matrix.hs
+++ b/lib/Data/Packed/Matrix.hs
@@ -455,6 +455,14 @@ class (Element e) => Container c e where
     real        :: c Double -> c e
     complex     :: c e -> c (Complex Double)
 
+instance Container Vector Float where
+    toComplex = toComplexV
+    fromComplex = fromComplexV
+    comp v = toComplex (v,constant 0 (dim v))
+    conj = conjV
+    real = mapVector realToFrac
+    complex = (mapVector (\(r :+ i) -> (realToFrac r :+ realToFrac i))) . comp
+
 instance Container Vector Double where
     toComplex = toComplexV
     fromComplex = fromComplexV
diff --git a/lib/Data/Packed/Vector.hs b/lib/Data/Packed/Vector.hs
index f6b3fc6..66aa71d 100644
--- a/lib/Data/Packed/Vector.hs
+++ b/lib/Data/Packed/Vector.hs
@@ -19,6 +19,7 @@ module Data.Packed.Vector (
     subVector, takesV, join,
     constant, linspace,
     vecdisp,
+    vectorFMax, vectorFMin, vectorFMaxIndex, vectorFMinIndex,
     vectorMax, vectorMin, vectorMaxIndex, vectorMinIndex,
     mapVector, zipVector,
     fscanfVector, fprintfVector, freadVector, fwriteVector,
@@ -63,6 +64,18 @@ linspace n (a,b) = add a $ scale s  $ fromList [0 .. fromIntegral n-1]
           add   = vectorMapValR AddConstant
           s = (b-a)/fromIntegral (n-1)
 
+vectorFMax :: Vector Float -> Float
+vectorFMax = toScalarF Max
+
+vectorFMin :: Vector Float -> Float
+vectorFMin = toScalarF Min
+
+vectorFMaxIndex :: Vector Float -> Int
+vectorFMaxIndex = round . toScalarF MaxIdx
+
+vectorFMinIndex :: Vector Float -> Int
+vectorFMinIndex = round . toScalarF MinIdx
+
 vectorMax :: Vector Double -> Double
 vectorMax = toScalarR Max