-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 7 microseconds.
Each test below will take on the order of 90740 microseconds.
   (= 12962 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3065       0.1598       0.1595       0.1607
Scale:         99.9587       0.1602       0.1601       0.1607
Add:          109.9001       0.2185       0.2184       0.2187
Triad:        107.7252       0.2230       0.2228       0.2236
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90602 microseconds.
   (= 45301 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5243       0.1595       0.1592       0.1605
Scale:        100.3097       0.1597       0.1595       0.1599
Add:          110.3526       0.2176       0.2175       0.2181
Triad:        108.0869       0.2222       0.2220       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90431 microseconds.
   (= 45215 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6615       0.1593       0.1589       0.1602
Scale:        100.5797       0.1593       0.1591       0.1595
Add:          110.4777       0.2174       0.2172       0.2177
Triad:        108.0535       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90393 microseconds.
   (= 45196 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5339       0.1595       0.1592       0.1602
Scale:        100.6201       0.1591       0.1590       0.1593
Add:          110.4252       0.2176       0.2173       0.2182
Triad:        108.1279       0.2221       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90478 microseconds.
   (= 45239 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7950       0.1596       0.1587       0.1657
Scale:        100.4333       0.1596       0.1593       0.1604
Add:          110.4129       0.2175       0.2174       0.2178
Triad:        108.1301       0.2233       0.2220       0.2333
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90724 microseconds.
   (= 45362 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6350       0.1592       0.1590       0.1604
Scale:        100.2775       0.1597       0.1596       0.1598
Add:          110.4954       0.2174       0.2172       0.2180
Triad:        108.1092       0.2221       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90585 microseconds.
   (= 45292 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9583       0.1589       0.1585       0.1597
Scale:        100.5334       0.1594       0.1592       0.1598
Add:          110.3040       0.2178       0.2176       0.2185
Triad:        108.0769       0.2222       0.2221       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90364 microseconds.
   (= 45182 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6552       0.1592       0.1590       0.1600
Scale:        100.3898       0.1596       0.1594       0.1597
Add:          110.4828       0.2175       0.2172       0.2181
Triad:        108.0640       0.2223       0.2221       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90531 microseconds.
   (= 45265 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7268       0.1592       0.1588       0.1601
Scale:        100.5260       0.1593       0.1592       0.1596
Add:          110.4162       0.2176       0.2174       0.2183
Triad:        108.0379       0.2223       0.2221       0.2227
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90591 microseconds.
   (= 45295 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3567       0.1598       0.1594       0.1609
Scale:        100.3105       0.1597       0.1595       0.1600
Add:          110.4640       0.2174       0.2173       0.2176
Triad:        107.9977       0.2224       0.2222       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90446 microseconds.
   (= 45223 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8635       0.1589       0.1586       0.1596
Scale:        100.6154       0.1593       0.1590       0.1602
Add:          110.3366       0.2176       0.2175       0.2178
Triad:        108.0740       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90449 microseconds.
   (= 45224 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4433       0.1596       0.1593       0.1607
Scale:        100.3471       0.1597       0.1594       0.1603
Add:          110.3615       0.2176       0.2175       0.2178
Triad:        107.9586       0.2225       0.2223       0.2232
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90455 microseconds.
   (= 45227 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9819       0.1588       0.1584       0.1597
Scale:        100.6135       0.1592       0.1590       0.1597
Add:          110.4354       0.2176       0.2173       0.2183
Triad:        108.0636       0.2222       0.2221       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90714 microseconds.
   (= 45357 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7400       0.1591       0.1588       0.1600
Scale:        100.3560       0.1596       0.1594       0.1603
Add:          110.3782       0.2175       0.2174       0.2178
Triad:        108.0216       0.2224       0.2222       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90683 microseconds.
   (= 45341 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9568       0.1588       0.1585       0.1598
Scale:        100.7277       0.1591       0.1588       0.1594
Add:          110.4256       0.2175       0.2173       0.2179
Triad:        108.1005       0.2223       0.2220       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90499 microseconds.
   (= 45249 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6194       0.1594       0.1590       0.1603
Scale:        100.2971       0.1596       0.1595       0.1598
Add:          110.4219       0.2175       0.2173       0.2177
Triad:        108.0990       0.2222       0.2220       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90432 microseconds.
   (= 45216 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9751       0.1588       0.1585       0.1597
Scale:        100.7261       0.1590       0.1588       0.1593
Add:          110.4363       0.2176       0.2173       0.2183
Triad:        108.1292       0.2221       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90832 microseconds.
   (= 45416 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4112       0.1597       0.1593       0.1606
Scale:        100.1862       0.1599       0.1597       0.1601
Add:          110.4967       0.2174       0.2172       0.2181
Triad:        108.1045       0.2221       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90497 microseconds.
   (= 45248 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9189       0.1588       0.1585       0.1595
Scale:        100.6222       0.1592       0.1590       0.1601
Add:          110.4421       0.2175       0.2173       0.2183
Triad:        108.1023       0.2222       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90522 microseconds.
   (= 45261 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7914       0.1590       0.1587       0.1598
Scale:        100.2448       0.1598       0.1596       0.1600
Add:          110.4117       0.2176       0.2174       0.2182
Triad:        108.0394       0.2223       0.2221       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90344 microseconds.
   (= 45172 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7788       0.1589       0.1588       0.1600
Scale:        100.6378       0.1592       0.1590       0.1594
Add:          110.3641       0.2176       0.2175       0.2178
Triad:        108.0576       0.2223       0.2221       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90798 microseconds.
   (= 45399 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8102       0.1590       0.1587       0.1601
Scale:        100.4009       0.1596       0.1594       0.1603
Add:          110.3211       0.2177       0.2175       0.2181
Triad:        108.0015       0.2225       0.2222       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90536 microseconds.
   (= 45268 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7891       0.1591       0.1587       0.1600
Scale:        100.5951       0.1593       0.1591       0.1600
Add:          110.3710       0.2176       0.2174       0.2178
Triad:        108.0473       0.2223       0.2221       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90450 microseconds.
   (= 45225 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3984       0.1596       0.1594       0.1606
Scale:        100.4054       0.1595       0.1594       0.1597
Add:          110.4710       0.2175       0.2173       0.2181
Triad:        108.0799       0.2222       0.2221       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90576 microseconds.
   (= 45288 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6049       0.1593       0.1590       0.1607
Scale:        100.6750       0.1592       0.1589       0.1596
Add:          110.3557       0.2177       0.2175       0.2184
Triad:        108.0849       0.2222       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90649 microseconds.
   (= 45324 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5636       0.1593       0.1591       0.1604
Scale:        100.2622       0.1597       0.1596       0.1599
Add:          110.4830       0.2175       0.2172       0.2181
Triad:        108.0473       0.2223       0.2221       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90475 microseconds.
   (= 45237 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8477       0.1590       0.1587       0.1606
Scale:        100.4495       0.1594       0.1593       0.1595
Add:          110.3620       0.2178       0.2175       0.2185
Triad:        108.0368       0.2223       0.2221       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90739 microseconds.
   (= 45369 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3540       0.1596       0.1594       0.1607
Scale:        100.3270       0.1597       0.1595       0.1602
Add:          110.4647       0.2175       0.2173       0.2180
Triad:        108.0396       0.2224       0.2221       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90388 microseconds.
   (= 45194 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         101.1695       0.1586       0.1582       0.1594
Scale:        100.6314       0.1592       0.1590       0.1600
Add:          110.4186       0.2176       0.2174       0.2178
Triad:        108.1114       0.2222       0.2220       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90549 microseconds.
   (= 45274 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.2656       0.1598       0.1596       0.1609
Scale:        100.3656       0.1597       0.1594       0.1604
Add:          110.4377       0.2175       0.2173       0.2177
Triad:        107.9723       0.2225       0.2223       0.2232
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90468 microseconds.
   (= 45234 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8725       0.1588       0.1586       0.1598
Scale:        100.5923       0.1594       0.1591       0.1601
Add:          110.4004       0.2175       0.2174       0.2179
Triad:        108.0215       0.2223       0.2222       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90736 microseconds.
   (= 45368 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7056       0.1591       0.1589       0.1601
Scale:        100.3042       0.1597       0.1595       0.1598
Add:          110.3940       0.2176       0.2174       0.2181
Triad:        108.0122       0.2224       0.2222       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90447 microseconds.
   (= 45223 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8450       0.1590       0.1587       0.1607
Scale:        100.6140       0.1592       0.1590       0.1594
Add:          110.4252       0.2176       0.2173       0.2184
Triad:        108.0899       0.2222       0.2220       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90423 microseconds.
   (= 45211 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         101.1989       0.1584       0.1581       0.1594
Scale:        100.3571       0.1596       0.1594       0.1598
Add:          110.4707       0.2175       0.2173       0.2182
Triad:        108.0871       0.2222       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90547 microseconds.
   (= 45273 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4919       0.1595       0.1592       0.1605
Scale:        100.7081       0.1591       0.1589       0.1595
Add:          110.4119       0.2175       0.2174       0.2178
Triad:        108.0528       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90480 microseconds.
   (= 45240 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3933       0.1596       0.1594       0.1605
Scale:        100.7215       0.1591       0.1589       0.1598
Add:          110.4261       0.2175       0.2173       0.2176
Triad:        108.0244       0.2224       0.2222       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90448 microseconds.
   (= 45224 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         101.0847       0.1586       0.1583       0.1596
Scale:        100.6270       0.1604       0.1590       0.1701
Add:          110.4237       0.2180       0.2173       0.2227
Triad:        108.0662       0.2224       0.2221       0.2236
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90944 microseconds.
   (= 45472 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9976       0.1587       0.1584       0.1596
Scale:        100.4090       0.1595       0.1593       0.1597
Add:          110.4532       0.2175       0.2173       0.2181
Triad:        108.1188       0.2222       0.2220       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90459 microseconds.
   (= 45229 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6734       0.1592       0.1589       0.1599
Scale:        100.3078       0.1596       0.1595       0.1598
Add:          110.4141       0.2176       0.2174       0.2182
Triad:        108.0784       0.2222       0.2221       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90540 microseconds.
   (= 45270 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9676       0.1589       0.1585       0.1599
Scale:        100.5325       0.1593       0.1592       0.1596
Add:          110.3358       0.2178       0.2175       0.2184
Triad:        108.0704       0.2222       0.2221       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90587 microseconds.
   (= 45293 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3617       0.1597       0.1594       0.1607
Scale:        100.3016       0.1596       0.1595       0.1599
Add:          110.4233       0.2176       0.2173       0.2183
Triad:        108.0552       0.2222       0.2221       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90417 microseconds.
   (= 45208 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6413       0.1593       0.1590       0.1600
Scale:        100.1927       0.1598       0.1597       0.1600
Add:          110.3868       0.2175       0.2174       0.2177
Triad:        108.1493       0.2221       0.2219       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90534 microseconds.
   (= 45267 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4930       0.1595       0.1592       0.1605
Scale:        100.3221       0.1597       0.1595       0.1606
Add:          110.3483       0.2177       0.2175       0.2183
Triad:        108.0305       0.2223       0.2222       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90486 microseconds.
   (= 45243 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8880       0.1588       0.1586       0.1597
Scale:        100.6349       0.1593       0.1590       0.1601
Add:          110.4198       0.2175       0.2174       0.2178
Triad:        108.1269       0.2222       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90430 microseconds.
   (= 45215 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4351       0.1595       0.1593       0.1607
Scale:        100.3110       0.1597       0.1595       0.1604
Add:          110.4296       0.2175       0.2173       0.2178
Triad:        108.1260       0.2222       0.2220       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90424 microseconds.
   (= 45212 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7929       0.1590       0.1587       0.1600
Scale:        100.6332       0.1593       0.1590       0.1598
Add:          110.4382       0.2175       0.2173       0.2178
Triad:        108.1700       0.2221       0.2219       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90423 microseconds.
   (= 45211 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7647       0.1590       0.1588       0.1599
Scale:        100.1683       0.1599       0.1597       0.1601
Add:          110.4507       0.2175       0.2173       0.2177
Triad:        108.0763       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90470 microseconds.
   (= 45235 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7341       0.1592       0.1588       0.1601
Scale:        100.5819       0.1593       0.1591       0.1596
Add:          110.3348       0.2177       0.2175       0.2182
Triad:        108.0489       0.2223       0.2221       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90465 microseconds.
   (= 45232 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         101.0215       0.1587       0.1584       0.1598
Scale:        100.2993       0.1598       0.1595       0.1605
Add:          110.4361       0.2174       0.2173       0.2177
Triad:        108.0229       0.2224       0.2222       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90442 microseconds.
   (= 45221 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         101.1154       0.1585       0.1582       0.1594
Scale:        100.7491       0.1591       0.1588       0.1600
Add:          110.4118       0.2176       0.2174       0.2177
Triad:        108.1189       0.2223       0.2220       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90880 microseconds.
   (= 45440 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4649       0.1596       0.1593       0.1608
Scale:        100.1287       0.1599       0.1598       0.1601
Add:          110.3813       0.2176       0.2174       0.2183
Triad:        108.0294       0.2223       0.2222       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90493 microseconds.
   (= 45246 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6801       0.1592       0.1589       0.1600
Scale:        100.6739       0.1592       0.1589       0.1601
Add:          110.3783       0.2177       0.2174       0.2185
Triad:        108.0784       0.2222       0.2221       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90366 microseconds.
   (= 45183 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6611       0.1592       0.1589       0.1602
Scale:        100.2117       0.1598       0.1597       0.1601
Add:          110.3943       0.2176       0.2174       0.2179
Triad:        108.0432       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90558 microseconds.
   (= 45279 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6361       0.1593       0.1590       0.1603
Scale:        100.6427       0.1591       0.1590       0.1594
Add:          110.4084       0.2175       0.2174       0.2177
Triad:        108.1028       0.2222       0.2220       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90444 microseconds.
   (= 45222 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.9266       0.1588       0.1585       0.1597
Scale:        100.3665       0.1595       0.1594       0.1596
Add:          110.4473       0.2175       0.2173       0.2179
Triad:        108.0922       0.2223       0.2220       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90417 microseconds.
   (= 45208 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5666       0.1594       0.1591       0.1604
Scale:        100.5397       0.1592       0.1591       0.1595
Add:          110.3664       0.2177       0.2175       0.2183
Triad:        108.1340       0.2221       0.2219       0.2222
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90684 microseconds.
   (= 45342 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4752       0.1596       0.1592       0.1605
Scale:        100.5606       0.1594       0.1591       0.1597
Add:          110.4792       0.2176       0.2172       0.2181
Triad:        108.0896       0.2222       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90592 microseconds.
   (= 45296 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6096       0.1594       0.1590       0.1603
Scale:        100.5929       0.1592       0.1591       0.1596
Add:          110.3694       0.2177       0.2175       0.2183
Triad:        108.0979       0.2222       0.2220       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90423 microseconds.
   (= 45211 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7078       0.1591       0.1589       0.1598
Scale:        100.2798       0.1598       0.1596       0.1600
Add:          110.3730       0.2176       0.2174       0.2178
Triad:        108.0530       0.2223       0.2221       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90469 microseconds.
   (= 45234 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8518       0.1589       0.1586       0.1603
Scale:        100.6281       0.1592       0.1590       0.1595
Add:          110.3370       0.2177       0.2175       0.2178
Triad:        108.0649       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90365 microseconds.
   (= 45182 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8054       0.1590       0.1587       0.1599
Scale:        100.2721       0.1596       0.1596       0.1598
Add:          110.4115       0.2175       0.2174       0.2176
Triad:        108.0480       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90478 microseconds.
   (= 45239 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.8651       0.1588       0.1586       0.1598
Scale:        100.5327       0.1594       0.1592       0.1599
Add:          110.4280       0.2175       0.2173       0.2176
Triad:        108.1193       0.2222       0.2220       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90687 microseconds.
   (= 45343 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4829       0.1595       0.1592       0.1604
Scale:        100.2879       0.1597       0.1595       0.1598
Add:          110.4759       0.2175       0.2172       0.2184
Triad:        108.0620       0.2223       0.2221       0.2226
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90439 microseconds.
   (= 45219 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6981       0.1594       0.1589       0.1606
Scale:        100.4671       0.1595       0.1593       0.1600
Add:          110.3149       0.2178       0.2176       0.2183
Triad:        108.0894       0.2222       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90413 microseconds.
   (= 45206 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5657       0.1593       0.1591       0.1601
Scale:        100.3560       0.1595       0.1594       0.1596
Add:          110.3894       0.2177       0.2174       0.2186
Triad:        108.0459       0.2223       0.2221       0.2225
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90767 microseconds.
   (= 45383 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.5893       0.1593       0.1591       0.1604
Scale:        100.7117       0.1591       0.1589       0.1594
Add:          110.4451       0.2175       0.2173       0.2182
Triad:        108.1163       0.2221       0.2220       0.2224
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90614 microseconds.
   (= 45307 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7719       0.1591       0.1588       0.1600
Scale:        100.5173       0.1595       0.1592       0.1600
Add:          110.3991       0.2176       0.2174       0.2179
Triad:        108.0307       0.2224       0.2222       0.2230
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90461 microseconds.
   (= 45230 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.1988       0.1599       0.1597       0.1608
Scale:        100.1200       0.1601       0.1598       0.1607
Add:          110.4401       0.2175       0.2173       0.2176
Triad:        108.0808       0.2223       0.2221       0.2229
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90443 microseconds.
   (= 45221 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.7728       0.1590       0.1588       0.1598
Scale:        100.5509       0.1594       0.1591       0.1601
Add:          110.4714       0.2175       0.2173       0.2177
Triad:        108.0823       0.2223       0.2221       0.2232
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90680 microseconds.
   (= 45340 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.3801       0.1596       0.1594       0.1607
Scale:        100.6057       0.1593       0.1590       0.1595
Add:          110.4055       0.2194       0.2174       0.2346
Triad:        108.0527       0.2223       0.2221       0.2231
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90547 microseconds.
   (= 45273 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.6165       0.1593       0.1590       0.1603
Scale:        100.5343       0.1594       0.1591       0.1595
Add:          110.3351       0.2178       0.2175       0.2186
Triad:        108.0736       0.2222       0.2221       0.2223
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 1000000, Offset = 0
Total memory required = 22.9 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 2 microseconds.
Each test below will take on the order of 90547 microseconds.
   (= 45273 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         100.4868       0.1595       0.1592       0.1603
Scale:        100.5974       0.1593       0.1590       0.1594
Add:          110.3489       0.2177       0.2175       0.2185
Triad:        108.0779       0.2222       0.2221       0.2224