Hi, Wie kann ich noch größere Genauigkeit bekommen, als über long double? philipp
Wichtig ist eigentlich, dass keine nicht ISO-Library dafür nötig ist und dass kein zu komplizierter Code dabei herauskommt.Muss das ganze nämlich auch erklären können und mein Lehrer muss es auch auf Windows kompilieren können und leicht verstehen. Ich meinte mehr so etwas wie z.B. bei int, wo ich einfach unsigned int nehme. Ich habe ja auf jeden Fall nur positive Zahlen. philipp
Philipp Otte schrieb:
Wichtig ist eigentlich, dass keine nicht ISO-Library dafür nötig ist und > dass kein zu komplizierter Code dabei herauskommt.Muss das ganze nämlich auch erklären können und mein Lehrer muss es auch auf Windows kompilieren können und leicht verstehen. Ich meinte mehr so etwas wie z.B. bei int, wo ich einfach unsigned int nehme. Ich habe ja auf jeden Fall nur positive Zahlen.
Mit den primitiven Datentypen dürfte, was die Genauigkeit anbelangt, ziemlich schnell Schluß sein. Weglassen des Vorzeichens gibt nicht mal eine Dezimalstelle mehr. Was Du bisher nicht gesagt hast: welche Genauigkeit benötigst Du? Nur ganze Zahlen oder auch gebrochene? Bzw. wie lautet das Problem? -- Alex
Also ich schreib ein Programm zur Bestimmung von pi. Das heißt ich brauche ziemlich viele Dezimalstellen, aber laut meinem C-Buch geht long double, double und float nur bis 6 Stellen hinter dem Komma genau. Das ist aber an sich zu wenig für diesen Zweck. Andererseits kann ich keine speziellen Bibliotheken nehmen, weil ich ISO-konform bleiben muss. philipp Am Sam, 2004-01-10 um 18.45 schrieb Alexander Veit:
Philipp Otte schrieb:
Wichtig ist eigentlich, dass keine nicht ISO-Library dafür nötig ist und > dass kein zu komplizierter Code dabei herauskommt.Muss das ganze nämlich auch erklären können und mein Lehrer muss es auch auf Windows kompilieren können und leicht verstehen. Ich meinte mehr so etwas wie z.B. bei int, wo ich einfach unsigned int nehme. Ich habe ja auf jeden Fall nur positive Zahlen.
Mit den primitiven Datentypen dürfte, was die Genauigkeit anbelangt, ziemlich schnell Schluß sein. Weglassen des Vorzeichens gibt nicht mal eine Dezimalstelle mehr. Was Du bisher nicht gesagt hast: welche Genauigkeit benötigst Du? Nur ganze Zahlen oder auch gebrochene? Bzw. wie lautet das Problem?
-- Alex
Hallo, Am Samstag, 10. Januar 2004 19:00 schrieb Philipp Otte:
Also ich schreib ein Programm zur Bestimmung von pi. Das heißt ich brauche ziemlich viele Dezimalstellen, aber laut meinem C-Buch geht long double, double und float nur bis 6 Stellen hinter dem Komma genau. Das ist aber an sich zu wenig für diesen Zweck. Andererseits kann ich keine speziellen Bibliotheken nehmen, weil ich ISO-konform bleiben muss. philipp
Du hast ein komisches Buch. Das gilt nur für float. double hat, glaube ich, 15 und long double 19 Stellen Genauigkeit. Ferdinand
Also so sieht das Programm bisher aus:
//*** Einzubindende Header ***
#include <cmath>
#include <iostream>
//*** Definition des Namespaces ***
using namespace std;
//*** Definition globaler Variablen ***
//*** Hauptfunktion main()
int main()
{
//Definition der Variablen
unsigned int k;
long double pi2=1;
unsigned int n;
// Abfrage von k
cout<<"Programm zur Berechnunhg von Pi mit der Methode von
Wallis"< Hallo, Am Samstag, 10. Januar 2004 19:00 schrieb Philipp Otte: Also ich schreib ein Programm zur Bestimmung von pi. Das heißt ich
brauche ziemlich viele Dezimalstellen, aber laut meinem C-Buch geht long
double, double und float nur bis 6 Stellen hinter dem Komma genau. Das
ist aber an sich zu wenig für diesen Zweck. Andererseits kann ich keine
speziellen Bibliotheken nehmen, weil ich ISO-konform bleiben muss.
philipp Du hast ein komisches Buch. Das gilt nur für float. double hat, glaube ich, 15
und long double 19 Stellen Genauigkeit. Ferdinand
Phillip Otte schrieb:
[...] cout<<"Programm zur Berechnunhg von Pi mit der Methode von Wallis"<
Was hast Du denn für Vorgaben, welche Genauigkeit der Näherungswert von Pi erreichen muß? Falls Du die Lösung mit der Formel von Wallis bis zu einer beliebigen Genauigkeit des Ergebnisses bringen sollst, ist die Aufgabe mit einem normalen Computer mangels Hauptspeicher wahrscheinlich gar nicht zu lösen. Die Formel von Wallis konvergiert sehr schlecht. Für k = 100000 stimmen gerade mal die ersten fünf Stellen der Näherung. -- Gruß, Alex
Ja ich bin nur angehalten worden ein Programm zur Facharbeit zu schreiben, sonst nichts. Aber ich glaub die 5 Stellen reichen auch. Ich sollte es nämlich erst in BASIC schreiben. Aber danke Euch! Am Sam, 2004-01-10 um 20.13 schrieb Alexander Veit:
Phillip Otte schrieb:
[...] cout<<"Programm zur Berechnunhg von Pi mit der Methode von Wallis"<
Was hast Du denn für Vorgaben, welche Genauigkeit der Näherungswert von Pi erreichen muß?
Falls Du die Lösung mit der Formel von Wallis bis zu einer beliebigen Genauigkeit des Ergebnisses bringen sollst, ist die Aufgabe mit einem normalen Computer mangels Hauptspeicher wahrscheinlich gar nicht zu lösen. Die Formel von Wallis konvergiert sehr schlecht. Für k = 100000 stimmen gerade mal die ersten fünf Stellen der Näherung.
-- Gruß, Alex
Am Samstag, 10. Januar 2004 20:02 schrieb Philipp Otte:
Also so sieht das Programm bisher aus: //*** Einzubindende Header *** #include <cmath> #include <iostream>
//*** Definition des Namespaces *** using namespace std;
//*** Definition globaler Variablen ***
//*** Hauptfunktion main()
int main() { //Definition der Variablen unsigned int k; long double pi2=1; unsigned int n; // Abfrage von k cout<<"Programm zur Berechnunhg von Pi mit der Methode von Wallis"<
>k; cout< 0;i--) { n=2*i; pi2=pi2*(long double)(n*n)/(long double)(n*n -1); cout<
Das muss an der Ausgabe liegen. k = 15000 hat bei mir die ersten 4 Stellen richtig und ist genauer als k = 1000. k = 100000 geht nicht mehr mit der Genauigkeit, aber für die gibt es einige bessere Verfahren. Welche Ausgabe du stattdessen nehmen solltest, weiß ich nicht. Ich kann kein C++. Ferdinand
Philipp Otte schrieb:
[...] Und jetzt probiers mal mit k=1000 zu starten. Da sind die ersten ca. 20 Ausgaben 1, weil erst danach die Genauigkeit von long double erreicht wird.
Nein, dies liegt daran, daß Du die Berechnung mit ganzen Zahlen durchführst (unsigned int n) und erst später nach long double castest. Versuche es mal so: for (int i = k; i > 0; i--) { long double n = 2 * i; long double p1 = n / (n - 1); long double p2 = n / (n + 1); pi2 = pi2 * p1 * p2; cout << pi2 << endl; } Das Aufspalten des Faktors n^2 / (n^2 -) in n / (n - 1) * n / (n + 1) erhöht evtl. die Genauigkeit bei großen k. -- Alex
Philipp Otte schrieb:
Also ich schreib ein Programm zur Bestimmung von pi. Das heißt ich brauche ziemlich viele Dezimalstellen, aber laut meinem C-Buch geht long double, double und float nur bis 6 Stellen hinter dem Komma genau. Das ist aber an sich zu wenig für diesen Zweck. Andererseits kann ich keine speziellen Bibliotheken nehmen, weil ich ISO-konform bleiben muss. [...]
also so etwas: int a=10000,b,c=2800,d,e,f[2801],g; main() { for(;b-c;) f[b++]=a/5; for(;d=0,g=c*2;c-=14,printf("%.4d",e+d/a),e=d%a) for(b=c;d+=f[b]*a,f[b]=d%--g,d/=g--,--b;d*=b); } -- Alex
Hallo, Am Samstag, 10. Januar 2004 19:00 schrieb Philipp Otte:
Also ich schreib ein Programm zur Bestimmung von pi. Das heißt ich brauche ziemlich viele Dezimalstellen, aber laut meinem C-Buch geht long double, double und float nur bis 6 Stellen hinter dem Komma genau. Das ist aber an sich zu wenig für diesen Zweck. Andererseits kann ich keine speziellen Bibliotheken nehmen, weil ich ISO-konform bleiben muss.
Ist dir das Verfahren vorgegeben? Sonst ist http://crd.lbl.gov/~dhbailey/mpdist/mpdist.html http://crd.lbl.gov/~dhbailey/piqp.c vielleicht ein interessanter Weg. Schöne Grüße aus Bremen hartmut
Philipp Otte
Wichtig ist eigentlich, dass keine nicht ISO-Library dafür nötig ist und dass kein zu komplizierter Code dabei herauskommt.
Dann kannst du es sowieso vergessen, denn eine Bibliothek wie gmp programmierst du nicht über Nacht und es gibt keine standardisierte Bibliothek dafür.
Ich meinte mehr so etwas wie z.B. bei int, wo ich einfach unsigned int nehme. Ich habe ja auf jeden Fall nur positive Zahlen.
Es gibt aber kein unsigned double, schon weil dies keinen Sinn machen würde. Philipp
* Philipp Otte
Hi, Wie kann ich noch größere Genauigkeit bekommen, als über long double? philipp
nicht über eingebaute Datentypen. Du könntest darüber nachdenken Java zu nehmen, da ist eine Bibliothek für sowas schon dabei und Dein Lehrer hätte keine Probleme mit Windows. Würde dann beispielsweise so aussehen: -------------------- 8< ---------------------------------------- import java.math.BigDecimal; class Test { public static void main (String[] args) { BigDecimal big = new BigDecimal("1.000000000000000001000000000000000000000000000000000"); final BigDecimal TEN = new BigDecimal("10"); for (int i = 0; i < 10; ++i) { big = big.divide(TEN, BigDecimal.ROUND_HALF_UP); System.out.println(big); } } } --------------------- >8 ----------------------------------------- Ausgabe ware dann: [~] $ java Test 0.100000000000000000100000000000000000000000000000000 0.010000000000000000010000000000000000000000000000000 0.001000000000000000001000000000000000000000000000000 0.000100000000000000000100000000000000000000000000000 0.000010000000000000000010000000000000000000000000000 0.000001000000000000000001000000000000000000000000000 0.000000100000000000000000100000000000000000000000000 0.000000010000000000000000010000000000000000000000000 0.000000001000000000000000001000000000000000000000000 0.000000000100000000000000000100000000000000000000000 Wäre für Deinen Fall fast am einfachsten, außer die Sprache ist Dir vorgegeben oder Du darfst externe Libraries verwenden. Gruß, Bernhard -- _________ http://www.bwalle.de _________________________________________________ Eine Investition in Wissen bringt noch immer die besten Zinsen. -- Benjamin Franklin
participants (6)
-
Alexander Veit
-
Bernhard Walle
-
Ferdinand Ihringer
-
Hartmut Meyer
-
Philipp Otte
-
Philipp Thomas