[C++] Programmfunktion?

[Trunestus]

Hallo,
Ich habe mich nun schon einige Zeit mit C++ beschäftigt und versuche nun eine Aufgabe zu lösen.
Diese ist die näherungsweise Berechnung von Pi durch Rechtecken.
Nunja, ich habe mir die Formel:
A = (x / s) * r * ((r^2 - (x / s)^2)*0.5) ausgearbeitet und stehe nun bei der Umsetzung vor folgendem Problem.
1. Ist eine Zahl zwischen 1 und s, die pro rechnung immer um eins erhöht wird, wie mach ich das?
2. Ich würde gerne für s (vom Benutzer) definiert jedesmal eine neue rechnung machen lassen, also an die vorherige die selbe formel nochmal addieren. Wie geht das?

Kann mir vllt auch jemand eine Lösung anbieten?

Vielen Dank im Voraus ;)

[Matthias Gubisch]

Komplettlösungen gibt es hier meistens nicht :) Selber denken ist die Devise

Einen kleinen Tipp kann ich dir aber geben
zu 1. Schau dir mal Schleifen die sollten hier helfen
bei 2. verstehe ich gerade nicht was du meinst, aber eventuell hilft dir die Schleife hier auch weiter

[Trunestus]

Das mit den Schleifen hat ich mir gedacht, aber ich kam nicht darauf welche Art von schleifen ich nehmen soll. ;P
Ich bin noch nicht so gut mit C++ und versuche noch schnell ein Programm für übermorgen auf die Beine zu stellen.

Ich meine das wenn s = 2 ist folgendes passiert:
A = (1 / 2) * r * ((r^2 - (1 / 2)^2)*0.5) + (2 / 2) * r * ((r^2 - (2 / 2)^2)*0.5)
Und bei s = 3
A = (1 / 3) * r * ((r^2 - (1 / 3)^2)*0.5) + (2 / 3) * r * ((r^2 - (2 / 3)^2)*0.5) + (3 / 3) * r * ((r^2 - (3 / 3)^2)*0.5)

[Matthias Gubisch]

Da sollte dir eine einfache for schleife weiterhelfen

Die Anzahl der Schleifendurchläufe ist das vom Benutzer vorgegebene s
s in der Rechung ist der wert der Schleifenvariable bei jedem Schleifendurchlauf.

Das Gesamtergebniss ist dann die Summe der Ergebnisse aller Schleifendurchläufe.

Wenn du eine Lösung hast kannst du sie gerne hier Posten dann bekommst du bestimmt noch ein paar gute Tipps was du besser machen könntest.

[Trunestus]

So,
Ich hab jetzt folgendes programmiert ->

Code: Alles auswählen

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{

    long double radius;
    long double streifen;
    long double xstelle;
    for (xstelle = 1; xstelle <= streifen;)

    cout << "Programm zur naeherungsweisen Berechnung von PI (3.14) via Streifen." << endl;
    cout << endl;
    cout << endl;
    cout << endl;
    cout << "Geben sie bitte hier den Radius (r) des Kreises an." << endl;
    cout << "Radius (r): ";
    cin  >> radius;
    cout << "Geben sie bitte hier die Anzahl der rechteckigen Streifen an." << endl;
    cout << "Streifenanzahl (s): ";
    cin  >> streifen;
    long double flaecheninhalt = (xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen)));
    cout << endl;
    cout << flaecheninhalt << endl;

    system("PAUSE");
    return 0;
}

Allerdings bekomm ich nicht hin das sich die flaecheninhalte addieren und das mit der schleife klappt auch nicht so ganz :/
Einer ne bessere Lösung?

[exploid]

huhu

gnihihi, hallo, :)

also

long double flaecheninhalt = (xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen)));

Ist dir klar, dass du hier immer den gleichen Wert berechnest und der Variable flaecheninhalt zuweist?
Deine Schleife hat keinen Schleifenzähler.
for (xstelle = 1; xstelle <= streifen; "Schleifenzähler fehlt")

