Calculator benchmark: Savage extended

Update: it seems that the benchmark was not well received by the community. A benchmark should provide some sort of indication, normally it is speed but for the savage benchmark it is also accuracy, the original savage benchmark is enough for this. Therefore the savage extended can be considered valid for very fast and precise future calculators. Maybe.

The idea
There are few popular benchmarks for calculators ¹⁾ and between those the one that tests more some complex mathematical operations is the Savage benchmark. Unfortunately it is not so useful to test the accuracy of a calculator ²⁾, moreover for newer calculators it is a tiny problem. But it is easy to extend, simply do the test for different values (from 1 to 500 for example). Besides in this manner we have more informations about the accuracy done on several distinct computations that are similar each other (though it isn't a “ideal” measure).

The measure of accuracy
And how do we can measure the accuracy? Of course there are several ways, but, since it is a benchmark, tring to keep it simple, we count the sum of absolute error for each iteration of the savage benchmark.

The pseudocode

input:
  n: upper bound value to test the savage benchmark
---

globalSum = 0
sum = 1
for k=1 to (n-1) { //note the "n-1"
  sum = sum + tan ( atan ( exp ( log ( sqrt ( sum*sum) ) ) ) )
    //CAREFUL here!
    //for the original savage benchmark many have done sqrt first and square then,
    //obtaining different results.
    //The algorithm must be the same in terms of main operations:
    //Square first
    //then square root
    //then log
    //then exp
    //then atan
    //then tan
  globalSum = globalSum + abs((k+1)-sum)
}
print globalSum //the global sum obtained

the result report

A result is composed by the following list
  - the device used plus the language used, eventual overclock, eventual custom firmware and so on.
  - [optional] the number of digits used by the device during the computation.
  - time elapsed for a given n in seconds (see below). NOTE: with same accuracy the faster speed is preferred in the accuracy section and a result with the time is preferred to one without it.
  - the globalSum printed.
  - the code used.

the values for n

1'000
2'500
5'000
for faster implementations:
10'000
25'000
50'000