Thema: Hilfe bei C++ Programm

Moin Moin,
hätte mal eine kleine Frage zu meiner Belegarbeit in Info:

1. Was ist ein Konvergenzbereich?
2. Woran erkenne ich wie groß epsilon werden muss?
   

Aufgabe: http://www.tu-chemnitz.de/informatik...eleg/index.php

1. Du bist vllt. schon selber drauf gekommen aber ich finde, dass der Konvergenzbereich auf Wikipedia gut erklärt ist:
Konvergenzbereich

2. Das mit epsilon versteh ich gerade nicht so wirklich :/

3. Ja.
Bei der Funktion "fakultaet" gibst du den Wert als Double zurück, ich denke Nachkommerstellen kann man sich da aber sparen. Zwar kein Fehler in dem Sinne aber überflüssig.

Die Fakultät würde ich an sich glaube so berechnen und nicht ständig die Funktion neu aufrufen:

Code:

int erg=1;

for (int i;i==1;i--)
    erg *= i;

Code ist zwar nicht getestet aber sollte funktionieren.

Außerdem fällt mir auf, dass du die pow Funktion benutzt, welche ja x^y berechnet, ich denke das ist aber auch ein Teil der cmath und das dürftest du ja dann nicht verwenden, oder?! ^^

fabs() könntest du außerdem auch leicht realisieren und dann sparst du dir die cmath komplett.

Code:

float own_fabs(float x)
{
    if (x < 0)
        x *= -1;

    return x;
}

Hoffe das hilft etwas

Dank erstmal für die Hilfe.

Der Konvergenzbereich ist also eine Art Definitionsbereich, so wie ich das aus der Wikipedia herauslese, oder (0<|x|<Pi, wäre dann also richtig)?

Die Geschichte mit dem Epsilon und dem "pow" werd ich kommende Woche nochmal nachfragen, ich bin ja nicht der einzige der das machen muss.

Also ich habe deinen Code mal in Codeblocks gehauen und bekomme für jegliches x das ich eingebe nur das Ergebnis laut Standardfunktion, der Teil mit "Ergenis laut Bernoulli-Summenformel..." wird gar nicht angezeigt.
http://www.abload.de/image.php?img=unbenanntj73y3.jpg
Weiterhin initialisiert du zwar die Variablen "epsilon" und "B" aber weißt ihnen nirgends einen Wert zu, vllt. verstehe ich das zumindest bei "B" nicht, da ich mathematisch nicht ganz so extrem bewandert bin. Daher macht deine if-Abfrage auf

Code:

epsilon > 100000

bzw. da du epsilon sonst nirgends im Code verwendest (inkrementierst oder sonst was) das

Code:

else epsilon < 100000

keinen Sinn für mich.
"pow" gehört ansonsten genauso wie "fabs" zur cmath, das kannst du dann aber auch so wie fabs selber realisieren (nur jetzt theoretisch, Code ist nicht getestet):

Code:

float own_pow(float x,float y)
{
float z;
z = x^y;
return z;
}

Ich hoffe ich habe jetzt nicht totalen Mist verzapft und konnte helfen


MfG

Zitat von DarthDeeger

"pow" gehört ansonsten genauso wie "fabs" zur cmath, das kannst du dann aber auch so wie fabs selber realisieren (nur jetzt theoretisch, Code ist nicht getestet):

Code:

float own_pow(float x,float y)
{
float z;
z = x^y;
return z;
}

Ich hoffe ich habe jetzt nicht totalen Mist verzapft und konnte helfen

Leider hast du Mist verzapft...

x^y bedeutet eine bitweise xor-Verknüpfung von x und y, nicht "x hoch y".

Wenn du eine entsprechende Funktion selbst schreiben musst, wird dir für den allgemeinen Fall nicht viel übrig bleiben als die folgende Regel zu verwenden:
pox(x,y) = exp(y * ln(x))

exp() ist dabei die natürliche Exponentialfunktion (auch e-Funktion) und ln() der natürliche Logarithmus. Beide kannst du mit Reihenentwicklungen näherungsweise berechnen.
(Allerdings kommt der Term x^k (hier ist Potenzieren gemeint, nicht xor) vor, aber k ist eine natürliche Zahl, kann also mit einer einfachen Hilfsunktion leicht berechnet werden, genauso wie Fakultät)

Falls du die pow Funktion wirklich selber schreiben musst (was ich eigentlich nicht glaub), reicht auch ne ganz triviale rekursive/iterative Lösung ohne böse Formeln; denn deine Exponenten sind immer ganzzahlig. Aber das hast du ja schon geschrieben klärst du ab.

Konvergenzbereich wurde ja schon erklärt (grob und eigentlich auch falsch gesagt: "Nur in dem Bereich funktioniert die Formel").

Das Epsilon verwendest du, um "zu schauen ob sich das Ergebnis überhaupt noch so großartig ändert, dass sich weitere Berechnungen noch rentieren": Das ist eben nicht der Fall, wenn zwei aufeinanderfolgende Werte einen Unterschied kleiner als Epsilon aufweisen. Ich denke aber, ihr bekommt das Epsilon vorgegeben; letztenendens ist's ja sowas ÄHNLICHES wie die Genauigkeit.

Ansonsten mal ein paar Kommentare:

