Some tests are performed on many different processors from 8086 to modern CPU's. The initial purpose of the tests is the evaluation of my own compiler. But it is only integer tests. Here simple floating point tests presented. They calculates the area under half the period of the sine unction by using rectangle method, the simplest method of integration.

The initial goal was to evaluate the efficiency of modern math coprocessors, and for this purpose rather primitive implementations of single- and double-precision floating-point arithmetic were written. Initial double-precision arithmetic implementatution could only work on 64-bit systems.

Testing was then expanded to include some 8-bit microcomputers and programmable calculators.

I also came up with a consistent proof of the existence of the limit of the ratio of the sine function to its argument needed to calculate the derivative. I'm not the first to do this, but my version is based on simpler grounds. You can read about it here.

Sine function calculated by FPU/library call and sum of Maclaurin series. Floating point arithmetic are performed by FPU/library calls and self-written in C language software implementation (possible inefficient and not fully correct):

Unfortunately, no stable versions of this libraries and different results were obtained using different versions. Current version here.

GCC and Borland C/C++ compilers are used. On some old compters built-in Basic interpreter are used. It is incorrect to compare the speed of compiled and interpreted code. On new machines the difference can be hundreds of times, on old machines it is much less - from two to five times. This is true for floating point calculations only, for integer calculations the difference are much more.

On many systems number of intervals (N) reduced to 10⁶ - 10¹ and the time is multiplied by 10⁷ /  N. Nubmer of signs after decimal point may be greater than time measurement accuracy (for unified results alignment). On old systems time measured by electronic stopwatch. It may increase result by reaction time (~0.4 sec) multiplied by 10⁷ / 10 ^N.

MS DOS and first MS Windows versions of my own compiler implements double precision arithmetic on 80x87 FPU unit only. It also used if possible.

For calculations with single precision (Real*4) N = 10⁷ is too large and result error significant (2.023 instead of 2.0), but here the time is determined, not the area.

Old versions of C compilers always use double precision arithmetic, IBM PC Basic interpreters always use single precision sine function (in versions 3.x precision may be changed via /D command line argument, but it was not used).

Thanks to the Yandex Museum for the opportunity to use some old computers - IBM 5150, Apple//e, Sinclair ZX81 and some others.

Simplified source code for first two columns (FPU/Lib and Soft-sin):

Most of the results were obtained on real machines, some were also obtained on emulators. Some of them are correct, others are not. In many cases three digits after decimal point added for alignment only.

Cpu: All Intel Core AMD Athlon 64 Pentium 4 Pentium II/III Pentium/AMD K6 80486 80386 80286 8086/8088 Accuracy: All Real*4 Real*8 Word: All 8-bit 16-bit 32-bit 64-bit Compiler/interpreter: All Borland C/C++ gcc GW-Basic IBM PC Basic Basic/other All: