-------------------------------------------------------------
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 4 microseconds.
Each test below will take on the order of 42234 microseconds.
   (= 10558 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8764       0.0555       0.0554       0.0561
Scale:        291.0574       0.0550       0.0550       0.0550
Add:          346.0257       0.0695       0.0694       0.0709
Triad:        296.8719       0.0809       0.0808       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 42090 microseconds.
   (= 42090 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5354       0.0555       0.0555       0.0561
Scale:        290.3145       0.0551       0.0551       0.0552
Add:          345.4603       0.0698       0.0695       0.0730
Triad:        303.6035       0.0791       0.0791       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 42365 microseconds.
   (= 42365 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.2205       0.0556       0.0555       0.0563
Scale:        290.2247       0.0552       0.0551       0.0552
Add:          345.5475       0.0695       0.0695       0.0695
Triad:        303.9291       0.0790       0.0790       0.0790
-------------------------------------------------------------
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 42051 microseconds.
   (= 42051 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.3397       0.0557       0.0555       0.0569
Scale:        290.2094       0.0552       0.0551       0.0552
Add:          345.6211       0.0695       0.0694       0.0695
Triad:        304.1868       0.0789       0.0789       0.0790
-------------------------------------------------------------
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 42268 microseconds.
   (= 42268 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.2332       0.0556       0.0555       0.0562
Scale:        290.3959       0.0551       0.0551       0.0551
Add:          345.7182       0.0694       0.0694       0.0695
Triad:        304.3350       0.0789       0.0789       0.0791
-------------------------------------------------------------
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 42040 microseconds.
   (= 42040 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.3670       0.0556       0.0555       0.0562
Scale:        290.2668       0.0551       0.0551       0.0552
Add:          345.5594       0.0696       0.0695       0.0711
Triad:        304.1576       0.0789       0.0789       0.0790
-------------------------------------------------------------
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 42283 microseconds.
   (= 42283 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5094       0.0556       0.0555       0.0562
Scale:        290.5610       0.0551       0.0551       0.0551
Add:          346.0272       0.0694       0.0694       0.0694
Triad:        304.7160       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42113 microseconds.
   (= 42113 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.3814       0.0556       0.0555       0.0562
Scale:        290.3654       0.0551       0.0551       0.0551
Add:          345.9203       0.0694       0.0694       0.0694
Triad:        304.3581       0.0789       0.0789       0.0789
-------------------------------------------------------------
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 42329 microseconds.
   (= 42329 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5024       0.0557       0.0555       0.0571
Scale:        290.1353       0.0552       0.0551       0.0552
Add:          345.8885       0.0694       0.0694       0.0694
Triad:        304.2985       0.0789       0.0789       0.0790
-------------------------------------------------------------
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 42095 microseconds.
   (= 42095 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.2488       0.0556       0.0555       0.0562
Scale:        290.2259       0.0551       0.0551       0.0552
Add:          345.7811       0.0694       0.0694       0.0694
Triad:        304.7102       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42300 microseconds.
   (= 42300 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7727       0.0555       0.0554       0.0562
Scale:        290.5501       0.0551       0.0551       0.0551
Add:          345.9372       0.0695       0.0694       0.0709
Triad:        304.2242       0.0789       0.0789       0.0790
-------------------------------------------------------------
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 42138 microseconds.
   (= 42138 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5584       0.0555       0.0554       0.0562
Scale:        290.4808       0.0551       0.0551       0.0551
Add:          346.3095       0.0693       0.0693       0.0694
Triad:        304.8106       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42305 microseconds.
   (= 42305 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8030       0.0555       0.0554       0.0561
Scale:        290.3245       0.0553       0.0551       0.0567
Add:          345.9799       0.0694       0.0694       0.0694
Triad:        304.5488       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42155 microseconds.
   (= 42155 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.4623       0.0556       0.0555       0.0562
Scale:        290.3781       0.0553       0.0551       0.0565
Add:          346.1007       0.0694       0.0693       0.0694
Triad:        304.4472       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42315 microseconds.
   (= 42315 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.3549       0.0556       0.0555       0.0562
Scale:        290.2944       0.0551       0.0551       0.0552
Add:          346.0550       0.0694       0.0694       0.0694
Triad:        304.2358       0.0789       0.0789       0.0791
-------------------------------------------------------------
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 42085 microseconds.
   (= 42085 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5406       0.0556       0.0555       0.0562
Scale:        290.5018       0.0551       0.0551       0.0551
Add:          346.0122       0.0694       0.0694       0.0694
Triad:        304.5837       0.0790       0.0788       0.0805
-------------------------------------------------------------
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 42311 microseconds.
   (= 42311 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7986       0.0555       0.0554       0.0562
Scale:        290.6242       0.0551       0.0551       0.0551
Add:          346.1290       0.0694       0.0693       0.0694
Triad:        304.5153       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42055 microseconds.
   (= 42055 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6650       0.0555       0.0554       0.0562
Scale:        290.4945       0.0552       0.0551       0.0565
Add:          346.3334       0.0693       0.0693       0.0693
Triad:        304.6703       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42311 microseconds.
   (= 42311 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6682       0.0555       0.0554       0.0562
Scale:        290.4322       0.0553       0.0551       0.0567
Add:          346.0978       0.0694       0.0693       0.0694
Triad:        304.5601       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42049 microseconds.
   (= 42049 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6605       0.0555       0.0554       0.0562
Scale:        290.6223       0.0551       0.0551       0.0551
Add:          346.0179       0.0694       0.0694       0.0694
Triad:        304.6611       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42254 microseconds.
   (= 42254 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7604       0.0555       0.0554       0.0561
Scale:        290.4157       0.0551       0.0551       0.0551
Add:          345.8878       0.0694       0.0694       0.0694
Triad:        304.3260       0.0791       0.0789       0.0804
-------------------------------------------------------------
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 42083 microseconds.
   (= 42083 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0690       0.0554       0.0554       0.0561
Scale:        290.6626       0.0551       0.0550       0.0551
Add:          346.0308       0.0694       0.0694       0.0694
Triad:        304.5880       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42257 microseconds.
   (= 42257 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8544       0.0555       0.0554       0.0561
Scale:        290.5430       0.0551       0.0551       0.0551
Add:          346.0425       0.0695       0.0694       0.0710
Triad:        304.3130       0.0789       0.0789       0.0790
-------------------------------------------------------------
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 42038 microseconds.
   (= 42038 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8193       0.0555       0.0554       0.0562
Scale:        290.6153       0.0551       0.0551       0.0551
Add:          346.1242       0.0694       0.0693       0.0694
Triad:        304.4873       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42243 microseconds.
   (= 42243 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7959       0.0555       0.0554       0.0561
Scale:        290.6070       0.0551       0.0551       0.0551
Add:          346.0583       0.0694       0.0694       0.0694
Triad:        304.6894       0.0788       0.0788       0.0790
-------------------------------------------------------------
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 42045 microseconds.
   (= 42045 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7828       0.0556       0.0554       0.0570
Scale:        290.6258       0.0551       0.0551       0.0551
Add:          346.0891       0.0694       0.0693       0.0694
Triad:        304.6256       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42092 microseconds.
   (= 42092 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7061       0.0555       0.0554       0.0561
Scale:        290.6563       0.0551       0.0550       0.0551
Add:          346.1242       0.0694       0.0693       0.0694
Triad:        304.6539       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42044 microseconds.
   (= 42044 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8947       0.0555       0.0554       0.0561
Scale:        290.5345       0.0551       0.0551       0.0551
Add:          346.0763       0.0695       0.0693       0.0708
Triad:        304.8652       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42174 microseconds.
   (= 42174 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8552       0.0555       0.0554       0.0561
Scale:        290.5605       0.0551       0.0551       0.0551
Add:          346.0258       0.0694       0.0694       0.0694
Triad:        304.6874       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42066 microseconds.
   (= 42066 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8671       0.0555       0.0554       0.0561
Scale:        290.6466       0.0552       0.0550       0.0566
Add:          346.1503       0.0693       0.0693       0.0694
Triad:        304.7143       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42182 microseconds.
   (= 42182 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9251       0.0555       0.0554       0.0561
Scale:        290.5492       0.0552       0.0551       0.0565
Add:          345.8730       0.0694       0.0694       0.0694
Triad:        304.4843       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42046 microseconds.
   (= 42046 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8350       0.0555       0.0554       0.0562
Scale:        290.5417       0.0551       0.0551       0.0551
Add:          346.0169       0.0694       0.0694       0.0694
Triad:        304.5724       0.0789       0.0788       0.0790
-------------------------------------------------------------
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 42074 microseconds.
   (= 42074 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6254       0.0555       0.0554       0.0561
Scale:        290.7332       0.0550       0.0550       0.0551
Add:          346.0244       0.0694       0.0694       0.0694
Triad:        304.7139       0.0790       0.0788       0.0804
-------------------------------------------------------------
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 42081 microseconds.
   (= 42081 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8069       0.0555       0.0554       0.0562
Scale:        290.5796       0.0551       0.0551       0.0551
Add:          345.9746       0.0694       0.0694       0.0694
Triad:        304.4378       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42185 microseconds.
   (= 42185 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8656       0.0555       0.0554       0.0561
Scale:        290.4865       0.0552       0.0551       0.0565
Add:          346.0083       0.0694       0.0694       0.0694
Triad:        304.5078       0.0789       0.0788       0.0790
-------------------------------------------------------------
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 42076 microseconds.
   (= 42076 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8278       0.0555       0.0554       0.0561
Scale:        290.6998       0.0552       0.0550       0.0566
Add:          346.0186       0.0694       0.0694       0.0694
Triad:        304.5719       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42171 microseconds.
   (= 42171 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7999       0.0555       0.0554       0.0561
Scale:        290.5597       0.0551       0.0551       0.0551
Add:          345.8002       0.0694       0.0694       0.0695
Triad:        304.5495       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42123 microseconds.
   (= 42123 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8586       0.0555       0.0554       0.0562
Scale:        290.5639       0.0551       0.0551       0.0551
Add:          346.1176       0.0693       0.0693       0.0694
Triad:        304.4774       0.0790       0.0788       0.0804
-------------------------------------------------------------
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 42199 microseconds.
   (= 42199 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7744       0.0555       0.0554       0.0561
Scale:        290.5632       0.0551       0.0551       0.0551
Add:          346.0258       0.0694       0.0694       0.0694
Triad:        304.5688       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42074 microseconds.
   (= 42074 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8620       0.0555       0.0554       0.0561
Scale:        290.6904       0.0551       0.0550       0.0551
Add:          346.1933       0.0695       0.0693       0.0709
Triad:        304.7094       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42193 microseconds.
   (= 42193 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8749       0.0555       0.0554       0.0561
Scale:        290.6794       0.0551       0.0550       0.0551
Add:          345.9932       0.0694       0.0694       0.0694
Triad:        304.3534       0.0789       0.0789       0.0789
-------------------------------------------------------------
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 42063 microseconds.
   (= 42063 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9554       0.0555       0.0554       0.0561
Scale:        290.6836       0.0551       0.0550       0.0551
Add:          346.1323       0.0693       0.0693       0.0694
Triad:        304.5689       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42199 microseconds.
   (= 42199 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0119       0.0556       0.0554       0.0569
Scale:        290.7892       0.0550       0.0550       0.0551
Add:          346.2343       0.0693       0.0693       0.0693
Triad:        304.5001       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42123 microseconds.
   (= 42123 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9856       0.0555       0.0554       0.0561
Scale:        290.7412       0.0550       0.0550       0.0551
Add:          346.1839       0.0693       0.0693       0.0694
Triad:        304.5605       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42215 microseconds.
   (= 42215 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8305       0.0555       0.0554       0.0561
Scale:        290.6858       0.0551       0.0550       0.0551
Add:          346.0477       0.0694       0.0694       0.0694
Triad:        304.5824       0.0790       0.0788       0.0803
-------------------------------------------------------------
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 42134 microseconds.
   (= 42134 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0412       0.0555       0.0554       0.0561
Scale:        290.7192       0.0551       0.0550       0.0551
Add:          346.0257       0.0694       0.0694       0.0694
Triad:        304.5961       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42155 microseconds.
   (= 42155 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8346       0.0556       0.0554       0.0576
Scale:        290.7038       0.0551       0.0550       0.0551
Add:          346.2526       0.0693       0.0693       0.0694
Triad:        304.9417       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42133 microseconds.
   (= 42133 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0596       0.0556       0.0554       0.0568
Scale:        290.7757       0.0550       0.0550       0.0551
Add:          346.1060       0.0694       0.0693       0.0694
Triad:        304.7766       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42294 microseconds.
   (= 42294 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7599       0.0555       0.0554       0.0561
Scale:        290.7797       0.0550       0.0550       0.0551
Add:          346.3294       0.0693       0.0693       0.0694
Triad:        304.6737       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42092 microseconds.
   (= 42092 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8623       0.0555       0.0554       0.0561
Scale:        290.7907       0.0550       0.0550       0.0551
Add:          346.0725       0.0694       0.0693       0.0694
Triad:        304.8795       0.0789       0.0787       0.0804
-------------------------------------------------------------
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 42212 microseconds.
   (= 42212 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8677       0.0555       0.0554       0.0561
Scale:        290.7891       0.0550       0.0550       0.0551
Add:          346.3070       0.0693       0.0693       0.0694
Triad:        304.7574       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42080 microseconds.
   (= 42080 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9774       0.0555       0.0554       0.0561
Scale:        290.6982       0.0552       0.0550       0.0565
Add:          346.1308       0.0694       0.0693       0.0694
Triad:        304.7366       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42204 microseconds.
   (= 42204 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8566       0.0555       0.0554       0.0561
Scale:        290.8455       0.0552       0.0550       0.0566
Add:          346.3121       0.0693       0.0693       0.0693
Triad:        304.8976       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42067 microseconds.
   (= 42067 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8137       0.0555       0.0554       0.0561
Scale:        290.8043       0.0551       0.0550       0.0551
Add:          346.1788       0.0694       0.0693       0.0694
Triad:        304.6220       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42245 microseconds.
   (= 42245 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5603       0.0555       0.0554       0.0562
Scale:        290.5317       0.0551       0.0551       0.0551
Add:          346.0111       0.0694       0.0694       0.0694
Triad:        304.6029       0.0790       0.0788       0.0803
-------------------------------------------------------------
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 42208 microseconds.
   (= 42208 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9058       0.0555       0.0554       0.0562
Scale:        290.5902       0.0551       0.0551       0.0551
Add:          345.9689       0.0694       0.0694       0.0694
Triad:        304.9197       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42229 microseconds.
   (= 42229 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6364       0.0555       0.0554       0.0562
Scale:        290.5401       0.0551       0.0551       0.0551
Add:          345.9857       0.0695       0.0694       0.0710
Triad:        304.5369       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42038 microseconds.
   (= 42038 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6078       0.0555       0.0554       0.0562
Scale:        290.6563       0.0551       0.0550       0.0551
Add:          346.0532       0.0694       0.0694       0.0694
Triad:        304.6816       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42239 microseconds.
   (= 42239 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.4454       0.0556       0.0555       0.0562
Scale:        290.3920       0.0551       0.0551       0.0551
Add:          346.0364       0.0694       0.0694       0.0694
Triad:        304.5616       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42111 microseconds.
   (= 42111 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9067       0.0556       0.0554       0.0569
Scale:        290.5965       0.0551       0.0551       0.0551
Add:          346.0276       0.0694       0.0694       0.0694
Triad:        304.7355       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42242 microseconds.
   (= 42242 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5881       0.0555       0.0554       0.0562
Scale:        290.4421       0.0551       0.0551       0.0551
Add:          345.9843       0.0694       0.0694       0.0694
Triad:        304.5886       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42093 microseconds.
   (= 42093 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9618       0.0555       0.0554       0.0561
Scale:        290.6087       0.0551       0.0551       0.0551
Add:          346.1481       0.0695       0.0693       0.0708
Triad:        304.7110       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42196 microseconds.
   (= 42196 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9027       0.0555       0.0554       0.0561
Scale:        290.5990       0.0551       0.0551       0.0551
Add:          346.0611       0.0694       0.0694       0.0694
Triad:        304.4871       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42073 microseconds.
   (= 42073 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9502       0.0555       0.0554       0.0561
Scale:        290.6370       0.0552       0.0551       0.0567
Add:          346.0268       0.0694       0.0694       0.0694
Triad:        304.6404       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42181 microseconds.
   (= 42181 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7092       0.0555       0.0554       0.0562
Scale:        290.6943       0.0552       0.0550       0.0565
Add:          345.8915       0.0694       0.0694       0.0694
Triad:        304.7801       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42089 microseconds.
   (= 42089 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9232       0.0555       0.0554       0.0561
Scale:        290.6733       0.0551       0.0550       0.0551
Add:          346.1271       0.0694       0.0693       0.0695
Triad:        304.9507       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42266 microseconds.
   (= 42266 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5872       0.0555       0.0554       0.0562
Scale:        290.5618       0.0551       0.0551       0.0551
Add:          346.0887       0.0694       0.0693       0.0694
Triad:        304.7038       0.0790       0.0788       0.0805
-------------------------------------------------------------
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 42054 microseconds.
   (= 42054 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9756       0.0555       0.0554       0.0561
Scale:        290.6952       0.0551       0.0550       0.0551
Add:          346.0282       0.0694       0.0694       0.0694
Triad:        304.8744       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42263 microseconds.
   (= 42263 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8929       0.0555       0.0554       0.0561
Scale:        290.7095       0.0552       0.0550       0.0565
Add:          346.2253       0.0693       0.0693       0.0694
Triad:        304.6642       0.0788       0.0788       0.0788
-------------------------------------------------------------
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 42093 microseconds.
   (= 42093 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8871       0.0555       0.0554       0.0561
Scale:        290.5137       0.0553       0.0551       0.0566
Add:          346.3004       0.0693       0.0693       0.0694
Triad:        304.8727       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42242 microseconds.
   (= 42242 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.9606       0.0555       0.0554       0.0561
Scale:        290.7863       0.0550       0.0550       0.0551
Add:          346.2817       0.0693       0.0693       0.0694
Triad:        305.0908       0.0787       0.0787       0.0788
-------------------------------------------------------------
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 42043 microseconds.
   (= 42043 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0225       0.0555       0.0554       0.0561
Scale:        290.8231       0.0550       0.0550       0.0551
Add:          346.1657       0.0693       0.0693       0.0694
Triad:        304.9316       0.0789       0.0787       0.0803
-------------------------------------------------------------
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 42285 microseconds.
   (= 42285 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.6375       0.0555       0.0554       0.0562
Scale:        290.5323       0.0551       0.0551       0.0551
Add:          346.3774       0.0693       0.0693       0.0693
Triad:        304.8401       0.0788       0.0787       0.0789
-------------------------------------------------------------
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 42084 microseconds.
   (= 42084 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8782       0.0555       0.0554       0.0561
Scale:        290.6550       0.0551       0.0550       0.0551
Add:          345.9703       0.0695       0.0694       0.0710
Triad:        305.0343       0.0787       0.0787       0.0788
-------------------------------------------------------------
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 42320 microseconds.
   (= 42320 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.3677       0.0556       0.0555       0.0562
Scale:        290.4050       0.0551       0.0551       0.0552
Add:          345.9238       0.0694       0.0694       0.0694
Triad:        304.3149       0.0789       0.0789       0.0789
-------------------------------------------------------------
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 42080 microseconds.
   (= 42080 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7553       0.0555       0.0554       0.0561
Scale:        290.5198       0.0551       0.0551       0.0551
Add:          346.1360       0.0694       0.0693       0.0695
Triad:        304.5184       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42290 microseconds.
   (= 42290 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.4987       0.0557       0.0555       0.0570
Scale:        290.2452       0.0552       0.0551       0.0552
Add:          345.9773       0.0694       0.0694       0.0694
Triad:        304.3852       0.0789       0.0788       0.0789
-------------------------------------------------------------
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 42119 microseconds.
   (= 42119 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7294       0.0555       0.0554       0.0562
Scale:        290.6981       0.0551       0.0550       0.0551
Add:          346.3057       0.0693       0.0693       0.0694
Triad:        304.8587       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42328 microseconds.
   (= 42328 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.2724       0.0556       0.0555       0.0562
Scale:        290.2719       0.0551       0.0551       0.0552
Add:          346.0775       0.0694       0.0693       0.0694
Triad:        304.8262       0.0789       0.0787       0.0803
-------------------------------------------------------------
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 42033 microseconds.
   (= 42033 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8568       0.0555       0.0554       0.0561
Scale:        290.4338       0.0551       0.0551       0.0551
Add:          346.1395       0.0693       0.0693       0.0694
Triad:        304.8030       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42325 microseconds.
   (= 42325 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.5975       0.0555       0.0554       0.0562
Scale:        290.5889       0.0552       0.0551       0.0567
Add:          346.3214       0.0693       0.0693       0.0693
Triad:        304.5849       0.0788       0.0788       0.0789
-------------------------------------------------------------
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 42035 microseconds.
   (= 42035 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.7275       0.0555       0.0554       0.0561
Scale:        290.5689       0.0552       0.0551       0.0565
Add:          346.2066       0.0693       0.0693       0.0693
Triad:        304.8960       0.0788       0.0787       0.0788
-------------------------------------------------------------
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 42266 microseconds.
   (= 42266 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         288.8747       0.0555       0.0554       0.0561
Scale:        290.7744       0.0550       0.0550       0.0551
Add:          346.1892       0.0693       0.0693       0.0694
Triad:        304.4229       0.0789       0.0788       0.0790
-------------------------------------------------------------
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 42058 microseconds.
   (= 42058 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------

Function      Rate (MB/s)   RMS time     Min time     Max time
Copy:         289.0077       0.0555       0.0554       0.0561
Scale:        290.6571       0.0551       0.0550       0.0551
Add:          346.1348       0.0694       0.0693       0.0694
Triad:        304.5113       0.0790       0.0788       0.0804