weiterhin fehlen die Schleifengrenzen also Schleifenanfang "{" und Ende "}".

Ich hoffe ich konnte etwas helfen. :) :] *grins*

[Trunestus]

Ist dir klar, dass du hier immer den gleichen Wert berechnest und der Variable flaecheninhalt zuweist?
Deine Schleife hat keinen Schleifenzähler.
for (xstelle = 1; xstelle <= streifen; "Schleifenzähler fehlt")

weiterhin fehlen die Schleifengrenzen also Schleifenanfang "{" und Ende "}".

Ich hoffe ich konnte etwas helfen. :) :] *grins*

Wie ich berechne immer den gleichen Wert?
Ich versuche das sich die verschiedenen flaecheninhalte addieren ._.

Sobald ich inkrement (Schleifenzähler) und Schleifenbegrenzung ({}) mache, funktioniert nichts mehr an meinem Programm. ->

Code: Alles auswählen

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{

    long double radius;
    long double streifen;
    long double xstelle;
    for (xstelle = 1; xstelle <= streifen;xstelle++)
{
    cout << "Programm zur naeherungsweisen Berechnung von PI (3.14) via Streifen." << endl;
    cout << "Geben sie bitte hier den Radius (r) des Kreises an." << endl;
    cout << "Radius (r): ";
    cin  >> radius;
    cout << "Geben sie bitte hier die Anzahl der rechteckigen Streifen an." << endl;
    cout << "Streifenanzahl (s): ";
    cin  >> streifen;
    long double flaecheninhalt = (xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen)));
    cout << endl;
    cout << flaecheninhalt << endl;
}
    system("PAUSE");
    return 0;
}

Wäre echt nett wenn mir jemand den Code berichtigen und ergänzen würde ich komm da langsam nicht mehr hinter und bin mit meinem Latein am Ende :/

[joggel]

Code: Alles auswählen

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{

    long double radius;		
    long double streifen;	// welcher Wert bekommt hier <streifen> ?
    long double xstelle;	

    // und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen?
    for (xstelle = 1; xstelle<= streifen; xstelle++)
	{
		cout << "Programm zur naeherungsweisen Berechnung von PI (3.14) via Streifen." << endl;
		cout << "Geben sie bitte hier den Radius (r) des Kreises an." << endl;
		cout << "Radius (r): ";
		cin  >> radius;
		cout << "Geben sie bitte hier die Anzahl der rechteckigen Streifen an." << endl;
		cout << "Streifenanzahl (s): ";
		cin  >> streifen;
		long double flaecheninhalt = (xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen)));
		cout << endl;
		cout << flaecheninhalt << endl;
	}
    system("PAUSE");
    return 0;
}

Ob die Formel richtig oder falsch ist, weiß ich nicht...
*<[>:-\
Was ist denn Heute los? Ich lass es mal lieber ;)

[exploid]

Code: Alles auswählen

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{

    long double radius;        
    long double streifen;       // welcher Wert bekommt hier <streifen> ?
    long double xstelle;       

    
                cout << "Programm zur naeherungsweisen Berechnung von PI (3.14) via Streifen." << endl;
                cout << "Geben sie bitte hier den Radius (r) des Kreises an." << endl;
                cout << "Radius (r): ";
                cin  >> radius;
                cout << "Geben sie bitte hier die Anzahl der rechteckigen Streifen an." << endl;
                cout << "Streifenanzahl (s): ";
                cin  >> streifen;
        
        // und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
        for (xstelle = 1; xstelle<= streifen; xstelle++)
        {
                long double flaecheninhalt = flaecheninhalt + ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
        }       
        cout << endl;
        cout << flaecheninhalt << endl;
       
    system("PAUSE");
    return 0;
}

[Trunestus]

