Adapt tests to new names and modules
[darcs-mirrors/vector.git] / tests / Utilities.hs
index d7ca44f..e0129f2 100644 (file)
@@ -6,13 +6,15 @@ import Test.QuickCheck
 import qualified Data.Vector as DV
 import qualified Data.Vector.Generic as DVG
 import qualified Data.Vector.Primitive as DVP
-import qualified Data.Vector.Fusion.Stream as S
+import qualified Data.Vector.Storable as DVS
+import qualified Data.Vector.Unboxed as DVU
+import qualified Data.Vector.Fusion.Bundle as S
 
 import Data.List ( sortBy )
 
 
-instance Show a => Show (S.Stream a) where
-    show s = "Data.Vector.Fusion.Stream.fromList " ++ show (S.toList s)
+instance Show a => Show (S.Bundle v a) where
+    show s = "Data.Vector.Fusion.Bundle.fromList " ++ show (S.toList s)
 
 
 instance Arbitrary a => Arbitrary (DV.Vector a) where
@@ -27,10 +29,22 @@ instance (Arbitrary a, DVP.Prim a) => Arbitrary (DVP.Vector a) where
 instance (CoArbitrary a, DVP.Prim a) => CoArbitrary (DVP.Vector a) where
     coarbitrary = coarbitrary . DVP.toList
 
-instance Arbitrary a => Arbitrary (S.Stream a) where
+instance (Arbitrary a, DVS.Storable a) => Arbitrary (DVS.Vector a) where
+    arbitrary = fmap DVS.fromList arbitrary
+
+instance (CoArbitrary a, DVS.Storable a) => CoArbitrary (DVS.Vector a) where
+    coarbitrary = coarbitrary . DVS.toList
+
+instance (Arbitrary a, DVU.Unbox a) => Arbitrary (DVU.Vector a) where
+    arbitrary = fmap DVU.fromList arbitrary
+
+instance (CoArbitrary a, DVU.Unbox a) => CoArbitrary (DVU.Vector a) where
+    coarbitrary = coarbitrary . DVU.toList
+
+instance Arbitrary a => Arbitrary (S.Bundle v a) where
     arbitrary = fmap S.fromList arbitrary
 
-instance CoArbitrary a => CoArbitrary (S.Stream a) where
+instance CoArbitrary a => CoArbitrary (S.Bundle v a) where
     coarbitrary = coarbitrary . S.toList
 
 class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
@@ -41,12 +55,12 @@ class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
   type EqTest a
   equal :: a -> a -> EqTest a
 
-instance Eq a => TestData (S.Stream a) where
-  type Model (S.Stream a) = [a]
+instance Eq a => TestData (S.Bundle v a) where
+  type Model (S.Bundle v a) = [a]
   model = S.toList
   unmodel = S.fromList
 
-  type EqTest (S.Stream a) = Property
+  type EqTest (S.Bundle v a) = Property
   equal x y = property (x == y)
 
 instance Eq a => TestData (DV.Vector a) where
@@ -65,6 +79,22 @@ instance (Eq a, DVP.Prim a) => TestData (DVP.Vector a) where
   type EqTest (DVP.Vector a) = Property
   equal x y = property (x == y)
 
+instance (Eq a, DVS.Storable a) => TestData (DVS.Vector a) where
+  type Model (DVS.Vector a) = [a]
+  model = DVS.toList
+  unmodel = DVS.fromList
+
+  type EqTest (DVS.Vector a) = Property
+  equal x y = property (x == y)
+
+instance (Eq a, DVU.Unbox a) => TestData (DVU.Vector a) where
+  type Model (DVU.Vector a) = [a]
+  model = DVU.toList
+  unmodel = DVU.fromList
+
+  type EqTest (DVU.Vector a) = Property
+  equal x y = property (x == y)
+
 #define id_TestData(ty) \
 instance TestData ty where { \
   type Model ty = ty;        \
@@ -74,6 +104,7 @@ instance TestData ty where { \
   type EqTest ty = Property; \
   equal x y = property (x == y) }
 
+id_TestData(())
 id_TestData(Bool)
 id_TestData(Int)
 id_TestData(Float)
@@ -174,10 +205,13 @@ indices m = sized $ \n ->
 -- Additional list functions
 singleton x = [x]
 snoc xs x = xs ++ [x]
-slice xs i n = take n (drop i xs)
+generate n f = [f i | i <- [0 .. n-1]]
+slice i n xs = take n (drop i xs)
 backpermute xs is = map (xs!!) is
 prescanl f z = init . scanl f z
 postscanl f z = tail . scanl f z
+prescanr f z = tail . scanr f z
+postscanr f z = init . scanr f z
 
 accum :: (a -> b -> a) -> [a] -> [(Int,b)] -> [a]
 accum f xs ps = go xs ps' 0
@@ -199,3 +233,33 @@ xs // ps = go xs ps' 0
     go (x:xs) ps j = x : go xs ps (j+1)
     go [] _ _      = []
 
+imap :: (Int -> a -> a) -> [a] -> [a]
+imap f = map (uncurry f) . zip [0..]
+
+izipWith :: (Int -> a -> a -> a) -> [a] -> [a] -> [a]
+izipWith f = zipWith (uncurry f) . zip [0..]
+
+izipWith3 :: (Int -> a -> a -> a -> a) -> [a] -> [a] -> [a] -> [a]
+izipWith3 f = zipWith3 (uncurry f) . zip [0..]
+
+ifilter :: (Int -> a -> Bool) -> [a] -> [a]
+ifilter f = map snd . filter (uncurry f) . zip [0..]
+
+ifoldl :: (a -> Int -> a -> a) -> a -> [a] -> a
+ifoldl f z = foldl (uncurry . f) z . zip [0..]
+
+ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b
+ifoldr f z = foldr (uncurry f) z . zip [0..]
+
+minIndex :: Ord a => [a] -> Int
+minIndex = fst . foldr1 imin . zip [0..]
+  where
+    imin (i,x) (j,y) | x <= y    = (i,x)
+                     | otherwise = (j,y)
+
+maxIndex :: Ord a => [a] -> Int
+maxIndex = fst . foldr1 imax . zip [0..]
+  where
+    imax (i,x) (j,y) | x >= y    = (i,x)
+                     | otherwise = (j,y)
+