-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 42884 microseconds.
   (= 42884 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:         297.7799       0.0545       0.0537       0.0550
Scale:        297.5914       0.0542       0.0538       0.0551
Add:          377.0856       0.0640       0.0636       0.0652
Triad:        324.1533       0.0750       0.0740       0.0831
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45064 microseconds.
   (= 45064 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:         297.1666       0.0544       0.0538       0.0551
Scale:        297.7714       0.0546       0.0537       0.0559
Add:          377.9095       0.0637       0.0635       0.0647
Triad:        324.8811       0.0739       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45053 microseconds.
   (= 45053 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:         299.0340       0.0546       0.0535       0.0558
Scale:        298.2294       0.0657       0.0536       0.1297
Add:          378.1459       0.0635       0.0635       0.0636
Triad:        324.6779       0.0742       0.0739       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45165 microseconds.
   (= 45165 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:         296.9932       0.0544       0.0539       0.0551
Scale:        297.8054       0.0545       0.0537       0.0550
Add:          377.9070       0.0636       0.0635       0.0637
Triad:        324.9256       0.0747       0.0739       0.0793
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45011 microseconds.
   (= 45011 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:         298.8202       0.0538       0.0535       0.0548
Scale:        298.2174       0.0543       0.0537       0.0550
Add:          378.4015       0.0639       0.0634       0.0646
Triad:        325.2128       0.0741       0.0738       0.0748
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45076 microseconds.
   (= 45076 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:         298.9660       0.0539       0.0535       0.0541
Scale:        297.7938       0.0544       0.0537       0.0557
Add:          377.6696       0.0644       0.0635       0.0655
Triad:        324.9818       0.0740       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 47011 microseconds.
   (= 47011 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:         299.0871       0.0537       0.0535       0.0538
Scale:        298.2813       0.0539       0.0536       0.0550
Add:          378.3886       0.0642       0.0634       0.0654
Triad:        325.0379       0.0744       0.0738       0.0754
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45029 microseconds.
   (= 45029 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:         298.0164       0.0539       0.0537       0.0540
Scale:        297.7679       0.0541       0.0537       0.0551
Add:          378.3802       0.0639       0.0634       0.0646
Triad:        324.6506       0.0754       0.0739       0.0820
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44872 microseconds.
   (= 44872 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:         298.7530       0.0540       0.0536       0.0549
Scale:        298.1434       0.0540       0.0537       0.0551
Add:          378.9276       0.0636       0.0633       0.0645
Triad:        325.0415       0.0745       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45105 microseconds.
   (= 45105 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:         298.4317       0.0547       0.0536       0.0560
Scale:        297.6496       0.0538       0.0538       0.0540
Add:          377.8689       0.0638       0.0635       0.0662
Triad:        324.8212       0.0744       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44988 microseconds.
   (= 44988 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:         299.0134       0.0545       0.0535       0.0561
Scale:        298.0995       0.0541       0.0537       0.0549
Add:          378.1274       0.0635       0.0635       0.0636
Triad:        324.8983       0.0740       0.0739       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45024 microseconds.
   (= 45024 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:         298.0883       0.0545       0.0537       0.0551
Scale:        297.4499       0.0544       0.0538       0.0549
Add:          377.7761       0.0636       0.0635       0.0638
Triad:        324.9450       0.0740       0.0739       0.0747
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45018 microseconds.
   (= 45018 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:         298.6286       0.0539       0.0536       0.0547
Scale:        298.1747       0.0542       0.0537       0.0549
Add:          378.3578       0.0639       0.0634       0.0645
Triad:        325.0617       0.0744       0.0738       0.0766
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45152 microseconds.
   (= 45152 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:         298.7424       0.0539       0.0536       0.0540
Scale:        297.6472       0.0544       0.0538       0.0554
Add:          377.8184       0.0643       0.0635       0.0646
Triad:        325.0967       0.0741       0.0738       0.0748
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46045 microseconds.
   (= 46045 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:         299.1705       0.0537       0.0535       0.0540
Scale:        298.2587       0.0545       0.0536       0.0602
Add:          378.2070       0.0643       0.0635       0.0654
Triad:        324.9684       0.0742       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46029 microseconds.
   (= 46029 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:         297.6274       0.0539       0.0538       0.0540
Scale:        297.9264       0.0538       0.0537       0.0539
Add:          378.1126       0.0642       0.0635       0.0655
Triad:        324.8686       0.0745       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45049 microseconds.
   (= 45049 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:         299.7937       0.0538       0.0534       0.0548
Scale:        298.3828       0.0540       0.0536       0.0553
Add:          378.9988       0.0637       0.0633       0.0644
Triad:        325.0357       0.0750       0.0738       0.0793
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45065 microseconds.
   (= 45065 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:         298.1531       0.0545       0.0537       0.0552
Scale:        297.5845       0.0542       0.0538       0.0553
Add:          378.6800       0.0635       0.0634       0.0636
Triad:        324.9787       0.0743       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45032 microseconds.
   (= 45032 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:         298.9503       0.0545       0.0535       0.0558
Scale:        298.0318       0.0540       0.0537       0.0549
Add:          378.2633       0.0641       0.0634       0.0696
Triad:        325.0412       0.0741       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45016 microseconds.
   (= 45016 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:         296.8685       0.0547       0.0539       0.0561
Scale:        297.4926       0.0548       0.0538       0.0585
Add:          377.8745       0.0636       0.0635       0.0636
Triad:        324.9748       0.0740       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44978 microseconds.
   (= 44978 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:         298.6974       0.0541       0.0536       0.0550
Scale:        298.1160       0.0544       0.0537       0.0554
Add:          378.0743       0.0638       0.0635       0.0646
Triad:        324.6758       0.0741       0.0739       0.0747
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45062 microseconds.
   (= 45062 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:         297.9726       0.0540       0.0537       0.0543
Scale:        297.5557       0.0543       0.0538       0.0549
Add:          377.5508       0.0642       0.0636       0.0647
Triad:        324.9097       0.0746       0.0739       0.0776
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46045 microseconds.
   (= 46045 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:         299.0498       0.0537       0.0535       0.0538
Scale:        298.0531       0.0539       0.0537       0.0548
Add:          378.5128       0.0642       0.0634       0.0654
Triad:        325.1883       0.0744       0.0738       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45034 microseconds.
   (= 45034 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:         297.8085       0.0539       0.0537       0.0540
Scale:        297.7677       0.0546       0.0537       0.0611
Add:          377.9937       0.0642       0.0635       0.0656
Triad:        324.8816       0.0745       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46190 microseconds.
   (= 46190 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:         299.2140       0.0537       0.0535       0.0548
Scale:        298.2750       0.0537       0.0536       0.0538
Add:          378.1845       0.0638       0.0635       0.0645
Triad:        325.1255       0.0746       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45014 microseconds.
   (= 45014 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:         298.5421       0.0543       0.0536       0.0551
Scale:        297.6001       0.0541       0.0538       0.0553
Add:          378.5236       0.0636       0.0634       0.0645
Triad:        325.0294       0.0749       0.0738       0.0794
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44873 microseconds.
   (= 44873 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:         298.8448       0.0543       0.0535       0.0549
Scale:        298.2299       0.0544       0.0536       0.0565
Add:          378.5579       0.0635       0.0634       0.0635
Triad:        324.9472       0.0741       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 51243 microseconds.
   (= 51243 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:         297.2211       0.0547       0.0538       0.0563
Scale:        297.7127       0.0544       0.0537       0.0550
Add:          377.9149       0.0636       0.0635       0.0636
Triad:        324.8460       0.0739       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45001 microseconds.
   (= 45001 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:         298.6746       0.0541       0.0536       0.0551
Scale:        298.0273       0.0548       0.0537       0.0583
Add:          378.3150       0.0638       0.0634       0.0645
Triad:        325.0743       0.0739       0.0738       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45016 microseconds.
   (= 45016 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:         298.0619       0.0540       0.0537       0.0550
Scale:        297.6192       0.0543       0.0538       0.0550
Add:          377.3235       0.0642       0.0636       0.0646
Triad:        324.8845       0.0740       0.0739       0.0748
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46066 microseconds.
   (= 46066 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:         298.9169       0.0537       0.0535       0.0538
Scale:        297.9673       0.0539       0.0537       0.0549
Add:          378.1215       0.0642       0.0635       0.0648
Triad:        325.1184       0.0751       0.0738       0.0801
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46064 microseconds.
   (= 46064 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:         298.0778       0.0538       0.0537       0.0540
Scale:        297.6356       0.0539       0.0538       0.0545
Add:          377.8489       0.0641       0.0635       0.0654
Triad:        324.9595       0.0747       0.0739       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44986 microseconds.
   (= 44986 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:         299.2441       0.0539       0.0535       0.0548
Scale:        298.2882       0.0543       0.0536       0.0588
Add:          378.4379       0.0638       0.0634       0.0644
Triad:        325.0933       0.0746       0.0738       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46021 microseconds.
   (= 46021 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:         298.7331       0.0543       0.0536       0.0551
Scale:        297.8446       0.0538       0.0537       0.0539
Add:          377.8247       0.0637       0.0635       0.0645
Triad:        324.9496       0.0745       0.0739       0.0751
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45010 microseconds.
   (= 45010 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:         298.8271       0.0541       0.0535       0.0548
Scale:        298.3042       0.0543       0.0536       0.0555
Add:          379.2875       0.0635       0.0633       0.0643
Triad:        324.9298       0.0748       0.0739       0.0802
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44920 microseconds.
   (= 44920 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:         296.8343       0.0545       0.0539       0.0559
Scale:        297.5537       0.0547       0.0538       0.0564
Add:          378.1624       0.0635       0.0635       0.0637
Triad:        324.8570       0.0744       0.0739       0.0783
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44970 microseconds.
   (= 44970 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:         298.8047       0.0542       0.0535       0.0561
Scale:        298.0658       0.0543       0.0537       0.0550
Add:          378.3406       0.0637       0.0634       0.0647
Triad:        325.1832       0.0739       0.0738       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45022 microseconds.
   (= 45022 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:         298.3642       0.0541       0.0536       0.0552
Scale:        297.7914       0.0549       0.0537       0.0601
Add:          377.6020       0.0642       0.0636       0.0646
Triad:        324.9734       0.0740       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46099 microseconds.
   (= 46099 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:         298.8246       0.0538       0.0535       0.0548
Scale:        297.9737       0.0540       0.0537       0.0550
Add:          378.2826       0.0641       0.0634       0.0646
Triad:        325.1216       0.0742       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46102 microseconds.
   (= 46102 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:         298.0692       0.0539       0.0537       0.0542
Scale:        297.9137       0.0538       0.0537       0.0538
Add:          377.8545       0.0640       0.0635       0.0647
Triad:        324.8290       0.0752       0.0739       0.0794
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44990 microseconds.
   (= 44990 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:         298.8456       0.0537       0.0535       0.0546
Scale:        298.0327       0.0538       0.0537       0.0547
Add:          378.2444       0.0638       0.0635       0.0653
Triad:        324.9894       0.0747       0.0738       0.0758
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45067 microseconds.
   (= 45067 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:         299.1101       0.0542       0.0535       0.0551
Scale:        297.8656       0.0546       0.0537       0.0613
Add:          377.9823       0.0638       0.0635       0.0645
Triad:        324.9234       0.0746       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46006 microseconds.
   (= 46006 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:         298.8754       0.0542       0.0535       0.0550
Scale:        298.2409       0.0539       0.0536       0.0549
Add:          378.3787       0.0637       0.0634       0.0645
Triad:        324.9883       0.0742       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45055 microseconds.
   (= 45055 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:         298.5129       0.0544       0.0536       0.0550
Scale:        297.4769       0.0546       0.0538       0.0551
Add:          378.3776       0.0636       0.0634       0.0644
Triad:        324.8150       0.0739       0.0739       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45017 microseconds.
   (= 45017 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:         299.1238       0.0542       0.0535       0.0559
Scale:        297.9532       0.0546       0.0537       0.0566
Add:          378.4923       0.0637       0.0634       0.0645
Triad:        324.9491       0.0747       0.0739       0.0809
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45065 microseconds.
   (= 45065 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:         298.4121       0.0541       0.0536       0.0551
Scale:        297.7431       0.0544       0.0537       0.0552
Add:          377.6579       0.0641       0.0635       0.0646
Triad:        324.9146       0.0740       0.0739       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44981 microseconds.
   (= 44981 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:         299.2436       0.0541       0.0535       0.0574
Scale:        298.1842       0.0541       0.0537       0.0550
Add:          378.3624       0.0641       0.0634       0.0646
Triad:        325.0799       0.0741       0.0738       0.0751
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46186 microseconds.
   (= 46186 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:         299.0590       0.0538       0.0535       0.0539
Scale:        297.5402       0.0538       0.0538       0.0540
Add:          377.5461       0.0642       0.0636       0.0647
Triad:        324.9691       0.0745       0.0739       0.0758
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45056 microseconds.
   (= 45056 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:         298.8191       0.0536       0.0535       0.0538
Scale:        298.2724       0.0538       0.0536       0.0540
Add:          378.5259       0.0638       0.0634       0.0645
Triad:        325.0444       0.0758       0.0738       0.0837
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45056 microseconds.
   (= 45056 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:         297.7399       0.0541       0.0537       0.0549
Scale:        297.9186       0.0539       0.0537       0.0544
Add:          377.8655       0.0637       0.0635       0.0645
Triad:        324.8871       0.0747       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44884 microseconds.
   (= 44884 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:         298.6187       0.0541       0.0536       0.0550
Scale:        298.1531       0.0542       0.0537       0.0583
Add:          378.1910       0.0637       0.0635       0.0644
Triad:        324.9906       0.0744       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46136 microseconds.
   (= 46136 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:         298.3160       0.0544       0.0536       0.0551
Scale:        297.7171       0.0542       0.0537       0.0550
Add:          378.3502       0.0636       0.0634       0.0645
Triad:        324.8493       0.0741       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45098 microseconds.
   (= 45098 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:         298.7647       0.0543       0.0536       0.0556
Scale:        298.4679       0.0546       0.0536       0.0560
Add:          378.9959       0.0635       0.0633       0.0636
Triad:        325.0364       0.0739       0.0738       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45039 microseconds.
   (= 45039 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:         297.2838       0.0542       0.0538       0.0564
Scale:        297.0903       0.0548       0.0539       0.0565
Add:          378.1294       0.0646       0.0635       0.0710
Triad:        325.0263       0.0745       0.0738       0.0792
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44974 microseconds.
   (= 44974 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:         298.4508       0.0539       0.0536       0.0551
Scale:        298.0394       0.0544       0.0537       0.0552
Add:          378.4539       0.0641       0.0634       0.0647
Triad:        324.9818       0.0739       0.0739       0.0742
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46097 microseconds.
   (= 46097 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:         298.0719       0.0543       0.0537       0.0571
Scale:        297.5140       0.0540       0.0538       0.0549
Add:          377.5285       0.0642       0.0636       0.0647
Triad:        324.8651       0.0743       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45925 microseconds.
   (= 45925 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:         298.9066       0.0537       0.0535       0.0538
Scale:        298.1395       0.0537       0.0537       0.0538
Add:          378.3629       0.0640       0.0634       0.0646
Triad:        324.6469       0.0746       0.0739       0.0758
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44925 microseconds.
   (= 44925 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:         298.1250       0.0539       0.0537       0.0541
Scale:        297.7014       0.0538       0.0537       0.0539
Add:          377.7899       0.0656       0.0635       0.0794
Triad:        324.8577       0.0749       0.0739       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44950 microseconds.
   (= 44950 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:         298.8634       0.0541       0.0535       0.0548
Scale:        298.3232       0.0537       0.0536       0.0538
Add:          378.1047       0.0637       0.0635       0.0644
Triad:        324.8560       0.0746       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45035 microseconds.
   (= 45035 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:         297.1130       0.0549       0.0539       0.0573
Scale:        297.5324       0.0540       0.0538       0.0549
Add:          378.5067       0.0637       0.0634       0.0645
Triad:        325.0175       0.0743       0.0738       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44973 microseconds.
   (= 44973 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:         298.4886       0.0552       0.0536       0.0627
Scale:        297.8450       0.0544       0.0537       0.0559
Add:          378.6809       0.0636       0.0634       0.0642
Triad:        326.1365       0.0740       0.0736       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45024 microseconds.
   (= 45024 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:         297.1177       0.0548       0.0539       0.0560
Scale:        297.5583       0.0546       0.0538       0.0564
Add:          377.7540       0.0636       0.0635       0.0637
Triad:        324.8630       0.0739       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44854 microseconds.
   (= 44854 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:         298.9913       0.0543       0.0535       0.0561
Scale:        298.5039       0.0542       0.0536       0.0549
Add:          378.3554       0.0642       0.0634       0.0671
Triad:        325.0845       0.0739       0.0738       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45091 microseconds.
   (= 45091 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:         298.5958       0.0540       0.0536       0.0551
Scale:        297.5820       0.0543       0.0538       0.0550
Add:          377.5908       0.0641       0.0636       0.0646
Triad:        324.9270       0.0741       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46017 microseconds.
   (= 46017 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:         299.0698       0.0546       0.0535       0.0627
Scale:        297.9701       0.0539       0.0537       0.0549
Add:          377.9935       0.0641       0.0635       0.0645
Triad:        324.6366       0.0744       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46116 microseconds.
   (= 46116 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:         297.3666       0.0539       0.0538       0.0541
Scale:        297.8596       0.0538       0.0537       0.0539
Add:          377.6269       0.0640       0.0636       0.0647
Triad:        324.8377       0.0747       0.0739       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45006 microseconds.
   (= 45006 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:         298.6338       0.0538       0.0536       0.0549
Scale:        297.9121       0.0538       0.0537       0.0541
Add:          378.1341       0.0643       0.0635       0.0680
Triad:        324.9112       0.0747       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45045 microseconds.
   (= 45045 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:         297.1346       0.0546       0.0538       0.0554
Scale:        297.5273       0.0539       0.0538       0.0539
Add:          377.5829       0.0639       0.0636       0.0645
Triad:        325.0561       0.0744       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44985 microseconds.
   (= 44985 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:         298.9588       0.0543       0.0535       0.0551
Scale:        297.7574       0.0541       0.0537       0.0552
Add:          378.8730       0.0635       0.0633       0.0636
Triad:        324.8649       0.0742       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45105 microseconds.
   (= 45105 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:         298.5003       0.0544       0.0536       0.0552
Scale:        297.4762       0.0546       0.0538       0.0564
Add:          377.8105       0.0636       0.0635       0.0636
Triad:        324.8674       0.0742       0.0739       0.0765
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45004 microseconds.
   (= 45004 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:         298.7724       0.0543       0.0536       0.0564
Scale:        298.2246       0.0545       0.0537       0.0555
Add:          378.1316       0.0637       0.0635       0.0645
Triad:        324.9357       0.0739       0.0739       0.0740
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45025 microseconds.
   (= 45025 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:         298.7110       0.0541       0.0536       0.0551
Scale:        297.5937       0.0544       0.0538       0.0553
Add:          377.6252       0.0648       0.0636       0.0717
Triad:        324.6234       0.0741       0.0739       0.0749
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44984 microseconds.
   (= 44984 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:         298.2197       0.0537       0.0537       0.0538
Scale:        298.1022       0.0540       0.0537       0.0549
Add:          378.0313       0.0641       0.0635       0.0646
Triad:        324.9332       0.0743       0.0739       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46225 microseconds.
   (= 46225 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:         298.2955       0.0539       0.0536       0.0542
Scale:        297.6674       0.0538       0.0538       0.0539
Add:          377.3976       0.0643       0.0636       0.0647
Triad:        324.8464       0.0751       0.0739       0.0801
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44962 microseconds.
   (= 44962 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:         299.3749       0.0537       0.0534       0.0540
Scale:        298.1067       0.0538       0.0537       0.0538
Add:          378.2577       0.0638       0.0634       0.0646
Triad:        324.8028       0.0747       0.0739       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45078 microseconds.
   (= 45078 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:         298.1706       0.0541       0.0537       0.0551
Scale:        297.9387       0.0539       0.0537       0.0547
Add:          377.7033       0.0647       0.0635       0.0722
Triad:        324.8198       0.0747       0.0739       0.0751
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45002 microseconds.
   (= 45002 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:         298.9177       0.0541       0.0535       0.0550
Scale:        298.1658       0.0544       0.0537       0.0585
Add:          378.8725       0.0637       0.0633       0.0644
Triad:        325.0616       0.0743       0.0738       0.0750
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44927 microseconds.
   (= 44927 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:         298.3944       0.0545       0.0536       0.0553
Scale:        297.6039       0.0544       0.0538       0.0552
Add:          378.1519       0.0636       0.0635       0.0636
Triad:        324.9169       0.0740       0.0739       0.0751
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 44962 microseconds.
   (= 44962 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:         298.7113       0.0542       0.0536       0.0559
Scale:        297.9064       0.0545       0.0537       0.0562
Add:          378.0914       0.0636       0.0635       0.0645
Triad:        324.6892       0.0747       0.0739       0.0810
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45041 microseconds.
   (= 45041 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:         297.3333       0.0544       0.0538       0.0563
Scale:        297.6157       0.0545       0.0538       0.0550
Add:          377.5609       0.0639       0.0636       0.0647
Triad:        324.8960       0.0740       0.0739       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45056 microseconds.
   (= 45056 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:         298.5545       0.0540       0.0536       0.0550
Scale:        297.7957       0.0547       0.0537       0.0592
Add:          378.2265       0.0642       0.0635       0.0646
Triad:        325.0333       0.0741       0.0738       0.0748
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46153 microseconds.
   (= 46153 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:         298.9419       0.0539       0.0535       0.0542
Scale:        297.6580       0.0539       0.0538       0.0549
Add:          377.4249       0.0643       0.0636       0.0648
Triad:        324.9021       0.0745       0.0739       0.0759
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 46280 microseconds.
   (= 46280 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:         298.6820       0.0537       0.0536       0.0538
Scale:        298.3329       0.0537       0.0536       0.0539
Add:          378.2645       0.0640       0.0634       0.0654
Triad:        324.6932       0.0754       0.0739       0.0819
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45072 microseconds.
   (= 45072 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:         298.5664       0.0540       0.0536       0.0551
Scale:        297.5414       0.0539       0.0538       0.0543
Add:          377.8430       0.0638       0.0635       0.0646
Triad:        324.8033       0.0748       0.0739       0.0758
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 47891 microseconds.
   (= 47891 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:         298.6354       0.0542       0.0536       0.0549
Scale:        298.2599       0.0539       0.0536       0.0547
Add:          378.7214       0.0637       0.0634       0.0644
Triad:        324.9099       0.0745       0.0739       0.0752
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45096 microseconds.
   (= 45096 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:         298.6769       0.0545       0.0536       0.0554
Scale:        297.3378       0.0552       0.0538       0.0640
Add:          378.5620       0.0637       0.0634       0.0645
Triad:        324.5589       0.0742       0.0739       0.0751
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45114 microseconds.
   (= 45114 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:         298.6161       0.0543       0.0536       0.0550
Scale:        297.6864       0.0545       0.0537       0.0564
Add:          378.4459       0.0635       0.0634       0.0636
Triad:        324.9796       0.0740       0.0739       0.0741
-------------------------------------------------------------
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 1 microseconds.
Each test below will take on the order of 45185 microseconds.
   (= 45185 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:         297.6434       0.0544       0.0538       0.0552
Scale:        297.5764       0.0544       0.0538       0.0551
Add:          378.0359       0.0638       0.0635       0.0646
Triad:        325.0643       0.0743       0.0738       0.0775