Okay das was ich genau machen möchte:
1. xstelle soll einen Wert zwischen 1 - streifen bekommen ( Wenn ich 4 streifen habe, dann 1, 2, 3, 4)
2. Er soll die rechnung mit den verschiedenen xstellen machen und diese dann addieren.
D.h. -> streifen = 2, dann hat xstelle den wert 1 und 2 und rechnet
A = (1 / 2) * r * ((r^2 - (1 / 2)^2)*0.5) + (2 / 2) * r * ((r^2 - (2 / 2)^2)*0.5)

Könnte mir das einer lösen? :/

Edit:
Ich finde in euren Codes nicht wirklich einen Unterschied zu meinem. :?:

[Punika]

Code: Alles auswählen

// und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
for (xstelle = 1; xstelle<= streifen; xstelle++)
{
long double flaecheninhalt = flaecheninhalt + ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
} 

Das ist natürlich auch nicht ganz richtig, wenn dann schon so:

Code: Alles auswählen

long double flaecheninhalt = 0;
// und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
for (xstelle = 1; xstelle<= streifen; xstelle++)
{
// flaecheninhalt = flaecheninhalt + ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
flaecheninhalt += ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
} 

[Trunestus]

Tut mir Leid, hab nicht aufgepasst :/
Sind ja nicht die gleichen Codes.

Also wenn ich beides compile komme ich trotzdem immer auf den Wert
flaecheninhalt = 0.1875
Da addieren sich die beiden flaecheninhalte nicht, also das was ich will.

Edit: Die Schleife soll von den Wert 1 - streifen haben.

[exploid]

hm,

Flächekreis = Pi * r²

=> Pi = Flächekreis/r²

Code: Alles auswählen

// und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
for (xstelle = 1; xstelle<= streifen; xstelle++)
{
long double flaecheninhalt = flaecheninhalt + ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
} 

Das ist natürlich auch nicht ganz richtig, wenn dann schon so:

Code: Alles auswählen

long double flaecheninhalt = 0;
// und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
for (xstelle = 1; xstelle<= streifen; xstelle++)
{
// flaecheninhalt = flaecheninhalt + ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
flaecheninhalt += ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));
} 

Die Ausdrücke sind äquivalent.

Was du aber machen solltest ist die ganzen Variablen zu beginn auf 0 setzen.

[exploid]

Flächekreis = Pi * r²

=> Pi = Flächekreis/r²

Im Einheitskreis ist r=1 d.h. im Einheitskreis ist die Fläche = PI

Ist das was deine Gleichung ausdrücken soll?

[Punika]

Wie oben schon erwähnt wurde, eine komplett Lösung kriegt man hier nicht. Was ich dir sagen kann ist, das die Schleife da oben wie eine Summe funktioniert. Und zwar die Summe die nach dem += steht. Inwieweit die Formel stimmt habe ich mir nicht angesehen.
Aber auch das solltest du jetzt hinbekommen können.

Noch als tip, ich hatte extra im Kommentar geschrieben was += heißt, falls du diese Schreibweise nicht kennst.


EDIT: Wieso sind die Ausdrücke gleich? Also bei mir ist das immer noch so, das wenn man eine Variable in der Schleife deklariert, die auch nur für die Schleife gilt, ein Guter Compiler müsste da auch schon meckern da du eigentlich sowas nicht schreiben darfst:
int i = i + 1; (Was soll dann bitte i sein??)

[exploid]

int i=0;
i = i + 1;

Dieser Code ist gleich dem folgenden! :)

int i=0;
i += 1;

[Punika]

Guck dir noch mal deinen Code an, also entweder spinnt hier mein Rechner oder du hast nicht
int i = 0; i = i + 1;
geschrieben sondern int i = i + 1;

Deine Beschreibung hatte ich ja oben erwähnt und hatte ich nur hingeschrieben da ein Anfänger vielleicht nicht unbedingt das += kennt oder interpretieren kann...

[Trunestus]

