[C/C++] Finite Differenzen / Implementierung einer Approximation

Dieses Thema im Forum "Programmierung & Entwicklung" wurde erstellt von iPoD.freaK, 25. Oktober 2012 .

Status des Themas:
Es sind keine weiteren Antworten möglich.
  1. 25. Oktober 2012
    Zuletzt von einem Moderator bearbeitet: 14. April 2017
    Finite Differenzen / Implementierung einer Approximation

    Moin Moin,

    studiere jetzt im ersten Semester CES und hab da auch "Einführung in die Programmierung" mit drinn.

    Haben jetzt unsere Wochenaufgabe bekommen, bei der wir die Berechnung einer Approximation implementieren sollen.

    Gegeben ist uns das folgende Blatt:

    Bild

    Habe hierbei folgende Probleme:
    1) Was genau macht eine Approximation -> was sollen wir dem Programm sagen, was es zu machen hat?
    2) Wie implementier ich das Ganze? Habe bisher folgendes:
    Code:
    #include <iostream>
    #include <cmath>
    using namespace std;
    int main(){
    
     // f(x)=sin(e^x)
     // f'(x)=e^x * cos(e^x)
     // Ansatz:
     // f'(x)=fs'(x)=[f(x+h1/2)-f(x-h1/2)]/h1
    
     double x;
     
     cout << "Bitte geben Sie zunächst einen Wert für x ein." << endl;
     cin >> x;
     
     double h1 = 1e-2;
     double f = sin(exp(x));
     double fhp = sin(exp(x+h1));
     double fhm = sin(exp(x-h1));
     double fs = exp(x) * cos(exp(x));
     double fsf = (fhp - fhm)/hc;
     
     cout << "Wert der Funktion f:" << f << endl;
     cout << "Wert der Ableitung f':" << fs << endl;
     cout << "Wert von fsf:" << fsf << endl;
     return 0;
    }
    Soweit funktioniert alles, sprich keine Fehler drinn. Wenn ich ganz ehrlich bin, versteh ich jedoch nicht, wofür das Ganze gedacht ist..

    Hoffe um Hilfe und NEIN ich bitte nicht darum, dass mir hier irgendwer n fertigen Quelltext o.Ä. gibt. Muss es ja schliesslich auch verstehen.

    mfg
     
  2. 25. Oktober 2012
    AW: Finite Differenzen / Implementierung einer Approximation

    Naja einem Computer die Algebra beizubringen erweist sich sehr oft als ein relativ schweres und komplexes Unterfangen und meistens ist nur der Wert hinter der Funktion gesucht, deswegen geht man den Weg der finiten Näherung.

    Dh. man versucht nicht wirklich die Funktion der Ableitung zu berechnen sondern geht einen einfachen weg und berechnet direkt den Wert der Ableitung.

    Aus einer Benutzereingabe f = sin(exp(x)) programiertechnisch fs = exp(x) * cos(exp(x)) zu generieren ist nicht einfach und bei komplexeren Funktionen auch eventuell gar nicht mehr möglich.

    Der Betrag von der Differenz von deinem fs und fsf ist der absolute Fehler. Mit kleiner werden h1 wird auch der Näherungsfehler fsf genauer (nur Abhängig der Genauigkeit von double).

    Wenn man nun eine andere beliebig komplexe Funktion f hat und möchte die Steigung an Position x wissen hat man mit dieser Technik schnell und einfach diesen Wert bestimmt.

    Mfg Rushh0ur
     
    2 Person(en) gefällt das.
  3. 25. Oktober 2012
    AW: Finite Differenzen / Implementierung einer Approximation

    Super, danke, das macht schon Mal Sinn! Nur was genau bedeutet die "Approximation"? Bedeutet ja genau genommen Näherung, aber in welchem Sinne? Extremwerte? Habe das Programm mal abgeändert, da das h1 schliesslich kleiner werden soll. Klappt soweit alles. Müsste doch vom Aufgabenansatz her richtig sein, oder?

    Code:
    #include <iostream>
    #include <cmath>
    using namespace std;
    int main(){
    
     // f(x)=sin(e^x)
     // f'(x)=e^x * cos(e^x)
     // Ansatz:
     // f'(x)=fs'(x)=[f(x+h1/2)-f(x-h1/2)]/h1
    
     double x;
     
     cout << "Bitte geben Sie zunächst einen Wert für x ein. Die Funktion lautet f(x) = sin(exp(x))." << endl;
    
     cin >> x;
     
     double h1 = 1e-2;
     double hmax = 1e-12;
     double fsf;
     int p = 1;
    
     double f = sin(exp(x));
     double fhp = sin(exp(x+h1));
     double fhm = sin(exp(x-h1));
     double fs = exp(x) * cos(exp(x)); 
     do
     {
     fsf = (fhp - fhm)/h1;
     cout << "Der Wert der Funktion im " << p << ". Durchlauf." << endl;
     p++;
     h1 = h1 / 1e1;
     
     cout << "Y-Wert der Funktion f: " << f << endl;
     cout << "Y-Wert der Ableitung f': " << fs << endl;
     cout << "Steigung im Punkt x: " << fsf << endl;
    
     double eabs = abs(fs-fsf);
    
     cout << "Absoluter Fehler: " << eabs << endl;
    
     double erel = (abs(fs-fsf))/(abs(fs));
    
     cout << "Relativer Fehler: " << erel << endl;
     cout << "---------------" << endl;
     cout << "Neues h: " << h1 << "." << endl << endl;
    
     cout << "#############################" << endl << endl;
    
     }while(h1 >= hmax);
     
     return 0;
    }
    
     
  4. 26. Oktober 2012
    AW: Finite Differenzen / Implementierung einer Approximation

    Sieht schon mal gut aus, du solltest aber noch die Berechnung von fhp und fhm in die schleife machen, die Werte sind ja von h1 abhängig welcher sich jede Runde ändert.

    Mit einem intelligentem Algorithmus kann man damit nicht nur die Steigung berechnen sondern unter anderem die Nullstellen, Wendepunkte und die von dir genannten Extrempunkte.

    Es ist auch im Prinzip nichts anderes was bei Geschwindigkeitsbestimmung verwendet wird, man nimmt innerhalb eines Zeitintervalls (h1) zwei rel. Entfernungen (fhp, fhm) auf und bestimmt damit die momentan Geschwindigkeit. (je kleiner h1 desto genauer die Bestimmung, ich schätze das sich h1 hierbei in dem ns-Bereich befindet).

    Es neben Finite Differenzen auch noch andere Ableger (Finite-Elemente) mit denen man sehr viele Sachen mit dem Computer simulieren und berechnen kann.

    Mfg Rushh0ur
     
  5. 26. Oktober 2012
    AW: Finite Differenzen / Implementierung einer Approximation

    Und um den Begriff "Approximation" nochmal einfach zu erklären:

    Eine Approximation ist eine Annäherung an den "echten" Wert.
    Mit jeder Iteration (Ein Durchgang durch do-while-schleife) wird dein Ergebnis besser. Und du iterierst eben solange bis dein Fehlerterm klein genug ist.
    Sprich man berechnet nicht direkt den richtigen Wert, sondern nähert sich langsam daran an.
     
    1 Person gefällt das.
  6. 31. Oktober 2012
    AW: Finite Differenzen / Implementierung einer Approximation

    Danke euch Beiden für die Erklärungen und Hilfestellungen Jetzt hab ich's endgültig Ich schliesse an dieser Stelle mal.
     
  7. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.