Ich hatte neulich einen Algorithmus wo ich effizient durch Pi dividie-
ren musste. Eine Multiplikation mit dem Kehrwert ist auf heutigen CPUs
schneller. Das benötigt aber mehr Rechenoperation rein von der Betrach-
htung der logischen Rechenschritte her.
Daher habe ich mal ein kleines Programm geschrieben das austestet wie-
viel Genauigkeit die beiden Ergebnisse bei einem beliebigen endlichen
x als floating point Zahl miteinander teilen. Als Maßstab für die
geteilte Genauigkeit habe ich mir die Formel ...
log2( max( abs( a ), abs( b ) ) ) - log2( abs( a - b ) )
.... ausgedacht. Sollten a und b gleich sein käme für den zweiten
Teil ein NaN raus; an der Stelle habe ich dann aber 53 Bit geteilte
Genauigkeit. Bei unterschiedlichem Vorzeichen ist der Abstand größer
als der größte Absolutwert der beiden Zahlen, d.h. man kann dann
von Null Bit geteilter Genauigkeit ausgehen, was für diese Berech-
nung aber nicht relevant ist.

#define _USE_MATH_DEFINES
#include <iostream>
#include <random>
#include <cstdint>
#include <cmath>
#include <bit>

extern double x87Fprem( double x, double y );

using namespace std;

int main()
{ mt19937_64 mt;
uniform_int_distribution<uint64_t> uid( 0, -1 );
constexpr size_t N = 10'000'000;
double accuracySum = 0;
for( size_t r = N; r; )
{
double
x = bit_cast<double>( uid( mt ) ),
fast = abs( x * (1 / M_PI) ),
slow = abs( x /(M_PI );
auto chk = []( double d ) { return !isnan( d ) && !isinf( d ); };
if( !chk( fast ) && !chk( slow ) )
continue;
accuracySum += slow != fast ? log2( slow > fast ? slow : fast ) -
log2( abs( slow - fast ) ) : 53;
--r;
}
accuracySum /= 1.0e7;
cout << accuracySum;
cout << " (" << (1 - accuracySum / 53) * 100 << "%)" << endl;
}

Für die besate Multiplikation mit 1 / Pi konkurrierend mit Division
durch Pi konnte ich eine geteilte Genausigkeit von 52.9325 Bit errech-
nen bei 53 Bit Mantisse, das sind 0.127303% Fehler-Bits. Das fand ich
ja schon mal absolut beeindruckend, dass der Fehler derart kein ist.