Ähhm.
Irgendwie komme ich nicht dahinter was das ganze mit meinem Problem zu tun hat?
Ich muss die flächeninhalte s(treifen)-fach addieren und zwar jedesmal mit einem neuen Wert als die xstelle (immer +1)
Bsp.
geg.
radius = 1
streifen = 2

xstelle hat also den Wert 1 und 2.
Diese Werte setze ich nun in die Formel ein:
flaecheninhalt = ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))))
flaecheninhalt = ((1/2)*1*(0.5((1*1)-(1/2)*(1/2))))) ;|; flaecheninhalt = ((2/2)*1*(0.5((1*1)-(2/2)*(2/2)))))
Und dann muss ich die beiden flächeninhalte addieren.
((1/2)*1*(0.5((1*1)-(1/2)*(1/2))))) + ((2/2)*1*(0.5((1*1)-(2/2)*(2/2)))))

So soll die Rechnung von statten gehen.

@exploid: Ja genau soll das ausdrücken, es ist eine näherungsweise Berechnung von PI!
@Punika: Ich würde nur gerne eine Lösung für mein Problem mit der Schleife (oben im Post) bekommen, mehr brauch ich ncht.

[exploid]

Schau dir bitte mal folgende Seite an und versuche alle so gut wie möglich zu verstehen dann wird dir auch deine eigene Aufgabe klar:

http://www.edu-bl.ch/handr/h08_diezahlp ... ne/pi.html

[Trunestus]

Tut mir leid, aber den Source-Code der dort angegeben ist, ist für mich nicht nachvollziehbar :/

[Punika]

Noch ein Versuch:

Code: Alles auswählen

long double gesamter_flaecheninhalt = 0;
// und von welchem Wert bis zu welchem Wert soll hier die Schleife laufen? 
for (xstelle = 1; xstelle<= streifen; xstelle++)
{
  // das ist die flaeche für jeweils xstelle die z.B. bei streifen 2  -> 1 und 2 ist (heißt die schleife wird zweimal ausgeführt mit jeweils xstelle 1 und dann bei)
  long double x_stelle_flaecheninhalt = ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));

   gesamter_flaecheninhalt += x_stelle_flaecheninhalt;
   // bedeutet = gesamter_flaecheninhalt = gesamter_flaecheninhalt + x_stelle_flaecheninhalt;
   // bedeutet im oben genannten fall 0 + x_stelle_flaecheninhalt(1) + x_stelle_flaecheninhalt(2) wobei hier x_stelle_flaecheninhalt(...) heißt das du jeweils wie oben beschrieben die den flaecheninhalt für die x_stelle berechnet hast.
   // überlege einfach mal einfacher 0 + 2 + 4 = 6 wobei du aber ja auch schreiben könntest
   // x = 0;
   // x + 2 = 2;
   // x + 4 = 6;
   // weiß nicht wie ich dir das brett vorm kopf nehmen kann
    gesamter_flaecheninhalt += x_stelle_flaecheninhalt;
} 

[exploid]

Hallo

Erklärung:
Um PI numerisch zu bestimmen ist es möglich dies am Einheitskreis zu tun. Die Fläche des Einheitskreises entspricht PI.
Funktionsgleichung:
Du kannst, um die Dinge zu vereinfachen, ein Viertel des Kreises betrachten und später das Ergebnis mit 4 multiplizieren. Funktionsgleichung ist für den positiven Teil
y = sqrt(1-x²) Information: sqrt => angelsächsisch für square root auf deutsch "Wurzel"
Mit dieser Gleichung bekommst du in Abhängigkeit vom x-Wert die Höhe eines Rechtecks. Jetzt musst du alle Rechtecke im Intervall addieren und n dabei so klein wie hinreichend nötig wählen. Theoretisch liefert n als infinitesimal also unendlich klein den exakten Wert für PI. Das ganze wurde in dem C-Programm in dem oben angegebenen Link so programmiert.

[exploid]

