content: -- |
  -- Description : Test cases for SFs with loops
  -- Copyright   : (c) Antony Courtney and Henrik Nilsson, Yale University, 2003-2004
  -- Authors     : Antony Courtney, Henrik Nilsson
  module Test.FRP.Yampa.Loop
      ( tests
      )
    where
  
  import Test.QuickCheck
  import Test.Tasty (TestTree, testGroup)
  import Test.Tasty.QuickCheck (testProperty)
  
  import FRP.Yampa as Yampa
  
  import TestsCommon
  
  tests :: TestTree
  tests = testGroup "Regression tests for FRP.Yampa.Loop"
    [ testProperty "loopPre (0, fixed)"      (property $ loopPre_t0 ~= loopPre_t0r)
    , testProperty "loopPre (1, fixed)"      (property $ loopPre_t1 ~= loopPre_t1r)
    , testProperty "loopPre (2, fixed)"      (property $ loopPre_t2 ~= loopPre_t2r)
    , testProperty "loopPre (3, fixed)"      (property $ loopPre_t3 ~= loopPre_t3r)
    , testProperty "loopPre (4, fixed)"      (property $ loopPre_t4 ~= loopPre_t4r)
    , testProperty "loopIntegral (0, fixed)" (property $ loopIntegral_t0 ~= loopIntegral_t0r)
    , testProperty "loopIntegral (1, fixed)" (property $ loopIntegral_t1 ~= loopIntegral_t1r)
    ]
  
  -- * Loops with guaranteed well-defined feedback
  
  loop_acc :: SF (Double, Double) (Double, Double)
  loop_acc = arr (\(x, y)->(x+y, x+y))
  
  -- This kind of test will fail for infinitesimal delay!
  loopPre_t0 = testSF1 (loopPre 0 loop_acc)
  loopPre_t0r =
    [ 0.0,1.0,3.0,6.0,10.0,15.0,21.0,28.0,36.0,45.0,55.0,66.0,78.0,91.0
    , 105.0,120.0,136.0,153.0,171.0,190.0,210.0,231.0,253.0,276.0,300.0
    ]
  
  loopPre_t1 = testSF2 (loopPre 0 loop_acc)
  loopPre_t1r =
    [ 0.0,0.0,0.0,0.0,0.0,1.0,2.0,3.0,4.0,5.0,7.0,9.0,11.0,13.0,15.0,18.0
    , 21.0,24.0,27.0,30.0,34.0,38.0,42.0,46.0,50.0
    ]
  
  -- This kind of test will fail for infinitesimal delay!
  loopPre_t2 = testSF1 (loopPre False (arr (dup . not . snd)))
  loopPre_t2r =
    [ True,False,True,False,True,False,True,False,True,False,True,False
    , True,False,True,False,True,False,True,False,True,False,True,False,True
    ]
  
  loopPre_t3 = testSF1 (loopPre 0 (first localTime))
  loopPre_t3r =
    [ 0.0,0.25,0.5,0.75,1.0,1.25,1.5,1.75,2.0,2.25,2.5,2.75,3.0,3.25,3.5,3.75
    , 4.0,4.25,4.5,4.75,5.0,5.25,5.5,5.75,6.0
    ]
  
  loopPre_t4 = testSF1 (loopPre 0 (first localTime >>> loop_acc))
  loopPre_t4r =
    [ 0.0,0.25,0.75,1.5,2.5,3.75,5.25,7.0,9.0,11.25,13.75,16.5,19.5,22.75
    , 26.25,30.0,34.0,38.25,42.75,47.5,52.5,57.75,63.25,69.0,75.0
    ]
  
  -- Computation of approximation to exp 0, exp 1, ..., exp 5 by integration.
  -- Values as given by using exp directly:
  -- 1.0, 2.71828, 7.38906, 20.0855, 54.5981, 148.413
  loopIntegral_t0 =
    let es = embed (loopIntegral (arr (\(_, x) -> (x + 1, x + 1))))
                   (deltaEncode 0.001 (repeat ()))
    in [es!!0, es!!1000, es!!2000, es!!3000, es!!4000, es!!5000]
  loopIntegral_t0r :: [Double]
  loopIntegral_t0r = [1.0,2.71692,7.38167,20.05544,54.48911,148.04276]
  
  -- Test case with a time varying signal transformer inside the loop.
  -- Starting at position 0 [m], accelerate by 1.0 [m/s^2] until position
  -- exceeds 2.0 [m]. Then accelerate by -1.0 [m/s^2] until position gets
  -- below 0.0 [m]. Then accelerate at 1.0 [m/s^2] again. And so on.
  
  type Position = Double
  type Velocity = Double
  type Acceleration = Double
  
  posCntrl :: SF b Position
  posCntrl = loopIntegral posCntrlNR
    where
      posCntrlNR :: SF (b, Velocity) (Position, Acceleration)
      posCntrlNR =
        arr snd                     -- Get the velocity.
        >>> integral                -- This integral gives us the position.
        >>> arr (\x -> (x,x))
        >>>
            (second $
               arr (\x -> (x,x))
               >>>
                   (first $
                      arr (>=2.0)
                      >>> edge
                      >>> (arr (fmap (const (constant (-1.0))))))
               >>>
                   (second $
                      arr (< 0.0)
                      >>> edge
                      >>> (arr (fmap (const (constant 1.0)))))
               >>> arr (\(e1,e2) -> e1 `lMerge` e2)
               >>> arr (\e -> ((), e))
               >>> rSwitch (constant 1.0))
  
  loopIntegral_t1 = take 250 (embed posCntrl (deltaEncode 0.1 (repeat ())))
  
  -- Result only partially verified. But the sign of the acceleration changes
  -- at roughly the right points.
  loopIntegral_t1r :: [Double]
  loopIntegral_t1r =
    [ 0.0,0.0,0.01,0.03,0.06,0.1,0.15,0.21,0.28,0.36,0.45,0.55,0.66,0.78,0.91
    , 1.05,1.2,1.36,1.53,1.71,1.9,2.1,2.31,2.51,2.7,2.88,3.05,3.21,3.36,3.5
    , 3.63,3.75,3.86,3.96,4.05,4.13,4.2,4.26,4.31,4.35,4.38,4.4,4.41,4.41,4.4
    , 4.38,4.35,4.31,4.26,4.2,4.13,4.05,3.96,3.86,3.75,3.63,3.5,3.36,3.21,3.05
    , 2.88,2.7,2.51,2.31,2.1,1.88,1.65,1.41,1.16,0.9,0.63,0.35,0.06,-0.24
    , -0.55,-0.85,-1.14,-1.42,-1.69,-1.95,-2.2,-2.44,-2.67,-2.89,-3.1,-3.3
    , -3.49,-3.67,-3.84,-4.0,-4.15,-4.29,-4.42,-4.54,-4.65,-4.75,-4.84,-4.92
    , -4.99,-5.05,-5.1,-5.14,-5.17,-5.19,-5.2,-5.2,-5.19,-5.17,-5.14,-5.1
    , -5.05,-4.99,-4.92,-4.84,-4.75,-4.65,-4.54,-4.42,-4.29,-4.15,-4.0,-3.84
    , -3.67,-3.49,-3.3,-3.1,-2.89,-2.67,-2.44,-2.2,-1.95,-1.69,-1.42,-1.14
    , -0.85,-0.55,-0.24,0.08,0.41,0.75,1.1,1.46,1.83,2.21,2.6,2.98,3.35,3.71
    , 4.06,4.4,4.73,5.05,5.36,5.66,5.95,6.23,6.5,6.76,7.01,7.25,7.48,7.7,7.91
    , 8.11,8.3,8.48,8.65,8.81,8.96,9.1,9.23,9.35,9.46,9.56,9.65,9.73,9.8,9.86
    , 9.91,9.95,9.98,10.0,10.01,10.01,10.0,9.98,9.95,9.91,9.86,9.8,9.73,9.65
    , 9.56,9.46,9.35,9.23,9.1,8.96,8.81,8.65,8.48,8.3,8.11,7.91,7.7,7.48,7.25
    , 7.01,6.76,6.5,6.23,5.95,5.66,5.36,5.05,4.73,4.4,4.06,3.71,3.35,2.98,2.6
    , 2.21,1.81,1.4,0.98,0.55,0.11,-0.34,-0.80,-1.25,-1.69,-2.12,-2.54,-2.95
    , -3.35,-3.74,-4.12,-4.49,-4.85,-5.2,-5.54,-5.87,-6.19,-6.5,-6.8,-7.09
    , -7.37,-7.64,-7.9
    ]
  