C++ mehr als 19 Stellen genauigkeit?

Computer: Software & Programmierung C/C++
#1

Hi ihr,
Ich bin zur Zeit am Programmieren von einem Programm, dass Wurzeln mit Näherungsverfahren bestimmt (also nicht mit sqrt). Ich möchte dazu natürlich die Zahlen möglichst genau haben. Jetzt möchte ich am Anfang

cout > w;
cout > n;

ich kann auch den Rest Programmieren, nur ich weiß nicht,

  1. wie ich es umsetzte, dass er mehr als 19 Nachkommastellen (long double) anzeigt und
  2. (ist aber nicht sooo wichtig) wie man einsellen kann, wie viele Stellen er anzeigen soll.

Vielleicht kann mir ein erfahrener Programmierer helfen, weil ich C++ erst seit 1 Monat lerne.

MfG Vincenz Frenzel

#2

Ich hab mal in meinem Archiv gesucht. Und ich hab Programmcode gefunden, mit dem man übertrieben genau rechnen kann.

Zunächst eine Klasse für Ganzzahlen:
die Haderdatei:
//---------------------------------------------------------------------------

#ifndef GZahlenH
#define GZahlenH
#include
#include

#define MaxAnzahl 1000
//---------------------------------------------------------------------------
// GanzZahl kann eine beliebig lange ganze Zahl enthalten
// ohne Komma ohne Vorzeichen
class GanzZahl {
friend GanzZahl operator+(const GanzZahl& Wert1,const GanzZahl& Wert2);
friend GanzZahl operator-(const GanzZahl& Wert1,const GanzZahl& Wert2);
friend GanzZahl operator*(const GanzZahl& Wert1,const GanzZahl& Wert2);
friend GanzZahl operator/(const GanzZahl& Wert1,const GanzZahl& Wert2);
friend GanzZahl operator%(const GanzZahl& Wert1,const GanzZahl& Wert2);
protected:
int Ziffer[MaxAnzahl]; // alle Ziffern
// Ziffer[0] = Einer
// Ziffer[1] = Zehner
// Ziffer[2] = Hunterter usw.
// neben der höchstwertigen Ziffer ist immer noch eine Ziffer mit 0
// auf diese 0 zeigt MaxPos. Alle höheren Ziffern können irgend welchen
// Müll enthalten.
int MaxPos; // Länge der Zahl
// Ziffer[x]
// alle Positionen x>=0 und x= MaxAnzahl ist wird Ausnahme 1 geworfen
// wenn Pos =(const GanzZahl& Wert2) const;
bool operator(const GanzZahl& Wert2) const;
bool operator (b)) ? (a) : (b))
#define min(a, b) (((a) 0) a–;
AnsiString ret="";
char X[2]=„X“;
while(a>=0) {
X[0]=‚0‘+Ziffer[a];
ret=ret+X;
a–;
}
return ret;
}

void GanzZahl::SetWert(AnsiString Wert) {
int a=0;
int b=Wert.Length();
while(b>0) {
Ziffer[a]=Wert[b]-‚0‘;
a++;
b–;
}
Ziffer[a]=0;
MaxPos=a;
Trimm();
}

void GanzZahl::Trimm() {
if (MaxPos==0) return;
while (Ziffer[MaxPos-1]==0) MaxPos–;
}

int GanzZahl::GetZiffer(int Pos) const {
if (Pos>=MaxPos) return 0;
if (Pos=MaxAnzahl) throw 1;
if (Pos=MaxAnzahl) throw 1;
for(int a=MaxPos;a>=0;a–) Ziffer[a+1]=Ziffer[a];
Ziffer[0]=0;
MaxPos++;
}