Die Rechtecksfläche ergibt sich mit dn * f(x) wobei f(x) = sqrt(1-x²) ist und dn ist die Rechtecksbreite. Die Summe alle Rechtecke ergibt dann PI/4. o.O Das ist Integralrechnung das ist nicht so kompliziert wie es sich liest.

[exploid]

blah, das war falsch daher gelöscht :) sorry

[exploid]

http://www.cplusplus.com/reference/clibrary/cmath/pow/

for (k= 1; k <= n - 1; k++)
{
sum+= sqrt (1.0 - pow (((double) k)/((double) n), 2.0));
}

Die Summierung aller Flächen erfolgt mit diesem Codesegment. Pow[(k/n),2] => (k/n)² ist unser x² wobei k/n der entsprechenden Streifenwert für unser x symbolisiert, der Abszissenwert also der x-wert eines Streifensegments, der "x-Wert-Zähler" für unsere zu summierenden Rechtecke. Intervallgrenzen: k/n => [0..1] aaargh o.O, das Ergebnis also sum ist dann ein Viertel der Fläche des Einheitskreises das später mit 4 multipliziert PI ergibt:

printf ("\n %8d %lf %lf", n, 4.0*ai, 4.0*aa); // <= HIER *4 *4 *4

Der Protagonist, also der Autor der oben angegebenen Seite, ist denke ich ein Lehrer, hat zwei Summen berechnet: Eine Obersumme und eine Untersumme. Warum? Weil man die Rechtecke in zwei möglichen Weisen definieren kann und beide sind fehlerbehaftet. Sie sind beide falsch! Erst wenn unsere Streifenbreite unendlich klein wird, verschwindet der Fehler und wird unendlich klein. o.O AARgh. Man nennt diese unendlich kleinen Werte die es oft gibt in der Integral und Differentialrechnung Infinitesimale. Das ist etwas unendlich kleines, es ist aber nicht 0 :) sondern 0,000..... unendliche viele Nullen ....1, bizarrr, also eine 1 am Ende aller Stellen im Unendlichen. LOL, das ist ein Infinitesimal üblicherweise in der Schreibweise mit einem kleinem "d" vor einem Buchstaben: (dx,dy,dz,dt)

[exploid]

Hallo

Ich bin es noch mal. Der Hintergrund warum du diese Aufgabe lösen willst ist mir nicht bekannt.
Schneller wär es wenn du das Integral im entsprechenden Intervall 0-1 lösen würdest für:
Integral [sqrt(1-x²)dx]. Das Ergebnis mit vier multipliziert ist ebenfalls PI.

update 23.11.12 13:28 MEZ winter:
Ich weiss es wird dir nicht helfen aber ich schreibs trotzdem um anzugeben und zu zeigen, dass ich Mathematica bedienen kann.
\($$\int \text{sqrt}\left[1-x^2\right] \, dx= \frac{1}{2} \left(x \sqrt{1-x^2}+\text{ArcSin}[x]\right)+C$$\)
= Integral[sqrt(1-x²) dx] = 1/2 * [x*sqrt{1-x²}+ArcSin(x)] + C

Für die Grenzen des Intervalls gilt für das unbestimmte Integral:
für x im Intervall 0 bis 1 als x=>[0..1] also für 1/4 des Einheitskreises
1/2 * [0*sqrt{1-0²}+ArcSin(0)] + C = C
1/2 * [1*sqrt{1-1²}+ArcSin(1)] + C= PI/4 + C
PI/4 + C - (0 + C) = PI/4
QED
Im Einheitskreis ist die Fläche = PI => HURRAAAA

ps: sorry für das ganze "rumgeändere" => Versuche mit latex

[Jonathan]

Die Schnellste Lösung ist natürlich, Pi irgendwo abzuschreiben.
Die Meiner Meinung nach coolste Lösung sind allerdings die BBP-Reihen, mit denen man beliebige Ziffern von Pi unabhängig voneinander bestimmen kann: http://de.wikipedia.org/wiki/Kreiszahl#BBP-Reihen