Code:

     if (epsilon < 100000)  ///Ist Quatsch, dein epsilon wird einen sehr kleinen wert haben. Außerdem musst du schauen, ob zwei aufeinanderfolgende Glieder sich um einen Betrag kleiner als Epsilon unterscheiden! Siehe hier
     {
         for (n=0; n>12; n++) //Die Schleife ist falsch. n wird auf 0 initialisiert, und die Schleife wird solange ausgeführt wie n GRÖßER als 12 ist!
         cout << "Das Ergebnis mittels Summenformel lautet x = " << (pow(-1,n+1)*pow(2,2*n)/fakultaet(2*n))*B*pow(x,2*n-1);  //Summenformel heißt, dass du etwas aufaddierst. Hier addierst du aber nichts. Du musst immer die einzelnen Glieder aufsummieren, wie hier hier beschrieben. Dazu brauchst du i.d.R. eine Variable. Hier musst du auch irgendwie das mit dem Epsilon managen!
     }
     else
     {
         epsilon > 100000;
         cout << "Der Abbruchwert wurde überschritten";
     }

Hast du die Formel mal auf dem Papier selber ausgeführt? Denk dabei werden eventuelle Unklarheiten schnell beseitigt!

Gruß
Matthias

Hoff ich hab nich zu viel Mist verbockt, ist aber noch so früh am morgen

Warum macht ihr euch son Stress?

Soweit ich das gesehen/verstanden habe, kann er auch einfach ne for-Schleife machen. Quick&Dirty nenn ich das, aber es geht ohne Probleme.

Danke erstmal für die vielen Antworten, ich hab noch bissl dran rum gebaut:

1. hab eigene Pow geschrieben (verbesserungwürdig )
2. habe ein Feld angelegt in dem die Bernoulli-Zahl und das zugehörige n steht
3. Epsilon ist noch immer irgendwie unklar ... könnte sein das es durch den Nutzer des Programmes eingegeben werden soll

Das Programm liefert noch ein paar irritierende Ergebnisse

Ich hab mal bischen was geändert

Code:

#include <iostream>
#include <cmath>

using namespace std;

double potenz(double basis, int exponent) // Funktion für Potenz (keine Exponenten <0 möglich){
if(exponent==0){
  double v = 1;
}
else{
  if(exponent>0){
       double v = basis;
       for (int j = 1; j < exponent; j++){
      v *= basis;
       }
  }
}

return v;
}

double fakultaet (int i) // Funktion für Fakultät
{
    float erg;
    if (i <= 0)
    return 1;
    erg = i * fakultaet(i-1);
    return erg;
}

int main()

{
double x, y;
int n;
const double Pi=3.14159265;
double epsilon;
double cosh (double x);
double sinh (double x);

double B[12][2] =
{
//{n, Bernoulli}
{1, 1.0/6.0},
{2, 1.0/30.0},
{3, 1.0/42.0},
{4, 1.0/30.0},
{5, 5.0/66.0},
{6, 691.0/2730.0},
{7, 7.0/6.0},
{8, 3617.0/510.0},
{9, 43867.0/798.0},
{10, 174611.0/330.0},
{11, 854513.0/ 138.0},
{12, 236364091.0/2730.0}
};

cout << "Berechnung des coth(x) mit Bernoulli Summenformel und Standartfunktionen aus cmath" "\n";
cout << "Geben Sie x ein:";
cout << "\nx = ";
cin >> x;

if (fabs(x) < 0,fabs(x) > Pi)
    {
        cout << "Bitte x erneut eingeben (Konvergenzbereich 0<|x|<Pi)";
    }
    if (epsilon < 0.000001)
    {
        for (n=1; n<=12; n++)

        y = (potenz(-1,n+1) * potenz(2,2*n) / fakultaet(2*n)) * (**(B)) * potenz(x,2*n-1);

        cout << "Das Ergebnis mittels Summenformel lautet y = " << y << "\n";
    }
    else
    {
        epsilon > 0.000001;
        cout << "Der Abbruchwert wurde überschritten";
    }

if (fabs(x) < 0,fabs(x) > Pi)
    {
        "Bitte x erneut eingeben (Konvergenzbereich 0<|x|<Pi)";
    }
    else
    {
    cout << "Das Ergebnis mittels Standartfunktionen lautet y = " << cosh(x)/sinh(x);
    }
    return 0;
}

Und man sieht, du hast die SAche mit Epsilon nicht verstanden...

Hast du keine Analysis gehört? Wenn nein, schau dir bitte Konvergenzbedingungen von Folgen und Reihen an. Was du da machst ist ja nichts anderes als eine Reihenentwicklung des coth an der Stelle x...

Bitte bitte bitte nimm dir nen Analysis Buch und schau dir das an. Wenn du es nicht kapierst, kannst du auch gern Fragen, aber du weißt überhaupt nicht, ein Epsilon ist.

PS: Epsilon-Umgebung oder Epsilon-Delta-Umgebung sind zwei gute Stichworte, für das was du hier machen sollst, wobei Epsilon-Delta schon wieder weitergehend ist. Für dich lang eigentlich die Betrachtung einer Epsilon-Umgebung.

Ich glaub ich werde das Programm erstmal ohne das Epsilon erstellen, weil ich erstmal vernünftige Funktionswerte brauche und die kriege ich mit den 12 Summengliedern.
@Skysnake:
Nein ich hatte noch keine Analysis Vorlesung, die kommt erst im zweiten Semester. Dein Vorschlag zur Verbesserung der Pow Funktion, will bei mir nicht so richtig funktionieren. Er sagt mir ständig als Ergebnis für x^0 ist NaN (Not a Number).Mir ist grad noch aufgefallen, die Exponenten, der jeweiligen Summenglieder sind sowieso immer positiv, deshalb brauch ich das eigentlich nicht.

Das Hauptproblem wird wohl in der Eingabe der Summenformel liegen. Ich hab mir bereits mal die Mühe gemacht und die einzelnen Glieder eingegeben, so kriege ich vernünftige Werte, aber das ist nicht Sinn der Sache, zumal ich dann Probleme beim Zahlenraum bekomme.