int GanzZahl::Vergleich(const GanzZahl& Wert2) const {
int a=max(Wert2.GetMaxPos(),GetMaxPos());
int b=min(Wert2.GetMinPos(),GetMinPos());
a–;
while (a>=b) {
if (Wert2.GetZiffer(a)>GetZiffer(a)) return 1;
if (Wert2.GetZiffer(a)0) {
if (b>a) throw 3; // wenn das erreicht wird dann ist wurde eine größere Zahl von einer kleineren abgezogen
if (was==’+’) {
e=GetZiffer(b)+Wert2.GetZiffer(b)+Ueb;
} else {
e=GetZiffer(b)-Wert2.GetZiffer(b)-Ueb;
}
Ueb=0;
if (e>9) { e-=10; Ueb=1; }
if (e0) {
int e=Erg.GetZiffer(a+b)+GetZiffer(a)*Wert2.GetZiffer(b)+Ueb;
Ueb=e/10;
Erg.SetZiffer(a+b,e%10);
a++;
}
b++;
}
Erg.Trimm();
return Erg;
}

GanzZahl GanzZahl::Teilen(const GanzZahl& Wert2,GanzZahl& Rest) const {
if (Wert2==0) throw 4;
GanzZahl Mul[10]; // Wert2 jeweils multipliziert mit 0-9
int a,b,e;
for (a=0;a=0) { // die ersten Stellen vom Dividenden holen
Rest.SetZiffer(b,GetZiffer(a));
a–; b–;
}
int NaechstePos=a;
while(true){
e=9; // von 9 abwärts probieren
while(Mul[e]>Rest) e–;
Erg.Mal10();
Erg.SetZiffer(0,e); // gfundene Ziffer zum Ergebnis dazuschreiben
Rest-=Mul[e]; // Rest ermitteln
if (NaechstePos=(const GanzZahl& Wert2) const {
return Vergleich(Wert2)!=1;
}

bool GanzZahl::operator(const GanzZahl& Wert2) const {
return Vergleich(Wert2)==-1;
}

bool GanzZahl::operator0) a–;
AnsiString ret="";
char X[2]=„X“;
while(a>=0) {
if (a==EinerPos-1) ret=ret+".";
X[0]=‚0‘+Ziffer[a];
ret=ret+X;
a–;
}
return ret;
}

void KommaZahl::SetWert(AnsiString Wert) {
EinerPos=0;
int a=0;
int b=Wert.Length();
while(b>0) {
if (Wert[b]==’.’) { EinerPos=a; b–; }
Ziffer[a]=Wert[b]-‚0‘;
a++;
b–;
}
Ziffer[a]=0;
MaxPos=a;
}

int KommaZahl::GetZiffer(int Pos) const {
Pos+=EinerPos;
return GanzZahl::GetZiffer(Pos);
}

void KommaZahl::SetZiffer(int Pos,int Wert) {
Pos+=EinerPos;
if (Pos=0) {
Ziffer[a-Pos]=Ziffer[a]; // alles nach vorne schieben
a–;
}
while (a-Pos>=0) {
Ziffer[a-Pos]=0; // mit 0-en auffüllen
a–;
}
MaxPos-=EinerPos+Pos; // Positionen erhöhen
EinerPos=0-Pos;
}
GanzZahl::SetZiffer(Pos,Wert); // Ziffer einsetzen
}

int KommaZahl::GetMaxPos() const {
return MaxPos-EinerPos;
}

int KommaZahl::GetMinPos() const {
return 0-EinerPos;
}

KommaZahl operator/(KommaZahl Wert1,KommaZahl Wert2) {
if (Wert2==0) throw 2;
while (Wert2.EinerPos>0) { // ggf erweiteren
if (Wert1.EinerPos>0) Wert1.EinerPos–;
else Wert1.Mal10();
Wert2.EinerPos–;
}
GanzZahl Mul[10]; // Wert2 jeweils multipliziert mit 0-9
int a,b,e;
for (a=0;a0) {
a–; b–;
Wert1a.SetZiffer(b,Wert1.GetZiffer(a));
}
int NaechstePos=a-1;
while(NaechstePos>=-1){
e=9; // von 9 abwärts probieren
while(Mul[e]>Wert1a) e–;
Erg.Mal10();
Erg.SetZiffer(0,e); // gfundene Ziffer zum Ergebnis dazuschreiben
Wert1a-=Mul[e]; // Rest ermitteln
Wert1a.Mal10();
Wert1a.SetZiffer(0,Wert1.GetZiffer(NaechstePos));
NaechstePos–;
}
return Erg;
}

#pragma package(smart_init)

Mit diesen beiden Klassen müstest du dein Problem lösen können.

Gruß Stefan

#3

Hallo,

ich kann auch den Rest Programmieren, nur ich weiß nicht,

  1. wie ich es umsetzte, dass er mehr als 19 Nachkommastellen
    (long double) anzeigt und
  2. (ist aber nicht sooo wichtig) wie man einsellen kann, wie
    viele Stellen er anzeigen soll.

Es ist nicht unbedings davon auszugehen, daß auf Deinem
System ‚long double‘ tatsächlich genauer ist als ‚double‘.
Das muß man erstmal prüfen:

#include 

int main(int argc, char \*argv[])
{
 long double a = 1.23456789011111111112222222222L;
 long double b = 12.3456789011111111112222222222L;
 long double c = b / a;

 int prec = 24;

 printf("double:%d, long double:%d\n",sizeof(double), sizeof(long double));
 printf("%.\*Lf / %.\*Lf = %.\*Lf\n", prec, a, prec, b, prec, c);
 
 return 0;
}

(mach ma bitte und poste die Resultate …)

Grüße

CMb