C# - Programm zur näherungsweisen Berechnung der Zahl π

Computer: Software & Programmierung .NET & C#
#1

Guten Abend,
ich würde gerne einen Viertelkreis mit dem Radius 1 nährungsweise mit durch n Rechtecke der Breite 1/n darstellen.
Ich weiß, dass ich die Konstante Pi von unten damit annähern kann:
 Formel.
Und von oben mit dieser:
Formel 1.

Das Programm soll nun gemäß dieser Formeln mit n = 4,8,16,32… die untere und obere Schranke berechnen bis beide Werte nach n-Schritten 0,00001 erreicht werden.

Ich würde nun eine do-Schleife und darin 2 for-Schleifen nutzen.
Nun hört aber eine Schleife bei n=4 einfach auf.
Was genau muss ich denn wie initialisieren. Und muss die Formel mit in den Code?
Könnte mir einer mit einfachen Worten erklären WAS ich WIE genau machen soll?

Vielen Dank.

#2

Hallo,

warum ihr Programm abbricht kann ich leider nicht beantworten. Dafür müsste ich das Programm vor Augen haben. 

Ist das das Verfahren von Archimedes, ich glaubes es, bin mir aber nicht ganz sicher. Im Internet werden sie viel darüber finden. So sollte es in C gehen:

int z = 1

double n = 0.0;
double pi =0.0;




