Yampa-core-0.2.0: tests/AFRPTestsPre.hs
{- $Id: AFRPTestsDelay.hs,v 1.2 2003/11/10 21:28:58 antony Exp $
******************************************************************************
* A F R P *
* *
* Module: AFRPTestsPre *
* Purpose: Test cases for pre and (derived) combinators *
* that (semantically) involves a pre. *
* Authors: Antony Courtney and Henrik Nilsson *
* *
* Copyright (c) Yale University, 2003 *
* Copyright (c) University of Nottingham, 2005 *
* *
******************************************************************************
-}
module AFRPTestsPre (pre_tr, pre_trs) where
import FRP.Yampa
import AFRPTestsCommon
------------------------------------------------------------------------------
-- Test cases for pre and related combinators
------------------------------------------------------------------------------
pre_t0 = testSF1 (iPre 17)
pre_t0r =
[17.0,0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,
15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0]
pre_t1 = testSF2 (iPre 17)
pre_t1r =
[17.0,0.0,0.0,0.0,0.0,0.0,1.0,1.0,1.0,1.0,1.0,2.0,2.0,2.0,2.0,2.0,
3.0,3.0,3.0,3.0,3.0,4.0,4.0,4.0,4.0]
pre_t2 = testSF1 (time
>>> arr (\t -> sin (0.5 * t * pi + pi))
>>> loop (arr (\(x1,x2) -> let x' = max x1 x2 in (x',x'))
>>> second (iPre 0.0)))
pre_t2r =
take 25
(let xs = [ sin (0.5 * t * pi + pi) | t <- [0.0, 0.25 ..] ]
in tail (scanl max 0 xs))
-- This is a (somewhat strange) way of doing a counter that
-- stops after reaching a threshold. Note that the ingoing event
-- is *control dependent* on the output of the counter, so
-- "dHold" really has to have the capability of delivering an
-- output without looking at the current input at all.
pre_t3, pre_t3r :: [Int]
pre_t3 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = repeatedly 1.0 ()
>>> (loop $
arr (\(e,c) -> (e `tag` (c + 1)) `gate` (c < 10))
>>> dHold 0
>>> arr dup)
pre_t3r = [0,0,0,0, -- 0s
0,1,1,1, -- 1s
1,2,2,2, -- 2s
2,3,3,3, -- 3s
3,4,4,4, -- 4s
4,5,5,5, -- 5s
5,6,6,6, -- 6s
6,7,7,7, -- 7s
7,8,8,8, -- 8s
8,9,9,9, -- 9s
9,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
-- Version of the above that tests that thigs still work OK also if
-- there is an initial event.
pre_t4, pre_t4r :: [Int]
pre_t4 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = (now () &&& repeatedly 1.0 ()) >>> arr (uncurry lMerge)
>>> (loop $
arr (\(e,c) -> (e `tag` (c + 1)) `gate` (c < 10))
>>> dHold 0
>>> arr dup)
pre_t4r = [0,1,1,1, -- 0s
1,2,2,2, -- 1s
2,3,3,3, -- 2s
3,4,4,4, -- 3s
4,5,5,5, -- 4s
5,6,6,6, -- 5s
6,7,7,7, -- 6s
7,8,8,8, -- 7s
8,9,9,9, -- 8s
9,10,10,10, -- 9s
10,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
-- Similar test to "pre_t3" above but for dAccumHold.
pre_t5, pre_t5r :: [Int]
pre_t5 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = repeatedly 1.0 ()
>>> (loop $
arr (\(e,c) -> (e `tag` (+1)) `gate` (c < 10))
>>> dAccumHold 0
>>> arr dup)
pre_t5r = [0,0,0,0, -- 0s
0,1,1,1, -- 1s
1,2,2,2, -- 2s
2,3,3,3, -- 3s
3,4,4,4, -- 4s
4,5,5,5, -- 5s
5,6,6,6, -- 6s
6,7,7,7, -- 7s
7,8,8,8, -- 8s
8,9,9,9, -- 9s
9,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
-- Similar test to "pre_t4" above but for dAccumHold.
pre_t6, pre_t6r :: [Int]
pre_t6 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = (now () &&& repeatedly 1.0 ()) >>> arr (uncurry lMerge)
>>> (loop $
arr (\(e,c) -> (e `tag` (+1)) `gate` (c < 10))
>>> dAccumHold 0
>>> arr dup)
pre_t6r = [0,1,1,1, -- 0s
1,2,2,2, -- 1s
2,3,3,3, -- 2s
3,4,4,4, -- 3s
4,5,5,5, -- 4s
5,6,6,6, -- 5s
6,7,7,7, -- 6s
7,8,8,8, -- 7s
8,9,9,9, -- 8s
9,10,10,10, -- 9s
10,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
-- Similar test to "pre_t3" above but for dAccumHoldBy.
pre_t7, pre_t7r :: [Int]
pre_t7 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = repeatedly 1.0 ()
>>> (loop $
arr (\(e,c) -> e `gate` (c < 10))
>>> dAccumHoldBy (\c _ -> c + 1) 0
>>> arr dup)
pre_t7r = [0,0,0,0, -- 0s
0,1,1,1, -- 1s
1,2,2,2, -- 2s
2,3,3,3, -- 3s
3,4,4,4, -- 4s
4,5,5,5, -- 5s
5,6,6,6, -- 6s
6,7,7,7, -- 7s
7,8,8,8, -- 8s
8,9,9,9, -- 9s
9,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
-- Similar test to "pre_t4" above but for dAccumHoldBy.
pre_t8, pre_t8r :: [Int]
pre_t8 = take 50 (embed sf (deltaEncode 0.25 (repeat ())))
where
sf = (now () &&& repeatedly 1.0 ()) >>> arr (uncurry lMerge)
>>> (loop $
arr (\(e,c) -> e `gate` (c < 10))
>>> dAccumHoldBy (\c _ -> c + 1) 0
>>> arr dup)
pre_t8r = [0,1,1,1, -- 0s
1,2,2,2, -- 1s
2,3,3,3, -- 2s
3,4,4,4, -- 3s
4,5,5,5, -- 4s
5,6,6,6, -- 5s
6,7,7,7, -- 6s
7,8,8,8, -- 7s
8,9,9,9, -- 8s
9,10,10,10, -- 9s
10,10,10,10, -- 10s
10,10,10,10, -- 11s
10,10] -- 12s
pre_trs =
[ pre_t0 ~= pre_t0r,
pre_t1 ~= pre_t1r,
pre_t2 ~= pre_t2r,
pre_t3 == pre_t3r,
pre_t4 == pre_t4r,
pre_t5 == pre_t5r,
pre_t6 == pre_t6r,
pre_t7 == pre_t7r,
pre_t8 == pre_t8r
]
pre_tr = and pre_trs