Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 15:17:02], version 200204013
 Executed d.d. Sat Apr 13 17:16:38 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.45072099999999998277(real)/0.4500000000000000111(user) seconds
1000000 times empty loop took 0.4473740000000000494(real)/0.4500000000000000111(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1117633 times empty loop took 0.50077000000000004842(real)/0.5(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1117633] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3894239999999999924(real)/6.3899999999999996803(user)s
Addition of 2 [1117633] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4837319999999998288(real)/6.4800000000000004263(user)s
10x array[1117633] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.00035899999999999999837(real)/0(user)s
10x array[1117633] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.93403700000000000614(real)/0.93999999999999994671(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1117633 times 2Dindex[1,2,3,4]: 2.7360039999999998805(real)/2.7400000000000002132(user)s
1117633 times nDindex[1,2,3,4]: 2.9555099999999998595(real)/2.9500000000000001776(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1117633 times 'progn[2,add[2,kk]]' took 3.7447409999999998753(real)/3.7400000000000002132(user) seconds with $UseConstantsLists=0
1117633 times 'progn[2,?add,?ran]' took 2.2956029999999998381(real)/2.2999999999999998224(user) seconds with $UseConstantsLists=0
1117633 times 'progn[2,add[2,kk]]' took 3.5475759999999998406(real)/3.5499999999999998224(user) seconds with $UseConstantsLists=1
1117633 times 'progn[2,?add,?ran]' took 2.0511590000000001766(real)/2.0499999999999998224(user) seconds with $UseConstantsLists=1
1117633 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2079399999999997917(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1117633 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.9324239999999999196(real)/1.9399999999999999467(user) seconds with $UseConstantsLists=1
1117633 times 'var'=0 took 0.81961099999999997845(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1117633 times 'var'=0 took 0.81983600000000000918(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1117633 times 'var[$loop]'=1117632 took 2.0159880000000001132(real)/2.0200000000000000178(user) seconds with $UseConstantsLists=0
1117633 times 'var[$loop]'=1117632 took 1.7640990000000000837(real)/1.7700000000000000178(user) seconds with $UseConstantsLists=1
1117633 times 'var[foo[$loop]]'=1117632 took 3.2177350000000002339(real)/3.2200000000000001954(user) seconds with $UseConstantsLists=0
1117633 times 'var[foo[$loop]]'=1117632 took 1.9355910000000000615(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117633 times 'var[foo[bar[$loop]]]'=1117632 took 4.4295650000000001967(real)/4.4299999999999997158(user) seconds with $UseConstantsLists=0
1117633 times 'var[foo[bar[$loop]]]'=1117632 took 3.1402390000000002246(real)/3.1400000000000001243(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1117633/2.4269581739130434705=460507.73021688021254 (real time)
	1117633/2.4278260869565220226=460343.10530085954815 (user time)
Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 15:17:02], version 200204013
 Executed d.d. Sat Apr 13 17:17:40 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.44764700000000001712(real)/0.4500000000000000111(user) seconds
1000000 times empty loop took 0.44746099999999999763(real)/0.4500000000000000111(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1117415 times empty loop took 0.50087800000000004541(real)/0.5(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1117415] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3955960000000002807(real)/6.4000000000000003553(user)s
Addition of 2 [1117415] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4610289999999999111(real)/6.4699999999999997513(user)s
10x array[1117415] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.00035599999999999997966(real)/0(user)s
10x array[1117415] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.93418500000000004313(real)/0.93000000000000004885(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1117415 times 2Dindex[1,2,3,4]: 2.7356609999999998983(real)/2.7400000000000002132(user)s
1117415 times nDindex[1,2,3,4]: 2.9544030000000001124(real)/2.9500000000000001776(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1117415 times 'progn[2,add[2,kk]]' took 3.7454960000000001585(real)/3.7400000000000002132(user) seconds with $UseConstantsLists=0
1117415 times 'progn[2,?add,?ran]' took 2.2958680000000000199(real)/2.2999999999999998224(user) seconds with $UseConstantsLists=0
1117415 times 'progn[2,add[2,kk]]' took 3.5452770000000000117(real)/3.5499999999999998224(user) seconds with $UseConstantsLists=1
1117415 times 'progn[2,?add,?ran]' took 2.0505870000000001596(real)/2.0499999999999998224(user) seconds with $UseConstantsLists=1
1117415 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2071079999999998478(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1117415 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.9324490000000000833(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117415 times 'var'=0 took 0.819277000000000033(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1117415 times 'var'=0 took 0.81938100000000002598(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1117415 times 'var[$loop]'=1117414 took 2.0155680000000000263(real)/2.0200000000000000178(user) seconds with $UseConstantsLists=0
1117415 times 'var[$loop]'=1117414 took 1.7648169999999998581(real)/1.7600000000000000089(user) seconds with $UseConstantsLists=1
1117415 times 'var[foo[$loop]]'=1117414 took 3.2165659999999998142(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1117415 times 'var[foo[$loop]]'=1117414 took 1.9337379999999999569(real)/1.9399999999999999467(user) seconds with $UseConstantsLists=1
1117415 times 'var[foo[bar[$loop]]]'=1117414 took 4.4319889999999997343(real)/4.4299999999999997158(user) seconds with $UseConstantsLists=0
1117415 times 'var[foo[bar[$loop]]]'=1117414 took 3.1393179999999998309(real)/3.1400000000000001243(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1117415/2.4258545652173912899=460627.36654613242717 (real time)
	1117415/2.4265217391304347849=460500.71671743417392 (user time)
Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 19:57:15], version 200204013
 Executed d.d. Sat Apr 13 20:03:33 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.48245100000000001872(real)/0.46999999999999997335(user) seconds
1000000 times empty loop took 0.44762299999999999311(real)/0.4500000000000000111(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1117011 times empty loop took 0.49985200000000001852(real)/0.5(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1117011] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3692570000000001684(real)/6.3700000000000001066(user)s
Addition of 2 [1117011] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4669259999999999522(real)/6.4599999999999999645(user)s
10x array[1117011] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.000371000000000000019(real)/0(user)s
10x array[1117011] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.90052699999999996638(real)/0.9000000000000000222(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1117011 times 2Dindex[1,2,3,4]: 2.7337379999999997793(real)/2.7400000000000002132(user)s
1117011 times nDindex[1,2,3,4]: 2.9462320000000001841(real)/2.9399999999999999467(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1117011 times 'progn[2,add[2,kk]]' took 3.7530019999999999492(real)/3.75(user) seconds with $UseConstantsLists=0
1117011 times 'progn[2,?add,?ran]' took 2.3325399999999998357(real)/2.3300000000000000711(user) seconds with $UseConstantsLists=0
1117011 times 'progn[2,add[2,kk]]' took 3.5490050000000001873(real)/3.5400000000000000355(user) seconds with $UseConstantsLists=1
1117011 times 'progn[2,?add,?ran]' took 2.0871909999999997964(real)/2.0899999999999998579(user) seconds with $UseConstantsLists=1
1117011 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2069209999999999106(real)/3.2000000000000001776(user) seconds with $UseConstantsLists=0
1117011 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.9328570000000000473(real)/1.9399999999999999467(user) seconds with $UseConstantsLists=1
1117011 times 'var'=0 took 0.81898599999999999177(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1117011 times 'var'=0 took 0.81996400000000002617(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1117011 times 'var[$loop]'=1117010 took 2.0149140000000000938(real)/2.0200000000000000178(user) seconds with $UseConstantsLists=0
1117011 times 'var[$loop]'=1117010 took 1.7676339999999999275(real)/1.7700000000000000178(user) seconds with $UseConstantsLists=1
1117011 times 'var[foo[$loop]]'=1117010 took 3.2112280000000001934(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1117011 times 'var[foo[$loop]]'=1117010 took 1.9310849999999999405(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117011 times 'var[foo[bar[$loop]]]'=1117010 took 4.4625479999999999592(real)/4.4599999999999999645(user) seconds with $UseConstantsLists=0
1117011 times 'var[foo[bar[$loop]]]'=1117010 took 3.1788639999999999119(real)/3.1800000000000001599(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1117011/2.4310311304347824723=459480.33573729923228 (real time)
	1117011/2.430000000000000604=459675.30864197522169 (user time)
Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 19:57:15], version 200204013
 Executed d.d. Sat Apr 13 20:04:55 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.44762200000000001987(real)/0.4500000000000000111(user) seconds
1000000 times empty loop took 0.44744600000000001039(real)/0.4500000000000000111(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1117453 times empty loop took 0.50065999999999999392(real)/0.5(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1117453] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3874310000000003029(real)/6.3899999999999996803(user)s
Addition of 2 [1117453] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4526690000000002101(real)/6.4500000000000001776(user)s
10x array[1117453] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.00037800000000000002652(real)/0(user)s
10x array[1117453] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.97583500000000000796(real)/0.96999999999999997335(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1117453 times 2Dindex[1,2,3,4]: 2.7367400000000001725(real)/2.7299999999999999822(user)s
1117453 times nDindex[1,2,3,4]: 2.9468890000000000917(real)/2.9500000000000001776(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1117453 times 'progn[2,add[2,kk]]' took 3.7541289999999998273(real)/3.75(user) seconds with $UseConstantsLists=0
1117453 times 'progn[2,?add,?ran]' took 2.3200620000000000687(real)/2.3199999999999998401(user) seconds with $UseConstantsLists=0
1117453 times 'progn[2,add[2,kk]]' took 3.5513400000000001633(real)/3.5600000000000000533(user) seconds with $UseConstantsLists=1
1117453 times 'progn[2,?add,?ran]' took 2.0882339999999999236(real)/2.0800000000000000711(user) seconds with $UseConstantsLists=1
1117453 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2067899999999998073(real)/3.2000000000000001776(user) seconds with $UseConstantsLists=0
1117453 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.9332530000000001102(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117453 times 'var'=0 took 0.81922800000000006726(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1117453 times 'var'=0 took 0.81929200000000002024(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1117453 times 'var[$loop]'=1117452 took 2.0155940000000001078(real)/2.0200000000000000178(user) seconds with $UseConstantsLists=0
1117453 times 'var[$loop]'=1117452 took 1.7694790000000000241(real)/1.7700000000000000178(user) seconds with $UseConstantsLists=1
1117453 times 'var[foo[$loop]]'=1117452 took 3.2117640000000000633(real)/3.2200000000000001954(user) seconds with $UseConstantsLists=0
1117453 times 'var[foo[$loop]]'=1117452 took 1.9326440000000000285(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117453 times 'var[foo[bar[$loop]]]'=1117452 took 4.4637489999999999668(real)/4.4699999999999997513(user) seconds with $UseConstantsLists=0
1117453 times 'var[foo[bar[$loop]]]'=1117452 took 3.1790490000000000137(real)/3.1800000000000001599(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1117453/2.4330555217391305334=459279.69584567996208 (real time)
	1117453/2.4330434782608696409=459281.96926375979092 (user time)
Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 19:57:15], version 200204013
 Executed d.d. Sat Apr 13 20:13:15 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.4478070000000000106(real)/0.44000000000000000222(user) seconds
1000000 times empty loop took 0.44743500000000002714(real)/0.44000000000000000222(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1117480 times empty loop took 0.50065899999999996517(real)/0.5(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1117480] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3743850000000001899(real)/6.3799999999999998934(user)s
Addition of 2 [1117480] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4539249999999999119(real)/6.4500000000000001776(user)s
10x array[1117480] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.0003719999999999999891(real)/0(user)s
10x array[1117480] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.97497999999999995779(real)/0.96999999999999997335(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1117480 times 2Dindex[1,2,3,4]: 2.7371910000000001517(real)/2.7299999999999999822(user)s
1117480 times nDindex[1,2,3,4]: 2.9470740000000001935(real)/2.9500000000000001776(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1117480 times 'progn[2,add[2,kk]]' took 3.7545440000000001035(real)/3.75(user) seconds with $UseConstantsLists=0
1117480 times 'progn[2,?add,?ran]' took 2.3201060000000000016(real)/2.3199999999999998401(user) seconds with $UseConstantsLists=0
1117480 times 'progn[2,add[2,kk]]' took 3.5520999999999998131(real)/3.5600000000000000533(user) seconds with $UseConstantsLists=1
1117480 times 'progn[2,?add,?ran]' took 2.0894260000000000055(real)/2.0899999999999998579(user) seconds with $UseConstantsLists=1
1117480 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2071700000000000763(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1117480 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.9311529999999998974(real)/1.9299999999999999378(user) seconds with $UseConstantsLists=1
1117480 times 'var'=0 took 0.81997500000000000941(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1117480 times 'var'=0 took 0.819249000000000005(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1117480 times 'var[$loop]'=1117479 took 2.0156339999999999257(real)/2.0099999999999997868(user) seconds with $UseConstantsLists=0
1117480 times 'var[$loop]'=1117479 took 1.7706849999999998424(real)/1.7700000000000000178(user) seconds with $UseConstantsLists=1
1117480 times 'var[foo[$loop]]'=1117479 took 3.2647589999999997445(real)/3.2599999999999997868(user) seconds with $UseConstantsLists=0
1117480 times 'var[foo[$loop]]'=1117479 took 1.9339610000000000412(real)/1.9399999999999999467(user) seconds with $UseConstantsLists=1
1117480 times 'var[foo[bar[$loop]]]'=1117479 took 4.4635259999999998826(real)/4.4599999999999999645(user) seconds with $UseConstantsLists=0
1117480 times 'var[foo[bar[$loop]]]'=1117479 took 3.1799010000000000886(real)/3.1800000000000001599(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1117480/2.4350442173913044996=458915.69114797073416 (real time)
	1117480/2.4339130434782605406=459128.97463379782857 (user time)
Current file: examples/benching.xg: Sat Apr 13 14:57:56 2002
A collection of timing benchmarks. Can take quite a while to complete, and doesn't generate
overly nice output! Performance measured in bogoflops, <err> I mean seconds :)
Current xgraph info:
 xgraph examples/benching.xg -detach
 XGraph build gcc[Apr 13 2002 20:19:19], version 200204013
 Executed d.d. Sat Apr 13 22:24:52 2002
 Input files: 'examples/benching.xg' 
 Working directory: /home/bertin/work/src/xgraph
 Last opened on display :0.0/-1/-1 (visual 0x24, 16 planes TrueColor) by bertin


1000000 times empty loop took 0.45237700000000002909(real)/0.4500000000000000111(user) seconds
1000000 times empty loop took 0.44793899999999997608(real)/0.44000000000000000222(user) seconds
Calibrating adapted loop size (should be 0.5s)... 1116223 times empty loop took 0.49981500000000000927(real)/0.48999999999999999112(user) seconds

timing of addition of 2 arrays, either with a for-toMAX[] loop construct (scalar addition), or
with (internal) array addition. The latter is done 10x to increase the reliability of the measured
duration. Procedures are used to ensure that the code is executed from compiled representations
(*EVAL* would not automatically compile the array-addition test procedure [test2]).
On a PIII 450Mhz (linux), test1 completes in around 5.8s, test2 under 1s (meaning that the array
addition is some 60x faster than the looped scalar addition).

Addition of 2 [1116223] arrays in a scalar-addition loop, without support for simple array arithmetic: 6.3888319999999998444(real)/6.3899999999999996803(user)s
Addition of 2 [1116223] arrays in a scalar-addition loop, with support for simple array arithmetic: 6.4270599999999999952(real)/6.4199999999999999289(user)s
10x array[1116223] addition without support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.0003739999999999999835(real)/0(user)s
10x array[1116223] addition with support for simple array arithmetic, array addition (add[&z,&x,&y]): 0.95214399999999999036(real)/0.95999999999999996447(user)s

Comparing the special 2-D indexing function 2Dindex to nDindex

1116223 times 2Dindex[1,2,3,4]: 2.7322969999999999757(real)/2.7299999999999999822(user)s
1116223 times nDindex[1,2,3,4]: 2.9452090000000001879(real)/2.9500000000000001776(user)s

Some loops to time the effect of $UseConstantsLists (and the '?' last-value operator):

1116223 times 'progn[2,add[2,kk]]' took 3.7494049999999998768(real)/3.75(user) seconds with $UseConstantsLists=0
1116223 times 'progn[2,?add,?ran]' took 2.3187340000000000728(real)/2.3199999999999998401(user) seconds with $UseConstantsLists=0
1116223 times 'progn[2,add[2,kk]]' took 3.5477249999999997954(real)/3.5499999999999998224(user) seconds with $UseConstantsLists=1
1116223 times 'progn[2,?add,?ran]' took 2.0856949999999998546(real)/2.0899999999999998579(user) seconds with $UseConstantsLists=1
1116223 times 'var[foo[?ran]]'=0.1766426425429159508 took 3.2040899999999998826(real)/3.2099999999999999645(user) seconds with $UseConstantsLists=0
1116223 times 'var[foo[?ran]]'=0.1766426425429159508 took 1.910671999999999926(real)/1.9099999999999999201(user) seconds with $UseConstantsLists=1
1116223 times 'var'=0 took 0.82347199999999998177(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=0
1116223 times 'var'=0 took 0.82355999999999995875(real)/0.81999999999999995115(user) seconds with $UseConstantsLists=1
1116223 times 'var[$loop]'=1116222 took 2.0150719999999999743(real)/2.0200000000000000178(user) seconds with $UseConstantsLists=0
1116223 times 'var[$loop]'=1116222 took 1.7639070000000001137(real)/1.7600000000000000089(user) seconds with $UseConstantsLists=1
1116223 times 'var[foo[$loop]]'=1116222 took 3.2090709999999997848(real)/3.2000000000000001776(user) seconds with $UseConstantsLists=0
1116223 times 'var[foo[$loop]]'=1116222 took 1.9105140000000000455(real)/1.9099999999999999201(user) seconds with $UseConstantsLists=1
1116223 times 'var[foo[bar[$loop]]]'=1116222 took 4.4235009999999999053(real)/4.4199999999999999289(user) seconds with $UseConstantsLists=0
1116223 times 'var[foo[bar[$loop]]]'=1116222 took 3.171930999999999834(real)/3.1699999999999999289(user) seconds with $UseConstantsLists=1
expression-loops per second:
	1116223/2.4262346086956525504=460063.91797373758163 (real time)
	1116223/2.4252173913043479914=460256.88418788090348 (user time)