while (z 



               pi = pi + (4/n) \* sqrt(1-((z/n)\*(z/n));





     z = z + 1;
    }



printf("pi : %lf", pi);

Die Näherung von unten sieht dann analog aus. Wenn ich die Formeln richtig verstehe geht es auch gar nicht elegant mit einer umschliessenden while - Schleife weil sich dann doch die Schleifenabbruchbedingung ändert. 
Ich habe die nativen Datentypen von C# (decimal, double) nicht parat. Aber ich glaube mit den Transport des Programms nach C# sollte es keine Probleme geben. 
#3

Da fehlt noch eniges_

int z = 1;
int n = 10000;
double n = 0.0;
double pi =0.0;

while (z

#4

) Nun musste ich es doch mal eben schreiben :smile: Da waren mir zu viele Fehler drinne

#include
#include
#include

int main(int argc, char **argv) {

int z = 1;
double n = 10000;
double pi =0.0;

while (z

#5

Also es ist nicht das Verfahren von Archimedes sondern eine Näherungsberechnung aus 2 Summen. Wenn ich mir das anschaue dann muss ein C# Programm so aussehen für die Berechung der Näherung von oben und von unten. Die Schleifengrenzen 4,8, 16, 32 müssen sie einsetzen. Ich habe mal 10000 genommen.

using System;

namespace PiNet
{
class MainClass
{
public static void Main (string[] args)
{
int z = 1;
double n = 10000;
double pilower = 0.0;
double piupper = 0.0;
double pi = 0.0;

while (z

#6

Und um es vollständig zu machen hier noch eimal das vollständige C Programm welches getestet ist und auch funktioniert. Das C# Programm ist aus der Hand geschrieben und kann Fehler enthalten. Bitte vorsichtig durchlesen und testen. Das C Programm funktioniert und liefert dals Ergebnis mit einer Schranke von 10000000 den Wert pi : 3.1415926536.

#include
#include
#include

int main(int argc, char **argv) {

int z = 1;
double n = 10000000;
double pilower = 0.0;
double piupper = 0.0;
double pi = 0.0;

while (z

#7

Guten Abend,
vielen Dank für die Tipps :smile:

Um die Aufgabe nochmals richtig nachvollziehen zu können,
habe ich das Programm nun in C++ geschrieben:

//Definition der Untersumme
double Untersumme(double n)
{
double Ergebnis=0;
for (int i=1; i Untersumme
n = n*2;
}
while (diff >= eps);
// Ausgabe wäre doch auch nicht verkehrt, oder
cout

#8

Hallo Baby Jaay,

Zuerst zu deinem Programm. Das bricht nicht nicht an 4 Schleifendurchläufen an. Das bricht ab wenn diff 2.495709068102441 | 3.495709068102441 diff : 1
n : 8 --> 2.839819144357173 | 3.339819144357173 diff : 0.5
n : 16 --> 2.998253037827741 | 3.248253037827741 diff : 0.25
n : 32 --> 3.07260242287713 | 3.197602422877131 diff : 0.1250000000000004
n : 64 --> 3.108046912779686 | 3.170546912779686 diff : 0.0625
n : 128 --> 3.125155792396614 | 3.156405792396614 diff : 0.03125
n : 256 --> 3.13349308295723 | 3.14911808295723 diff : 0.015625
n : 512 --> 3.137584902719655 | 3.145397402719655 diff : 0.0078125
n : 1024 --> 3.13960364153902 | 3.14350989153902 diff : 0.00390625
n : 2048 --> 3.140603402911442 | 3.142556527911442 diff : 0.001953125
n : 4096 --> 3.141099886357759 | 3.142076448857759 diff : 0.0009765625
n : 8192 --> 3.14134692692469 | 3.14183520817469 diff : 0.0004882812500004441
n : 16384 --> 3.141470022526393 | 3.141714163151393 diff : 0.000244140625
n : 32768 --> 3.141531420177993 | 3.141653490490493 diff : 0.0001220703125
n : 65536 --> 3.141562065917714 | 3.141623101073964 diff : 6.103515625e-05
n : 131072 --> 3.141577370018765 | 3.14160788759689 diff : 3.0517578125e-05
n : 262144 --> 3.141585015433538 | 3.141600274222601 diff : 1.52587890625e-05
n : 524288 --> 3.141588835794821 | 3.141596465189352 diff : 7.62939453125e-06

#9

Du kannst auch eine andere Schleifenabbruchbedingung setzen:
Statt while (diff >= eps) nimmst du z.B. while (n 2.495709068102441 | 3.495709068102441 diff : 1
n : 8 --> 2.839819144357173 | 3.339819144357173 diff : 0.5
n : 16 --> 2.998253037827741 | 3.248253037827741 diff : 0.25
n : 32 --> 3.07260242287713 | 3.197602422877131 diff : 0.1250000000000004
n : 64 --> 3.108046912779686 | 3.170546912779686 diff : 0.0625
n : 128 --> 3.125155792396614 | 3.156405792396614 diff : 0.03125

#10

So und jetzt kannst Du die beiden Abbruchbedingungen verknoten und dann hast du es einer Meinung nach. Hier das C++ Programm welches deine Anforderungen erfüllt, wenn es keine Missverständnisse meinerseits gibt:

#include
#include
#include
#include

using namespace std;

//Definition der Untersumme
double Untersumme(double n)
{
double Ergebnis=0;
for (int i=1; i Untersumme
cout ";
cout = eps || n

#11

Anbei noch das C# Programm. Ich habe keinen Zugriff auf eine C# Umgebung also das Programm lesen und testen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PiNet
{
class Program
{
const int limit = 129;

static double Untersumme(double n)
{
double Ergebnis = 0.0;
for(int i=1; i " + Untersumme(n) + " „);
Console.Write(Obersumme(n));
Console.Write(“ diff: " + diff + „\r\n“);
n = n * 2;

} while (diff >= eps || n

#12

Ich habe keinen Zugriff auf eine C# Umgebung

Das Programm funktioniert und liefert folgenden Output:

n: 000000004 --\> 2,49570906810244 3,49570906810244 diff: 1
n: 000000008 --\> 2,83981914435717 3,33981914435717 diff: 0,5
n: 000000016 --\> 2,99825303782774 3,24825303782774 diff: 0,25
n: 000000032 --\> 3,07260242287713 3,19760242287713 diff: 0,125
n: 000000064 --\> 3,10804691277969 3,17054691277969 diff: 0,0625
n: 000000128 --\> 3,12515579239661 3,15640579239661 diff: 0,03125
n: 000000256 --\> 3,13349308295723 3,14911808295723 diff: 0,015625
n: 000000512 --\> 3,13758490271965 3,14539740271965 diff: 0,0078125
n: 000001024 --\> 3,13960364153902 3,14350989153902 diff: 0,00390625
n: 000002048 --\> 3,14060340291144 3,14255652791144 diff: 0,001953125
n: 000004096 --\> 3,14109988635776 3,14207644885776 diff: 0,0009765625
n: 000008192 --\> 3,14134692692469 3,14183520817469 diff: 0,000488281250000444
n: 000016384 --\> 3,14147002252639 3,14171416315139 diff: 0,000244140625
n: 000032768 --\> 3,14153142017799 3,14165349049049 diff: 0,0001220703125
n: 000065536 --\> 3,14156206591771 3,14162310107396 diff: 6,103515625E-05
n: 000131072 --\> 3,14157737001877 3,14160788759689 diff: 3,0517578125E-05
n: 000262144 --\> 3,14158501543354 3,1416002742226 diff: 1,52587890625E-05
n: 000524288 --\> 3,14158883579482 3,14159646518935 diff: 7,62939453125E-06
n: 001048576 --\> 3,14159074514601 3,14159455984327 diff: 3,81469726606909E-06
n: 002097152 --\> 3,14159169952839 3,14159360687703 diff: 1,9073486328125E-06

mfg M.L.