/* 

  Comparison of higher order functions in Picat v2 and v3.

  * Timing on map/2 (go..go4)

  $ time picat3 -g go map_bench.pi
  picat3 map_bench.pi  1,61s user 0,08s system 99% cpu 1,685 total

  $ time picat2 -g go map_bench.pi
  picat2 map_bench.pi  2,98s user 0,10s system 99% cpu 3,081 total

  $ time picat3 -g go2 map_bench.pi
  picat -g go2 map_bench.pi  15,82s user 0,98s system 99% cpu 16,804 total

  $ time picat2 -g go2 map_bench.pi
  picat2 -g go2 map_bench.pi  30,48s user 0,96s system 99% cpu 31,436 total

  $ time picat3 -g go3 map_bench.pi
  picat3 -g go3 map_bench.pi  1,50s user 0,10s system 99% cpu 1,597 total

  $ time picat2 -g go3 map_bench.pi
  picat2 -g go3 map_bench.pi  2,93s user 0,10s system 99% cpu 3,038 total

  $ time picat3 -g go4 map_bench.pi
  picat3 -g go4 map_bench.pi  14,84s user 1,12s system 99% cpu 15,958 total

  $ time picat2 -g go4 map_bench.pi
  picat2 -g go4 map_bench.pi  29,78s user 0,96s system 99% cpu 30,735 total

  I.e. Picat v3 is faster on map/2 by a factor about 2.


  * Timing on apply/2 (go5..go6)

  $ time picat3 -g go5 map_bench.pi
  picat3 -g go5 map_bench.pi  1,25s user 0,05s system 99% cpu 1,307 total

  $ time picat2 -g go5 map_bench.pi
  picat2 -g go5 map_bench.pi  2,81s user 0,06s system 99% cpu 2,874 total

  $ time picat3 -g go6 map_bench.pi
  picat3 -g go6 map_bench.pi  12,80s user 0,94s system 99% cpu 13,737 total

  $ time picat2 -g go6 map_bench.pi
  picat2 -g go6 map_bench.pi  27,87s user 0,84s system 99% cpu 28,706 total

  Same: Picat3 is faster on apply/2 by about 2.

  * Timing on call/2 (go7..go8)

  $ time picat3 -g go7 map_bench.pi
  picat3 -g go7 map_bench.pi  1,33s user 0,04s system 99% cpu 1,371 total

  $ time picat2 -g go7 map_bench.pi
  picat2 -g go7 map_bench.pi  2,72s user 0,04s system 99% cpu 2,756 total

  $ time picat3 -g go8 map_bench.pi
  picat3 -g go8 map_bench.pi  13,08s user 0,82s system 99% cpu 13,908 total

  $ time picat2 -g go8 map_bench.pi
  picat2 -g go8 map_bench.pi  27,18s user 0,80s system 99% cpu 27,984 total

  * Just checking that the foreach loops takes about the same (go9..go10)

  $ time picat -g go9 map_bench_v3.pi
  picat -g go9 map_bench_v3.pi  0,03s user 0,01s system 98% cpu 0,035 total

  $ time picat2 -g go9 map_bench_v3.pi
  picat2 -g go9 map_bench_v3.pi  0,03s user 0,00s system 98% cpu 0,033 total

  $ time picat -g go10 map_bench_v3.pi
  picat -g go10 map_bench_v3.pi  0,10s user 0,00s system 99% cpu 0,106 total

  $ time picat2 -g go10 map_bench_v3.pi
  picat2 -g go10 map_bench_v3.pi  0,09s user 0,01s system 99% cpu 0,100 total


  This Picat model was created by Hakan Kjellerstrand, hakank@gmail.com
  See also my Picat page: http://www.hakank.org/picat/

*/


main => go.


go ?=>
  X=sum(map(plus1,[I : I in 1..1_000_000])), 
  nl.
go => true.

go2 ?=>
  X=sum(map(plus1,[I : I in 1..10_000_000])),
  nl.
go2 => true.


go3 ?=>
  X=sum(map(times2,[I : I in 1..1_000_000])),
  nl.
go3 => true.

go4 ?=>
  X=sum(map(times2,[I : I in 1..10_000_000])),
  nl.
go4 => true.


go5 ?=>
  foreach(I in 1..1_000_000)
    X = apply(plus1,I)
  end,
  nl.
go5 => true.

go6 ?=>
  foreach(I in 1..10_000_000)
    X = apply(plus1,I)
  end,
  nl.
go6 => true.


go7 ?=>
  foreach(I in 1..1_000_000)
    I2 = I*2,
    call(p,I,I2)
  end,
  nl.
go7 => true.

go8 ?=>
  foreach(I in 1..10_000_000)
    I2 = I*2,
    call(p,I,I2)
  end,
  nl.
go8 => true.

go9 ?=>
  foreach(I in 1..1_000_000)
    true
  end,
  nl.
go9 => true.

go10 ?=>
  foreach(I in 1..10_000_000)
     true
  end,
  nl.
go10 => true.




plus1(X) = X+1.

times2(X) = X*2.


p(X,Y) => X != Y.