[Trunestus]

Hallo,
Vielleicht hätte ich noch sagen müssen das ich in die 10 Klasse gehe ;P
Die Lösungsansätze versteh ich nur zum Teil, irgendwie (noch) nicht mein Ding.
Ich habe schon 1/4 von PI genommen, und lasse mir das ergebniss am ende mit 4 und 2 multiplizieren.

Code: Alles auswählen

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{

long double radius;
long double streifen;
long double xstelle;


cout << "Programm zur naeherungsweisen Berechnung von PI (3.14) via Streifen. " << endl;
cout << "Geben sie bitte hier den Radius (r) des Kreises an." << endl;
cout << "Radius (r): ";
cin >> radius;
cout << "Geben sie bitte hier die Anzahl der rechteckigen Streifen an." << endl;
cout << "Streifenanzahl (s): ";
cin >> streifen;

long double gesamter_flaecheninhalt = 0;
for (xstelle = 1; xstelle<= streifen; xstelle++)
{

long double x_stelle_flaecheninhalt = ((xstelle / streifen) * radius * (0.5*((radius * radius) - (xstelle / streifen) * (xstelle / streifen))));

gesamter_flaecheninhalt += x_stelle_flaecheninhalt;

}
cout << endl;
long double ergebnis = (gesamter_flaecheninhalt * 4) * 2;
cout << "Das Ergebnis ist: " << ergebnis << endl;

system("PAUSE");
return 0;
}

Wenn ich aber nun die Werte Radius = 1 und Streifen = 4 benutze sollte eig. als Lösung annährungsweise PI rauskommen, was es ja auch tut es sind dann 3.75 als Ergebniss. Wähle ich aber nun Radius = 1 und Streifen = 2500 (*4 dann sinds am ende 10000 streifen), dann kommt als Ergebniss 2500 raus, wobei doch eig schon näher an PI sein sollte (Zwischen 3.14 und 3.75 sollte es doch sein).
Ich glaube mittlerweile das die Schleife funktioniert da:
((1/4)*1*(0.5((1^2)-(1/4)^2))) + ((2/4)*1*(0.5((1^2)-(2/4)^2))) + ((3/4)*1*(0.5((1^2)-(3/4)^2))) + ((4/4)*1*(0.5((1^2)-(4/4)^2))) = 0.46875
0.46875 * 4 = 1.875
1.875 * 2 = 3.75
sind, also genau das was das Programm ausgibt ;)
Nun sollte es aber auch noch die richtigen Werte ausgeben...
und nicht =
Radius = 1
Streifen = 2500 (*4 dann sinds am ende 10000 streifen)
Ergebniss = 2500

Wo liegt mein Fehler?
Ist das jetzt ein Denkfehler?

Hintergrund ist das wir in der Schule Gerade Aufgaben für eine Arbeit üben und wir dann für diejenigen die den Mathe Leistungskurs wählen so "schwere" Aufgaben ausgewählt bekommen haben, die wir mit unserem Wissen über Sinus, Kosinus und Tangens (Sinussatz, Kosinussatz) lösen _können_ sollten und ich dies genau mit einem Programm machen wollte und dazu auch die Erlaubnis bekam. ;)

[exploid]

Hallo

hm, also wir sollen deine Hausaufgaben lösen? gnihihihihi, OKAY!
Ich versteh deine Gleichung nicht die als Fläche PI ergeben soll.
habs mal für mich persönlich vereinfacht so geschrieben:
A = x/n * r * 1/2 * [r²-(x/n)²]
Kannst du die mal bitte herleiten? Am Besten mit Zeichnung.

[eXile]

\($$\lim_{s \to \infty} \frac{4r}{s} \sum_{x=0}^{s-1} \sqrt{r^2 - \Big( \! \frac{rx}{s} \! \Big)^2} = \pi r^2$$\)