-------------------------------------------------------------
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 3 microseconds.
Each test below will take on the order of 147034 microseconds.
   (= 49011 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:          76.2399       0.2111       0.2099       0.2188
Scale:         88.9239       0.1810       0.1799       0.1889
Add:           93.3867       0.2577       0.2570       0.2611
Triad:         93.4121       0.2572       0.2569       0.2582
-------------------------------------------------------------
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 146916 microseconds.
   (= 73458 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:          76.8565       0.2087       0.2082       0.2101
Scale:         89.6690       0.1786       0.1784       0.1787
Add:           94.1417       0.2576       0.2549       0.2780
Triad:         94.1628       0.2552       0.2549       0.2560
-------------------------------------------------------------
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 146150 microseconds.
   (= 73075 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:          76.8776       0.2090       0.2081       0.2144
Scale:         89.6709       0.1786       0.1784       0.1797
Add:           94.1820       0.2550       0.2548       0.2557
Triad:         94.1832       0.2551       0.2548       0.2557
-------------------------------------------------------------
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 146200 microseconds.
   (= 73100 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:          76.8739       0.2083       0.2081       0.2094
Scale:         89.6970       0.1785       0.1784       0.1786
Add:           94.1764       0.2551       0.2548       0.2558
Triad:         94.1997       0.2550       0.2548       0.2557
-------------------------------------------------------------
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 146357 microseconds.
   (= 73178 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:          76.8703       0.2085       0.2081       0.2096
Scale:         89.6782       0.1787       0.1784       0.1796
Add:           94.1883       0.2552       0.2548       0.2558
Triad:         94.2000       0.2552       0.2548       0.2561
-------------------------------------------------------------
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 146747 microseconds.
   (= 73373 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:          76.8051       0.2090       0.2083       0.2102
Scale:         89.4439       0.1791       0.1789       0.1794
Add:           93.8788       0.2559       0.2556       0.2567
Triad:         93.8865       0.2558       0.2556       0.2561
-------------------------------------------------------------
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 146492 microseconds.
   (= 73246 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:          76.8529       0.2090       0.2082       0.2103
Scale:         89.6310       0.1791       0.1785       0.1807
Add:           94.1752       0.2557       0.2548       0.2568
Triad:         94.1969       0.2556       0.2548       0.2566
-------------------------------------------------------------
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 146219 microseconds.
   (= 73109 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:          76.8752       0.2084       0.2081       0.2094
Scale:         89.6998       0.1786       0.1784       0.1795
Add:           94.1723       0.2551       0.2549       0.2560
Triad:         94.1968       0.2549       0.2548       0.2557
-------------------------------------------------------------
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 146049 microseconds.
   (= 73024 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:          76.8768       0.2083       0.2081       0.2095
Scale:         89.7009       0.1785       0.1784       0.1793
Add:           94.1808       0.2549       0.2548       0.2550
Triad:         94.1990       0.2550       0.2548       0.2559
-------------------------------------------------------------
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 146121 microseconds.
   (= 73060 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:          76.8598       0.2084       0.2082       0.2094
Scale:         89.6659       0.1787       0.1784       0.1794
Add:           94.1446       0.2550       0.2549       0.2552
Triad:         94.1481       0.2552       0.2549       0.2567
-------------------------------------------------------------
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 145624 microseconds.
   (= 72812 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:          76.8680       0.2087       0.2081       0.2097
Scale:         89.7000       0.1789       0.1784       0.1798
Add:           94.1765       0.2555       0.2548       0.2565
Triad:         94.2006       0.2553       0.2548       0.2559
-------------------------------------------------------------
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 148054 microseconds.
   (= 74027 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:          76.6505       0.2090       0.2087       0.2103
Scale:         89.3795       0.1792       0.1790       0.1800
Add:           93.8608       0.2558       0.2557       0.2561
Triad:         93.8652       0.2560       0.2557       0.2568
-------------------------------------------------------------
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 146696 microseconds.
   (= 73348 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:          76.8751       0.2087       0.2081       0.2101
Scale:         89.7036       0.1788       0.1784       0.1792
Add:           94.1588       0.2555       0.2549       0.2565
Triad:         94.1993       0.2570       0.2548       0.2667
-------------------------------------------------------------
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 146005 microseconds.
   (= 73002 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:          76.8543       0.2084       0.2082       0.2095
Scale:         89.6604       0.1786       0.1785       0.1787
Add:           94.1509       0.2551       0.2549       0.2560
Triad:         94.1596       0.2551       0.2549       0.2558
-------------------------------------------------------------
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 146104 microseconds.
   (= 73052 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:          76.8826       0.2085       0.2081       0.2107
Scale:         89.7106       0.1785       0.1784       0.1787
Add:           94.1895       0.2551       0.2548       0.2562
Triad:         94.2014       0.2548       0.2548       0.2550
-------------------------------------------------------------
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 146172 microseconds.
   (= 73086 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:          76.8554       0.2085       0.2082       0.2096
Scale:         89.6698       0.1785       0.1784       0.1787
Add:           94.1462       0.2551       0.2549       0.2559
Triad:         94.1555       0.2550       0.2549       0.2551
-------------------------------------------------------------
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 146085 microseconds.
   (= 73042 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:          76.8482       0.2090       0.2082       0.2099
Scale:         89.6539       0.1790       0.1785       0.1794
Add:           94.1629       0.2558       0.2549       0.2568
Triad:         94.1514       0.2558       0.2549       0.2566
-------------------------------------------------------------
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 146087 microseconds.
   (= 73043 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:          76.6605       0.2093       0.2087       0.2107
Scale:         89.3939       0.1791       0.1790       0.1797
Add:           93.8702       0.2558       0.2557       0.2560
Triad:         93.8512       0.2559       0.2557       0.2566
-------------------------------------------------------------
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 147441 microseconds.
   (= 73720 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:          76.8719       0.2092       0.2081       0.2142
Scale:         89.6691       0.1788       0.1784       0.1793
Add:           94.1554       0.2553       0.2549       0.2562
Triad:         94.1701       0.2560       0.2549       0.2626
-------------------------------------------------------------
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 145957 microseconds.
   (= 72978 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:          76.8731       0.2085       0.2081       0.2098
Scale:         89.6624       0.1786       0.1784       0.1794
Add:           94.1527       0.2551       0.2549       0.2557
Triad:         94.1628       0.2555       0.2549       0.2597
-------------------------------------------------------------
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 145928 microseconds.
   (= 72964 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:          76.8821       0.2085       0.2081       0.2112
Scale:         89.6745       0.1787       0.1784       0.1793
Add:           94.1709       0.2556       0.2549       0.2611
Triad:         94.1520       0.2551       0.2549       0.2560
-------------------------------------------------------------
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 145882 microseconds.
   (= 72941 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:          76.8448       0.2091       0.2082       0.2123
Scale:         89.6387       0.1799       0.1785       0.1837
Add:           94.1070       0.2563       0.2550       0.2594
Triad:         94.1027       0.2561       0.2550       0.2600
-------------------------------------------------------------
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 145971 microseconds.
   (= 72985 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:          76.7355       0.2098       0.2085       0.2134
Scale:         89.3829       0.1798       0.1790       0.1834
Add:           93.8737       0.2559       0.2557       0.2567
Triad:         93.8529       0.2561       0.2557       0.2566
-------------------------------------------------------------
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 147926 microseconds.
   (= 73963 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:          76.6672       0.2104       0.2087       0.2217
Scale:         89.3643       0.1793       0.1790       0.1801
Add:           93.8912       0.2558       0.2556       0.2561
Triad:         93.8613       0.2561       0.2557       0.2569
-------------------------------------------------------------
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 145919 microseconds.
   (= 72959 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:          76.8886       0.2084       0.2081       0.2095
Scale:         89.6950       0.1784       0.1784       0.1786
Add:           94.1633       0.2551       0.2549       0.2558
Triad:         94.1872       0.2549       0.2548       0.2553
-------------------------------------------------------------
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 145913 microseconds.
   (= 72956 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:          76.8676       0.2086       0.2082       0.2099
Scale:         89.6906       0.1786       0.1784       0.1794
Add:           94.1693       0.2550       0.2549       0.2558
Triad:         94.1835       0.2549       0.2548       0.2551
-------------------------------------------------------------
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 145814 microseconds.
   (= 72907 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:          76.8792       0.2085       0.2081       0.2096
Scale:         89.6689       0.1785       0.1784       0.1788
Add:           94.1720       0.2550       0.2549       0.2558
Triad:         94.1572       0.2552       0.2549       0.2558
-------------------------------------------------------------
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 146039 microseconds.
   (= 73019 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:          76.8698       0.2086       0.2081       0.2094
Scale:         89.6914       0.1788       0.1784       0.1797
Add:           94.1627       0.2552       0.2549       0.2570
Triad:         94.1862       0.2551       0.2548       0.2566
-------------------------------------------------------------
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 146604 microseconds.
   (= 73302 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:          76.6671       0.2095       0.2087       0.2129
Scale:         89.3777       0.1791       0.1790       0.1793
Add:           93.8628       0.2559       0.2557       0.2565
Triad:         93.8904       0.2567       0.2556       0.2601
-------------------------------------------------------------
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 145991 microseconds.
   (= 72995 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:          76.8676       0.2090       0.2082       0.2104
Scale:         89.6689       0.1790       0.1784       0.1792
Add:           94.1543       0.2557       0.2549       0.2564
Triad:         94.1733       0.2556       0.2548       0.2561
-------------------------------------------------------------
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 154676 microseconds.
   (= 77338 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:          76.8776       0.2085       0.2081       0.2097
Scale:         89.6747       0.1786       0.1784       0.1794
Add:           94.1654       0.2551       0.2549       0.2559
Triad:         94.1592       0.2560       0.2549       0.2635
-------------------------------------------------------------
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 145983 microseconds.
   (= 72991 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:          76.8741       0.2083       0.2081       0.2094
Scale:         89.6880       0.1785       0.1784       0.1793
Add:           94.1648       0.2550       0.2549       0.2552
Triad:         94.1803       0.2550       0.2548       0.2557
-------------------------------------------------------------
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 146185 microseconds.
   (= 73092 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:          76.8870       0.2083       0.2081       0.2095
Scale:         89.6930       0.1786       0.1784       0.1795
Add:           94.1661       0.2549       0.2549       0.2551
Triad:         94.1790       0.2550       0.2548       0.2558
-------------------------------------------------------------
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 145977 microseconds.
   (= 72988 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:          76.8780       0.2087       0.2081       0.2097
Scale:         89.6638       0.1789       0.1784       0.1796
Add:           94.1644       0.2558       0.2549       0.2568
Triad:         94.1784       0.2555       0.2548       0.2573
-------------------------------------------------------------
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 146639 microseconds.
   (= 73319 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:          76.6706       0.2090       0.2087       0.2100
Scale:         89.3900       0.1791       0.1790       0.1793
Add:           93.8967       0.2559       0.2556       0.2575
Triad:         93.8897       0.2559       0.2556       0.2562
-------------------------------------------------------------
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 147678 microseconds.
   (= 73839 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:          76.8714       0.2087       0.2081       0.2102
Scale:         89.6761       0.1789       0.1784       0.1800
Add:           94.1727       0.2553       0.2549       0.2561
Triad:         94.1680       0.2556       0.2549       0.2566
-------------------------------------------------------------
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 145946 microseconds.
   (= 72973 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:          76.8899       0.2086       0.2081       0.2115
Scale:         89.6815       0.1786       0.1784       0.1789
Add:           94.1813       0.2552       0.2548       0.2569
Triad:         94.1723       0.2554       0.2549       0.2584
-------------------------------------------------------------
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 146064 microseconds.
   (= 73032 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:          76.8833       0.2084       0.2081       0.2094
Scale:         89.6777       0.1785       0.1784       0.1786
Add:           94.1784       0.2551       0.2548       0.2559
Triad:         94.1653       0.2550       0.2549       0.2554
-------------------------------------------------------------
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 146272 microseconds.
   (= 73136 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:          76.8833       0.2085       0.2081       0.2098
Scale:         89.6942       0.1785       0.1784       0.1786
Add:           94.1765       0.2551       0.2548       0.2566
Triad:         94.1757       0.2549       0.2548       0.2550
-------------------------------------------------------------
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 145796 microseconds.
   (= 72898 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:          76.8498       0.2090       0.2082       0.2097
Scale:         89.6628       0.1796       0.1784       0.1856
Add:           94.1737       0.2558       0.2548       0.2569
Triad:         94.0845       0.2559       0.2551       0.2567
-------------------------------------------------------------
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 146783 microseconds.
   (= 73391 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:          76.6739       0.2090       0.2087       0.2105
Scale:         89.4627       0.1792       0.1788       0.1799
Add:           93.8939       0.2570       0.2556       0.2667
Triad:         93.9002       0.2560       0.2556       0.2576
-------------------------------------------------------------
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 146249 microseconds.
   (= 73124 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:          76.8813       0.2086       0.2081       0.2104
Scale:         89.6644       0.1795       0.1784       0.1832
Add:           94.1880       0.2556       0.2548       0.2591
Triad:         94.1833       0.2550       0.2548       0.2558
-------------------------------------------------------------
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 146145 microseconds.
   (= 73072 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:          76.8492       0.2084       0.2082       0.2095
Scale:         89.6415       0.1788       0.1785       0.1796
Add:           94.1153       0.2551       0.2550       0.2553
Triad:         94.1232       0.2553       0.2550       0.2564
-------------------------------------------------------------
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 146050 microseconds.
   (= 73025 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:          76.8501       0.2087       0.2082       0.2118
Scale:         89.6676       0.1789       0.1784       0.1817
Add:           94.1131       0.2551       0.2550       0.2554
Triad:         94.1378       0.2551       0.2549       0.2560
-------------------------------------------------------------
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 147454 microseconds.
   (= 73727 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:          76.8469       0.2084       0.2082       0.2095
Scale:         89.6357       0.1786       0.1785       0.1789
Add:           94.1185       0.2553       0.2550       0.2559
Triad:         94.1168       0.2560       0.2550       0.2635
-------------------------------------------------------------
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 147338 microseconds.
   (= 73669 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:          76.6090       0.2090       0.2089       0.2101
Scale:         89.3572       0.1792       0.1791       0.1794
Add:           94.0019       0.2559       0.2553       0.2567
Triad:         93.8413       0.2560       0.2558       0.2567
-------------------------------------------------------------
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 146561 microseconds.
   (= 73280 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:          76.6046       0.2092       0.2089       0.2107
Scale:         89.3555       0.1792       0.1791       0.1794
Add:           93.8389       0.2560       0.2558       0.2567
Triad:         93.8269       0.2561       0.2558       0.2566
-------------------------------------------------------------
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 147031 microseconds.
   (= 73515 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:          76.8790       0.2084       0.2081       0.2094
Scale:         89.6663       0.1785       0.1784       0.1787
Add:           94.1441       0.2551       0.2549       0.2553
Triad:         94.1676       0.2551       0.2549       0.2563
-------------------------------------------------------------
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 145703 microseconds.
   (= 72851 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:          76.8687       0.2083       0.2081       0.2092
Scale:         89.6807       0.1785       0.1784       0.1786
Add:           94.1437       0.2552       0.2549       0.2566
Triad:         94.1536       0.2550       0.2549       0.2553
-------------------------------------------------------------
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 146475 microseconds.
   (= 73237 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:          76.8668       0.2084       0.2082       0.2094
Scale:         89.6739       0.1787       0.1784       0.1802
Add:           94.1463       0.2551       0.2549       0.2559
Triad:         94.1694       0.2550       0.2549       0.2557
-------------------------------------------------------------
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 145723 microseconds.
   (= 72861 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:          76.8614       0.2090       0.2082       0.2137
Scale:         89.6614       0.1796       0.1784       0.1868
Add:           94.1442       0.2557       0.2549       0.2565
Triad:         94.1494       0.2557       0.2549       0.2580
-------------------------------------------------------------
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 146317 microseconds.
   (= 73158 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:          76.6599       0.2104       0.2087       0.2144
Scale:         89.3687       0.1801       0.1790       0.1834
Add:           93.8533       0.2579       0.2557       0.2619
Triad:         93.8629       0.2571       0.2557       0.2629
-------------------------------------------------------------
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 151310 microseconds.
   (= 75655 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:          76.8742       0.2093       0.2081       0.2130
Scale:         89.6455       0.1789       0.1785       0.1793
Add:           94.1716       0.2565       0.2549       0.2600
Triad:         94.1659       0.2568       0.2549       0.2602
-------------------------------------------------------------
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 145849 microseconds.
   (= 72924 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:          76.8794       0.2084       0.2081       0.2093
Scale:         89.6775       0.1785       0.1784       0.1786
Add:           94.1591       0.2557       0.2549       0.2618
Triad:         94.1560       0.2563       0.2549       0.2599
-------------------------------------------------------------
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 145785 microseconds.
   (= 72892 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:          76.8694       0.2084       0.2081       0.2097
Scale:         89.6646       0.1787       0.1784       0.1795
Add:           94.1559       0.2553       0.2549       0.2566
Triad:         94.1515       0.2551       0.2549       0.2560
-------------------------------------------------------------
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 145693 microseconds.
   (= 72846 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:          76.8848       0.2083       0.2081       0.2096
Scale:         89.6875       0.1786       0.1784       0.1793
Add:           94.1571       0.2549       0.2549       0.2551
Triad:         94.1496       0.2552       0.2549       0.2559
-------------------------------------------------------------
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 145673 microseconds.
   (= 72836 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:          76.8667       0.2096       0.2082       0.2131
Scale:         89.6677       0.1789       0.1784       0.1799
Add:           94.1587       0.2558       0.2549       0.2567
Triad:         94.1146       0.2561       0.2550       0.2585
-------------------------------------------------------------
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 146194 microseconds.
   (= 73097 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:          76.6611       0.2090       0.2087       0.2102
Scale:         89.3969       0.1792       0.1790       0.1799
Add:           93.8696       0.2560       0.2557       0.2575
Triad:         93.8724       0.2561       0.2557       0.2568
-------------------------------------------------------------
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 146011 microseconds.
   (= 73005 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:          76.8799       0.2086       0.2081       0.2099
Scale:         89.6855       0.1789       0.1784       0.1794
Add:           94.1323       0.2581       0.2550       0.2797
Triad:         94.1077       0.2555       0.2550       0.2560
-------------------------------------------------------------
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 147313 microseconds.
   (= 73656 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:          76.8787       0.2085       0.2081       0.2094
Scale:         89.6726       0.1785       0.1784       0.1786
Add:           94.1616       0.2550       0.2549       0.2555
Triad:         94.1674       0.2560       0.2549       0.2639
-------------------------------------------------------------
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 145589 microseconds.
   (= 72794 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:          76.8683       0.2083       0.2081       0.2095
Scale:         89.6918       0.1786       0.1784       0.1799
Add:           94.1501       0.2558       0.2549       0.2617
Triad:         94.1801       0.2551       0.2548       0.2557
-------------------------------------------------------------
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 145447 microseconds.
   (= 72723 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:          76.8674       0.2085       0.2082       0.2095
Scale:         89.6305       0.1786       0.1785       0.1788
Add:           94.1445       0.2551       0.2549       0.2558
Triad:         94.1043       0.2551       0.2550       0.2554
-------------------------------------------------------------
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 145609 microseconds.
   (= 72804 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:          76.8316       0.2091       0.2082       0.2099
Scale:         89.5704       0.1791       0.1786       0.1796
Add:           93.8713       0.2562       0.2557       0.2576
Triad:         94.1140       0.2558       0.2550       0.2565
-------------------------------------------------------------
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 146198 microseconds.
   (= 73099 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:          76.7096       0.2091       0.2086       0.2103
Scale:         89.4345       0.1791       0.1789       0.1792
Add:           93.8348       0.2560       0.2558       0.2563
Triad:         93.8520       0.2560       0.2557       0.2568
-------------------------------------------------------------
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 146064 microseconds.
   (= 73032 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:          76.8753       0.2085       0.2081       0.2104
Scale:         89.6851       0.1786       0.1784       0.1793
Add:           94.1647       0.2551       0.2549       0.2561
Triad:         94.1551       0.2555       0.2549       0.2565
-------------------------------------------------------------
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 145616 microseconds.
   (= 72808 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:          76.8543       0.2085       0.2082       0.2094
Scale:         89.6592       0.1786       0.1785       0.1793
Add:           94.1199       0.2552       0.2550       0.2566
Triad:         94.1361       0.2551       0.2550       0.2560
-------------------------------------------------------------
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 145781 microseconds.
   (= 72890 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:          76.8575       0.2084       0.2082       0.2096
Scale:         89.6491       0.1786       0.1785       0.1794
Add:           94.1286       0.2553       0.2550       0.2565
Triad:         94.1317       0.2551       0.2550       0.2559
-------------------------------------------------------------
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 145554 microseconds.
   (= 72777 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:          76.8641       0.2085       0.2082       0.2095
Scale:         89.6307       0.1787       0.1785       0.1797
Add:           94.1261       0.2565       0.2550       0.2692
Triad:         94.1141       0.2553       0.2550       0.2561
-------------------------------------------------------------
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 146347 microseconds.
   (= 73173 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:          76.6390       0.2092       0.2088       0.2105
Scale:         89.3658       0.1792       0.1790       0.1793
Add:           93.8455       0.2560       0.2557       0.2577
Triad:         93.9688       0.2560       0.2554       0.2566
-------------------------------------------------------------
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 145857 microseconds.
   (= 72928 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:          76.5845       0.2091       0.2089       0.2103
Scale:         89.3688       0.1791       0.1790       0.1793
Add:           93.8374       0.2560       0.2558       0.2567
Triad:         94.0819       0.2560       0.2551       0.2567
-------------------------------------------------------------
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 145406 microseconds.
   (= 72703 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:          76.8616       0.2087       0.2082       0.2105
Scale:         89.6520       0.1791       0.1785       0.1816
Add:           94.1249       0.2559       0.2550       0.2621
Triad:         94.1069       0.2552       0.2550       0.2556
-------------------------------------------------------------
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 145528 microseconds.
   (= 72764 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:          76.8485       0.2085       0.2082       0.2093
Scale:         89.6480       0.1786       0.1785       0.1789
Add:           94.1184       0.2551       0.2550       0.2561
Triad:         94.1164       0.2551       0.2550       0.2554
-------------------------------------------------------------
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 145497 microseconds.
   (= 72748 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:          76.8671       0.2083       0.2082       0.2095
Scale:         89.6857       0.1785       0.1784       0.1789
Add:           94.1393       0.2552       0.2549       0.2562
Triad:         94.1559       0.2550       0.2549       0.2552
-------------------------------------------------------------
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 145874 microseconds.
   (= 72937 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:          76.8530       0.2087       0.2082       0.2095
Scale:         89.6472       0.1790       0.1785       0.1801
Add:           94.1495       0.2555       0.2549       0.2567
Triad:         94.1430       0.2554       0.2549       0.2565
-------------------------------------------------------------
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 146126 microseconds.
   (= 73063 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:          76.6440       0.2091       0.2088       0.2103
Scale:         89.3699       0.1792       0.1790       0.1800
Add:           93.8192       0.2561       0.2558       0.2570
Triad:         93.8346       0.2561       0.2558       0.2567
-------------------------------------------------------------
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 146087 microseconds.
   (= 73043 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:          76.8431       0.2089       0.2082       0.2100
Scale:         89.6307       0.1789       0.1785       0.1793
Add:           94.1215       0.2561       0.2550       0.2607
Triad:         94.1118       0.2567       0.2550       0.2602
-------------------------------------------------------------
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 145862 microseconds.
   (= 72931 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:          76.8378       0.2092       0.2082       0.2147
Scale:         89.6167       0.1788       0.1785       0.1795
Add:           94.0730       0.2552       0.2551       0.2554
Triad:         94.0550       0.2556       0.2552       0.2570
-------------------------------------------------------------
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 145592 microseconds.
   (= 72796 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:          76.8271       0.2084       0.2083       0.2095
Scale:         89.6114       0.1788       0.1785       0.1794
Add:           94.0678       0.2552       0.2551       0.2555
Triad:         94.0797       0.2552       0.2551       0.2560
-------------------------------------------------------------
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 145386 microseconds.
   (= 72693 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:          76.8352       0.2085       0.2082       0.2096
Scale:         89.5972       0.1787       0.1786       0.1795
Add:           94.0767       0.2570       0.2551       0.2595
Triad:         94.0710       0.2555       0.2551       0.2570
-------------------------------------------------------------
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 145320 microseconds.
   (= 72660 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:          76.8501       0.2089       0.2082       0.2096
Scale:         89.6567       0.1791       0.1785       0.1797
Add:           94.1030       0.2558       0.2550       0.2562
Triad:         94.1330       0.2558       0.2550       0.2569
-------------------------------------------------------------
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 146213 microseconds.
   (= 73106 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:          76.6316       0.2091       0.2088       0.2103
Scale:         89.3705       0.1792       0.1790       0.1794
Add:           93.8136       0.2562       0.2558       0.2570
Triad:         93.8984       0.2559       0.2556       0.2569
-------------------------------------------------------------
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 146519 microseconds.
   (= 73259 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:          76.8454       0.2101       0.2082       0.2137
Scale:         89.6542       0.1796       0.1785       0.1828
Add:           94.0956       0.2563       0.2551       0.2593
Triad:         94.1246       0.2561       0.2550       0.2593
-------------------------------------------------------------
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 145657 microseconds.
   (= 72828 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:          76.8420       0.2086       0.2082       0.2098
Scale:         89.6147       0.1798       0.1785       0.1851
Add:           94.0605       0.2555       0.2552       0.2566
Triad:         94.0632       0.2561       0.2551       0.2594
-------------------------------------------------------------
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 145905 microseconds.
   (= 72952 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:          76.8260       0.2085       0.2083       0.2093
Scale:         89.6029       0.1786       0.1786       0.1788
Add:           94.0612       0.2553       0.2552       0.2559
Triad:         94.0625       0.2553       0.2551       0.2559
-------------------------------------------------------------
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 146755 microseconds.
   (= 73377 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:          76.8271       0.2087       0.2083       0.2100
Scale:         89.6176       0.1786       0.1785       0.1790
Add:           94.0605       0.2562       0.2552       0.2597
Triad:         94.0695       0.2557       0.2551       0.2593
-------------------------------------------------------------
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 146174 microseconds.
   (= 73087 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:          76.6134       0.2092       0.2088       0.2101
Scale:         89.3392       0.1793       0.1791       0.1798
Add:           93.7569       0.2564       0.2560       0.2570
Triad:         93.7524       0.2562       0.2560       0.2568
-------------------------------------------------------------
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 146293 microseconds.
   (= 73146 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:          76.6316       0.2092       0.2088       0.2103
Scale:         89.3009       0.1794       0.1792       0.1799
Add:           93.7745       0.2561       0.2559       0.2568
Triad:         93.7627       0.2562       0.2560       0.2565