Repository : ssh://darcs.haskell.org//srv/darcs/packages/dph On branch : master
http://hackage.haskell.org/trac/ghc/changeset/2465b8b79dfad6db6b923f841f3e36af1dd7ed9c >--------------------------------------------------------------- commit 2465b8b79dfad6db6b923f841f3e36af1dd7ed9c Author: George Roldugin <[email protected]> Date: Sun May 8 19:26:17 2011 +1000 Updated old quickcheck tests. >--------------------------------------------------------------- examples/quickcheck/tests/Unlifted_Basics.hs | 52 ++++++++++++++++ examples/quickcheck/tests/Unlifted_Combinators.hs | 63 ++++++++++++++++++++ examples/quickcheck/tests/Unlifted_Subarrays.hs | 23 +++++++ examples/quickcheck/tests/Unlifted_Sums.hs | 65 +++++++++++++++++++++ 4 files changed, 203 insertions(+), 0 deletions(-) diff --git a/examples/quickcheck/tests/Unlifted_Basics.hs b/examples/quickcheck/tests/Unlifted_Basics.hs new file mode 100644 index 0000000..756569b --- /dev/null +++ b/examples/quickcheck/tests/Unlifted_Basics.hs @@ -0,0 +1,52 @@ +import Testsuite + +import Data.Array.Parallel.Unlifted as U +import Prelude as P + +$(testcases [ "" <@ [t| ( Bool, Int ) |] + , "acc" <@ [t| ( Int ) |] + , "num" <@ [t| ( Int ) |] + , "ord" <@ [t| ( Bool, Int ) |] + , "enum" <@ [t| ( Bool, Int ) |] + ] + [d| + -- if this doesn't work nothing else will, so run this first + prop_toList_fromList :: (Eq a, Elt a) => [a] -> Bool + prop_toList_fromList xs = toList (fromList xs) == xs + + prop_length :: Elt a => Array a -> Bool + prop_length arr = U.length arr == P.length (toList arr) + + --prop_nullU :: UA a => UArr a -> Bool + --prop_nullU arr = nullU arr == (lengthU arr == 0) + + prop_empty :: (Eq a, Elt a) => a -> Bool + prop_empty x = toList empty == tail [x] + + --prop_unitsU :: Len -> Bool + --prop_unitsU (Len n) = + -- toList (unitsU n) == replicate n () + + prop_replicate :: (Eq a, Elt a) => Len -> a -> Bool + prop_replicate (Len n) x = + toList (U.replicate n x) == P.replicate n x + + prop_index :: (Eq a, Elt a) => Array a -> Len -> Property + prop_index arr (Len i) = + i < U.length arr + ==> (arr !: i) == (toList arr !! i) + + prop_append :: (Eq a, Elt a) => Array a -> Array a -> Bool + prop_append arr brr = + toList (arr +:+ brr) == toList arr ++ toList brr + + -- Equality + -- -------- + + prop_eqU_1 :: (Eq a, Elt a) => Array a -> Bool + prop_eqU_1 arr = arr == arr + + prop_eqU_2 :: (Eq a, Elt a) => Array a -> Array a -> Bool + prop_eqU_2 arr brr = (arr == brr) == (toList arr == toList brr) + |]) + diff --git a/examples/quickcheck/tests/Unlifted_Combinators.hs b/examples/quickcheck/tests/Unlifted_Combinators.hs new file mode 100644 index 0000000..124c34d --- /dev/null +++ b/examples/quickcheck/tests/Unlifted_Combinators.hs @@ -0,0 +1,63 @@ +import Testsuite + +import Data.Array.Parallel.Unlifted as U +import Prelude as P + +$(testcases [ "" <@ [t| ( Bool, Int ) |] + , "acc" <@ [t| ( Int ) |] + , "num" <@ [t| ( Int ) |] + , "ord" <@ [t| ( Bool, Int ) |] + , "enum" <@ [t| ( Bool, Int ) |] + ] + [d| + prop_map :: (Elt a, Eq b, Elt b) => (a -> b) -> Array a -> Bool + prop_map f arr = + toList (U.map f arr) == P.map f (toList arr) + + prop_filter :: (Eq a, Elt a) => (a -> Bool) -> Array a -> Bool + prop_filter pred arr = + toList (U.filter pred arr) == P.filter pred (toList arr) + + prop_pack :: (Eq a, Elt a) => Array a -> Array Bool -> Bool + prop_pack arr flags = + toList (U.pack arr flags) == [x | (x,flag) <- P.zip arr' flags', flag] + where arr' = toList arr + flags' = toList flags + + prop_combine :: (Eq a, Elt a) => Array Bool -> Array a -> Array a -> Property + prop_combine sel arr brr = + (count sel True <= U.length arr && count sel False <= U.length brr) + ==> toList (combine sel arr brr) == combine' (toList sel) (toList arr) (toList brr) + where + -- combine' :: [Bool] -> [a] -> [a] -> [a] + combine' [] [] [] = [] + combine' (True : ss) (x : xs) ys = x : combine' ss xs ys + combine' (False : ss) xs (y : ys) = y : combine' ss xs ys + combine' _ _ _ = [] + + -- missing: combine2 + + prop_zipWith :: (Elt a, Elt b, Eq c, Elt c) => (a -> b -> c) -> Array a -> Array b -> Bool + prop_zipWith f arr brr = + toList (U.zipWith f arr brr) == P.zipWith f (toList arr) (toList brr) + + prop_zipWith3 :: (Elt a, Elt b, Elt c, Eq d, Elt d) + => (a -> b -> c -> d) -> Array a -> Array b -> Array c -> Bool + prop_zipWith3 f arr brr crr = + toList (U.zipWith3 f arr brr crr) == P.zipWith3 f (toList arr) (toList brr) (toList crr) + + prop_fold :: (Elt a, Eq a) => (a -> a -> a) -> a -> Array a -> Bool + prop_fold f z arr = + U.fold f z arr == P.foldl f z (toList arr) + + prop_fold1 :: (Elt a, Eq a) => (a -> a -> a) -> Array a -> Property + prop_fold1 f arr = + not (null $ toList arr) + ==> U.fold1 f arr == P.foldl1 f (toList arr) + + prop_scan :: (Elt a, Eq a) => (a -> a -> a) -> a -> Array a -> Bool + prop_scan f z arr = + toList (U.scan f z arr) == P.init (P.scanl f z (toList arr)) + + |]) + diff --git a/examples/quickcheck/tests/Unlifted_Subarrays.hs b/examples/quickcheck/tests/Unlifted_Subarrays.hs new file mode 100644 index 0000000..51c3f83 --- /dev/null +++ b/examples/quickcheck/tests/Unlifted_Subarrays.hs @@ -0,0 +1,23 @@ +import Testsuite + +import Data.Array.Parallel.Unlifted as U +import Prelude as P + +$(testcases [ "" <@ [t| ( Bool, Int ) |] + , "acc" <@ [t| ( Int ) |] + , "num" <@ [t| ( Int ) |] + , "ord" <@ [t| ( Bool, Int ) |] + , "enum" <@ [t| ( Bool, Int ) |] + ] + [d| + prop_extract :: (Eq a, Elt a) => Array a -> Len -> Len -> Property + prop_extract arr (Len i) (Len n) = + i <= U.length arr && n <= U.length arr - i + ==> toList (U.extract arr i n) == take n (P.drop i $ toList arr) + + prop_drop :: (Eq a, Elt a) => Len -> Array a -> Property + prop_drop (Len n) arr = + n <= U.length arr + ==> toList (U.drop n arr) == P.drop n (toList arr) + |]) + diff --git a/examples/quickcheck/tests/Unlifted_Sums.hs b/examples/quickcheck/tests/Unlifted_Sums.hs new file mode 100644 index 0000000..9cf2115 --- /dev/null +++ b/examples/quickcheck/tests/Unlifted_Sums.hs @@ -0,0 +1,65 @@ +import Testsuite + +import Data.Array.Parallel.Unlifted as U +import Prelude as P + +$(testcases [ "" <@ [t| ( Bool, Int ) |] + , "acc" <@ [t| ( Int ) |] + , "num" <@ [t| ( Int ) |] + , "ord" <@ [t| ( Bool, Int ) |] + , "enum" <@ [t| ( Bool, Int ) |] + ] + [d| + -- Searching + -- --------- +{- + prop_elem :: (Eq e, Elt e) => e -> Array e -> Bool + prop_elem x arr = + U.elem x arr == P.elem x (toList arr) + + prop_notElemU :: (Eq e, Elt e) => e -> Array e -> Bool + prop_notElemU x arr = + notElemU x arr == notElem x (toList arr) +-} + -- Logic operations + -- ---------------- + + prop_and :: Array Bool -> Bool + prop_and arr = + U.and arr == P.and (toList arr) +{- + prop_orU :: Array Bool -> Bool + prop_orU arr = + orU arr == or (toList arr) + + prop_anyU :: Elt e => (e -> Bool) -> Array e -> Bool + prop_anyU f arr = + anyU f arr == any f (toList arr) + + prop_allU :: Elt e => (e -> Bool) -> Array e -> Bool + prop_allU f arr = + allU f arr == all f (toList arr) +-} + -- Arithmetic operations + -- --------------------- + + prop_sum :: (Eq num, Elt num, Num num) => Array num -> Bool + prop_sum arr = + U.sum arr == P.sum (toList arr) +{- + prop_productU :: (Eq num, Elt num, Num num) => Array num -> Bool + prop_productU arr = + productU arr == product (toList arr) + + prop_maximumU :: (Ord ord, Elt ord) => Array ord -> Property + prop_maximumU arr = + not (nullU arr) + ==> maximumU arr == maximum (toList arr) + + prop_minimumU :: (Ord ord, Elt ord) => Array ord -> Property + prop_minimumU arr = + not (nullU arr) + ==> minimumU arr == minimum (toList arr) +-} + |]) + _______________________________________________ Cvs-libraries mailing list [email protected] http://www.haskell.org/mailman/listinfo/cvs-libraries
