-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 27 microseconds.
Each test below will take on the order of 4550897 microseconds.
   (= 168551 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:          38.5877       0.2105       0.2073       0.2277
Scale:         56.6343       0.6321       0.1413       1.9530
Add:           59.1818       0.2042       0.2028       0.2100
Triad:         58.5349       0.2051       0.2050       0.2057
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 20 microseconds.
Each test below will take on the order of 174626 microseconds.
   (= 8731 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:          37.4901       0.2147       0.2134       0.2248
Scale:         55.6808       0.1438       0.1437       0.1448
Add:           57.3678       0.2107       0.2092       0.2238
Triad:         57.2609       0.2096       0.2096       0.2096
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 192700 microseconds.
   (= 10142 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:          37.4943       0.2149       0.2134       0.2242
Scale:         55.7133       0.1441       0.1436       0.1468
Add:           57.4157       0.2091       0.2090       0.2096
Triad:         57.2888       0.2097       0.2095       0.2110
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 176333 microseconds.
   (= 9280 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:          37.5092       0.2189       0.2133       0.2379
Scale:         55.7434       0.1445       0.1435       0.1482
Add:           57.4271       0.2091       0.2090       0.2092
Triad:         57.3048       0.2108       0.2094       0.2214
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 178642 microseconds.
   (= 9402 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:          37.5170       0.2147       0.2132       0.2255
Scale:         55.8205       0.1445       0.1433       0.1546
Add:           57.4911       0.2090       0.2087       0.2102
Triad:         57.3441       0.2093       0.2093       0.2094
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 193706 microseconds.
   (= 10195 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:          37.5398       0.2133       0.2131       0.2151
Scale:         55.8508       0.1434       0.1432       0.1447
Add:           57.5169       0.2087       0.2086       0.2087
Triad:         57.3677       0.2094       0.2092       0.2106
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 185807 microseconds.
   (= 9779 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:          37.5441       0.2147       0.2131       0.2250
Scale:         55.8556       0.1432       0.1432       0.1433
Add:           57.5333       0.2088       0.2086       0.2100
Triad:         57.3794       0.2092       0.2091       0.2092
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174289 microseconds.
   (= 9173 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:          37.5245       0.2135       0.2132       0.2159
Scale:         55.8750       0.1432       0.1432       0.1433
Add:           57.5251       0.2088       0.2086       0.2101
Triad:         57.3694       0.2093       0.2092       0.2096
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 198493 microseconds.
   (= 10447 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:          37.5379       0.2134       0.2131       0.2160
Scale:         55.8979       0.1433       0.1431       0.1445
Add:           57.5496       0.2085       0.2085       0.2086
Triad:         57.3840       0.2092       0.2091       0.2094
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 176629 microseconds.
   (= 9296 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:          37.5280       0.2156       0.2132       0.2345
Scale:         55.8549       0.1436       0.1432       0.1461
Add:           57.5166       0.2098       0.2086       0.2195
Triad:         57.3505       0.2095       0.2092       0.2107
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174024 microseconds.
   (= 9159 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:          37.5286       0.2136       0.2132       0.2151
Scale:         55.8295       0.1435       0.1433       0.1450
Add:           57.5075       0.2087       0.2087       0.2088
Triad:         57.3562       0.2092       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 177850 microseconds.
   (= 9360 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:          37.5331       0.2135       0.2131       0.2160
Scale:         55.8328       0.1433       0.1433       0.1434
Add:           57.5050       0.2087       0.2087       0.2087
Triad:         57.3561       0.2094       0.2092       0.2107
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173263 microseconds.
   (= 9119 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:          37.5379       0.2135       0.2131       0.2155
Scale:         55.8406       0.1439       0.1433       0.1470
Add:           57.5160       0.2106       0.2086       0.2273
Triad:         57.3502       0.2093       0.2092       0.2095
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173739 microseconds.
   (= 9144 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:          37.5214       0.2136       0.2132       0.2152
Scale:         55.8368       0.1433       0.1433       0.1434
Add:           57.4942       0.2091       0.2087       0.2123
Triad:         57.3507       0.2093       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 191567 microseconds.
   (= 10082 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:          37.5231       0.2137       0.2132       0.2161
Scale:         55.8235       0.1434       0.1433       0.1434
Add:           57.5020       0.2089       0.2087       0.2102
Triad:         57.3540       0.2093       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173827 microseconds.
   (= 9148 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:          37.5217       0.2138       0.2132       0.2162
Scale:         55.8270       0.1451       0.1433       0.1596
Add:           57.4948       0.2138       0.2087       0.2355
Triad:         57.3520       0.2094       0.2092       0.2104
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174170 microseconds.
   (= 9166 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:          37.5237       0.2137       0.2132       0.2174
Scale:         55.8061       0.1435       0.1434       0.1446
Add:           57.4801       0.2090       0.2088       0.2103
Triad:         57.3391       0.2097       0.2093       0.2132
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 184444 microseconds.
   (= 9707 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:          37.5381       0.2133       0.2131       0.2150
Scale:         55.8826       0.1435       0.1432       0.1448
Add:           57.5365       0.2086       0.2086       0.2087
Triad:         57.3900       0.2093       0.2091       0.2107
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 187764 microseconds.
   (= 9882 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:          37.5258       0.2136       0.2132       0.2162
Scale:         55.8607       0.1434       0.1432       0.1448
Add:           57.5176       0.2087       0.2086       0.2088
Triad:         57.3651       0.2094       0.2092       0.2107
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173370 microseconds.
   (= 9124 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:          37.5342       0.2157       0.2131       0.2367
Scale:         55.8324       0.1437       0.1433       0.1454
Add:           57.5125       0.2102       0.2087       0.2234
Triad:         57.3593       0.2094       0.2092       0.2108
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173398 microseconds.
   (= 9126 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:          37.5250       0.2137       0.2132       0.2162
Scale:         55.8835       0.1432       0.1432       0.1433
Add:           57.5288       0.2086       0.2086       0.2087
Triad:         57.3627       0.2092       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173308 microseconds.
   (= 9121 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:          37.5214       0.2408       0.2132       0.3528
Scale:         55.8960       0.2565       0.1431       0.6832
Add:           57.5319       0.2222       0.2086       0.2844
Triad:         57.3743       0.2222       0.2092       0.2941
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 175194 microseconds.
   (= 9220 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:          37.5464       0.2135       0.2131       0.2164
Scale:         55.8906       0.1434       0.1431       0.1447
Add:           57.5497       0.2108       0.2085       0.2288
Triad:         57.3876       0.2093       0.2091       0.2108
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174400 microseconds.
   (= 9178 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:          37.5520       0.2136       0.2130       0.2166
Scale:         55.8649       0.1433       0.1432       0.1433
Add:           57.5399       0.2086       0.2086       0.2086
Triad:         57.3818       0.2092       0.2091       0.2094
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 197714 microseconds.
   (= 10406 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:          37.5619       0.2132       0.2130       0.2152
Scale:         55.8596       0.1433       0.1432       0.1433
Add:           57.5546       0.2087       0.2085       0.2101
Triad:         57.3949       0.2091       0.2091       0.2092
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 176478 microseconds.
   (= 9288 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:          37.5370       0.2146       0.2131       0.2228
Scale:         55.8311       0.1434       0.1433       0.1439
Add:           57.5155       0.2087       0.2086       0.2089
Triad:         57.3533       0.2093       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 175179 microseconds.
   (= 9219 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:          37.5291       0.2135       0.2132       0.2161
Scale:         55.8348       0.1434       0.1433       0.1436
Add:           57.5096       0.2087       0.2087       0.2090
Triad:         57.3549       0.2094       0.2092       0.2108
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173679 microseconds.
   (= 9141 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:          37.5338       0.2135       0.2131       0.2155
Scale:         55.8594       0.1473       0.1432       0.1785
Add:           57.5327       0.2110       0.2086       0.2265
Triad:         57.3727       0.2112       0.2092       0.2283
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 185210 microseconds.
   (= 9747 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:          37.5432       0.2135       0.2131       0.2164
Scale:         55.8644       0.1434       0.1432       0.1445
Add:           57.5319       0.2089       0.2086       0.2101
Triad:         57.3676       0.2103       0.2092       0.2192
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 173797 microseconds.
   (= 9147 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:          37.5316       0.2135       0.2132       0.2149
Scale:         55.8370       0.1434       0.1433       0.1435
Add:           57.5059       0.2089       0.2087       0.2102
Triad:         57.3560       0.2093       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174626 microseconds.
   (= 9190 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:          37.5387       0.2136       0.2131       0.2157
Scale:         55.8465       0.1433       0.1432       0.1434
Add:           57.5309       0.2088       0.2086       0.2102
Triad:         57.3762       0.2092       0.2091       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174840 microseconds.
   (= 9202 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:          37.5351       0.2146       0.2131       0.2234
Scale:         55.8486       0.1433       0.1432       0.1434
Add:           57.5218       0.2088       0.2086       0.2102
Triad:         57.3613       0.2092       0.2092       0.2093
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 187116 microseconds.
   (= 9848 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:          37.5381       0.2135       0.2131       0.2164
Scale:         55.8671       0.1433       0.1432       0.1433
Add:           57.5205       0.2088       0.2086       0.2101
Triad:         57.3732       0.2096       0.2092       0.2128
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 175352 microseconds.
   (= 9229 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:          37.5301       0.2139       0.2132       0.2174
Scale:         55.8714       0.1434       0.1432       0.1450
Add:           57.5166       0.2087       0.2086       0.2088
Triad:         57.3625       0.2106       0.2092       0.2228
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 183250 microseconds.
   (= 9644 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:          37.5419       0.2135       0.2131       0.2159
Scale:         55.8771       0.1437       0.1432       0.1483
Add:           57.5389       0.2091       0.2086       0.2119
Triad:         57.3721       0.2095       0.2092       0.2118
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174264 microseconds.
   (= 9171 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:          37.5364       0.2141       0.2131       0.2219
Scale:         55.8914       0.1434       0.1431       0.1447
Add:           57.5469       0.2086       0.2085       0.2086
Triad:         57.3804       0.2093       0.2091       0.2106
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 178715 microseconds.
   (= 9406 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:          37.5385       0.2134       0.2131       0.2151
Scale:         55.8905       0.1432       0.1431       0.1433
Add:           57.5460       0.2086       0.2085       0.2087
Triad:         57.3766       0.2093       0.2091       0.2106
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174122 microseconds.
   (= 9164 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:          37.5370       0.2138       0.2131       0.2166
Scale:         55.8893       0.1442       0.1431       0.1529
Add:           57.5495       0.2111       0.2085       0.2316
Triad:         57.3904       0.2092       0.2091       0.2098
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174376 microseconds.
   (= 9177 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:          37.5598       0.2135       0.2130       0.2159
Scale:         55.8932       0.1432       0.1431       0.1432
Add:           57.5750       0.2085       0.2084       0.2087
Triad:         57.3990       0.2091       0.2091       0.2092
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 197100 microseconds.
   (= 10373 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:          37.5539       0.2134       0.2130       0.2159
Scale:         55.8835       0.1432       0.1432       0.1436
Add:           57.5557       0.2087       0.2085       0.2101
Triad:         57.3899       0.2091       0.2091       0.2092
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 178783 microseconds.
   (= 9409 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:          37.5499       0.2135       0.2131       0.2150
Scale:         55.8307       0.1450       0.1433       0.1593
Add:           57.5375       0.2103       0.2086       0.2247
Triad:         57.3710       0.2094       0.2092       0.2111
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174797 microseconds.
   (= 9199 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:          37.5501       0.2137       0.2130       0.2194
Scale:         55.8701       0.1435       0.1432       0.1447
Add:           57.5495       0.2086       0.2085       0.2088
Triad:         57.3885       0.2091       0.2091       0.2092
-------------------------------------------------------------
This system uses 8 bytes per DOUBLE PRECISION word.
-------------------------------------------------------------
Array size = 500000, Offset = 0
Total memory required = 11.4 MB.
Each test is run 10 times, but only
the *best* time for each is used.
-------------------------------------------------------------
Your clock granularity/precision appears to be 19 microseconds.
Each test below will take on the order of 174214 microseconds.
   (= 9169 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:          37.5338       0.2136       0.2131       0.2169
Scale:         55.8887       0.1436       0.1431       0.1471
Add:           57.5326       0.2086       0.2086       0.2086
Triad:         57.3762       0.2093       0.2091       0.2106