Utopische 20stellige Genauigkeit

Hi!

Die Compiler-Genauigkeit des C++ Builder beträgt max. 15 Stellen, interpretiert long double wie double. Der Typ long double ist daher bei den Grundrechenarten mindeststens so genau wie double, lediglich die math. Funktionen (Winkelfunktion) vom Typ long double sind mindestens auf 18 Stellen genau.
Wie frisiert man den Compiler, so dass der Typ long double auch in den Grundrechnarten auf 19-20 Stellen genau rechnet? Die Stellenzahl ist einfach notwendig, um Aufrundungsfehler in math. Progr. zu vermeiden.

:p

Alles Wissen ist nur Erinnerung.

Sunday

32-Bit Datentypen, Größen und Bereiche

Typ   Größe (Bits)   Bereich   Beispielanwendungen

unsigned char   8   0 <= X <= 255   Kleine Zahlen und kompletter PC-Zeichensatz
char   8   -128 <= X <= 127   Sehr kleine Zahlen und ASCII-Zeichen
short int   16   -32.768 <= X <= 32.767   Zähler, kleine Zahlen, Schleifensteuerung
unsigned int   32   0 <= X <= 4.294.967.295   Große Zahlen und Schleifen
int   32   -2,147,483,648 to 2,147,483,647   Zähler, kleine Zahlen, Schleifensteuerung
unsigned long   32   0 <= X <= 4.294.967.295   Astronomische Distanzen

enum   32   -2.147.483.648 <= X <= 2.147.483.647   Geordnete Wertemengen
long   32   -2.147.483.648 <= X <= 2.147.483.647   Sehr große Zahlen, statistische Grundgesamtheiten
float   32   1,18  10^-38 < |X| < 3,40  10^38   Wissenschaftlich, 7-stellige Genauigkeit
double   64   2,23  10^-308 < |X| < 1.79  10^308   Wissenschaftlich, 15-stellige Genauigkeit
long double   80   3,37  10^-4932 < |X| < 1.18  10^4932   Finanzrechnung, 18-stellige Genauigkeit

wie wäre es wenn du Extended nimmst?

Typ   Bereich    Signifikante Stellen   Größe in Byte
Real48   2.9 x 1039 .. 1.7 x 1038   11-12   6
Single   1.5 x 1045 .. 3.4 x 1038   7-8   4
Double   5.0 x 10324 .. 1.7 x 10308   15-16   8
Extended   3.6 x 104951 .. 1.1 x 104932   19-20   10
Comp   263+1 .. 263 1   19-20   8
Currency   922337203685477.5808.. 922337203685477.5807   19-20   8

bzw. gibts auch libs die dir beliebig viele nachkommastellen simulieren.

[ Dieser Beitrag wurde am 22.01.2003 um 15:14 Uhr von Sunday editiert. ]

Egal welcher Datentyp. Die max. Genauigkeit des C++ Builder Compilers entspricht nur dem Typ double.

Schau schau:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <conio.h>
//---------------------------------------------------------------------------

#pragma argsused

int main(int argc, char* argv[])
{
float ffloat;
double ddouble;
long double ldouble;
Extended eex;
ffloat=ddouble=ldouble=eex = 10.0/3.0;
cout.precision(40);

cout << "float......: " << 8*sizeof(ffloat) << " Bit " << ffloat << "\n";
cout << "double.....: " << 8*sizeof(ddouble) << " Bit " << ddouble << "\n";
cout << "long double: " << 8*sizeof(ldouble) << " Bit " << ldouble << "\n";
cout << "Extended...: " << 8*sizeof(eex) << " Bit " << eex << "\n";
getch();

        return 0;
}
//---------------------------------------------------------------------------