www.vorhilfe.de
- Förderverein -
Der Förderverein.

Gemeinnütziger Verein zur Finanzierung des Projekts Vorhilfe.de.
Hallo Gast!einloggen | registrieren ]
Startseite · Mitglieder · Impressum
Forenbaum
^ Forenbaum
Status VH e.V.
  Status Vereinsforum

Gezeigt werden alle Foren bis zur Tiefe 2

Navigation
 Startseite...
 Suchen
 Impressum
Das Projekt
Server und Internetanbindung werden durch Spenden finanziert.
Organisiert wird das Projekt von unserem Koordinatorenteam.
Hunderte Mitglieder helfen ehrenamtlich in unseren moderierten Foren.
Anbieter der Seite ist der gemeinnützige Verein "Vorhilfe.de e.V.".
Partnerseiten
Weitere Fächer:

Open Source FunktionenplotterFunkyPlot: Kostenloser und quelloffener Funktionenplotter für Linux und andere Betriebssysteme
Forum "stochastische Prozesse" - C++: Heston Modell-Zhu Scheme
C++: Heston Modell-Zhu Scheme < stoch. Prozesse < Stochastik < Hochschule < Mathe < Vorhilfe
Ansicht: [ geschachtelt ] | ^ Forum "stochastische Prozesse"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien

C++: Heston Modell-Zhu Scheme: Wo ist mein Fehler?
Status: (Frage) beantwortet Status 
Datum: 15:25 Do 31.03.2011
Autor: timyyyyyy

Aufgabe
// HESTON MODELL - Transformed Volatility Scheme - Moment Matching Method

#include <cmath>
#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <ctime>

using namespace std;

// Eingabe der Parameter für die Optionsberechnung:
double T=6;                       // Laufzeit der Option
double K=70;                      // Strike
double S0=100;                    // Startkurs Basiswert
double Vola=0.15;                 // Start-Vola (sigma)
double r=0.04;                    // risikoloser Zins (c.c.)
double Speed=2;                   // Stärke des Mean Reverse (kappa)
double meanVar=0.16;              // durchscnittliche langfristige Varianz (theta)
double VolVol=0.3;                // Die Volatilität der Varianz des Underlying (xi)
unsigned long Pfade=20000;        // Anzahl Akitenpfad-Simulationen
double KnotenProJahr=32;          // Anzahl der unterjährigen Kursbeobachtungen (time steps)
double p=(-0.5);                  // Korrelation der ZVen zwischen Basiswert und Volatilität (rho)
// Ende Parametereingabe

double Var;                                 // Varianz des Basiswertes
double KnotenGesamt=KnotenProJahr*T;        // Anzahl der gesamten Kursbeobachtungen über gesamte Laufzeit
double t=(1/KnotenProJahr);                 // Dauer zwischen den Knoten (in Jahren)


// 1. Generierung normalverteilter Zufallszahlen
double NVZV()
{
       double result;
       double x;
       double y;
       double sizeSquared;
       do
       {                
       x = 2.0000*rand()/static_cast<double>(RAND_MAX)-1; // erstellt GVZV von -1 bis +1
       y = 2.0000*rand()/static_cast<double>(RAND_MAX)-1;
       sizeSquared = x*x + y*y;
       }
       while
       ( sizeSquared >= 1.0000);
       while
       ( sizeSquared <= 0.0000);
       result = x*sqrt(-2*log(sizeSquared)/sizeSquared);
       return result;
}
// Ende 1.


// 2. Monte-Carlo-Simulation
double MonteCarlo
(double T,
double K,
double S0,
double Vola,
double r,
double KnotenGesamt,
unsigned long Pfade)
{
    
         double Summe=0;
        
         double ST; // Aktienendkurs      
    //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  
         for(unsigned long i=0; i <Pfade; i++) // Anzahl der Simulationen
         {
              double PerformanceKnoten;
              double PerformanceGesamt=1;
                                                          
   //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  
                  for(unsigned long i=0; i <KnotenGesamt; i++) // Anzahl der Knoten
                 {
                  Var=Vola*Vola;
                  double Z=NVZV();
                  double q=1-(p*p);
                  double W= sqrt(q)*NVZV() + p*Z;
                                              
                  PerformanceKnoten=exp(((r- 0.5*Var)*t)+(sqrt(t)*Vola*Z));
                  PerformanceGesamt *= PerformanceKnoten;
                                        
                  double alpha = meanVar+(Var-meanVar)*exp(-Speed*t)-(VolVol*VolVol/(4*Speed)*(1-exp(-Speed*t)));
                  alpha = alpha >0 ? alpha : 0;                
                  double beta = sqrt(alpha);
                  double mmm= (beta-Vola*exp(-0.5*Speed*t))/(1-exp(-0.5*Speed*t));     // mmm = moment matched mean level
                                                            
                  Vola += (0.5*Speed*(mmm - Vola)*t) + (0.5*VolVol*sqrt(t)*W);      
        
                                          }                                            
  //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    
                      ST=S0*PerformanceGesamt;    
                      double Auszahlung = ST - K;
                      Auszahlung = Auszahlung >0 ? Auszahlung : 0;
                      Summe += Auszahlung;                        
      
         }
   //xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx      
         double average = Summe / Pfade;
         average *= exp(-r*T);
         return average;
}
// Ende 2.






// Hauptprogramm:
int main()
{
                                                                  // START UHR
                                                                  [mm] clock_t [/mm] start, end;
                                                                  double dif;
                                                                  start = clock();  
            
        // Start: für zeitabhängig generierte Zufallsvariablen
         long n = time(0);
         srand(n);
         // Ende:  für zeitabhängig generierte Zufallsvariablen
                                  
            
double Ergebnis = MonteCarlo(T, K, S0,  Vola, r, KnotenGesamt, Pfade);
cout << "Der Preis der Call-Option beträgt: " <<Ergebnis << " EUR"  << endl << endl;
                  
                                                                     // Ende Uhr
                                                                     end = clock();
                                                                     dif = double (end - start) / CLOCKS_PER_SEC;
                                                                     cout << "Benoetigte Zeit: " << dif << "s" << endl;
cout <<endl<<endl<<endl<<endl<<endl;




system("PAUSE");                  
}

Hallo zusammen,

zur zuordnung:
meine erste Schwierigkeit: Ich weiss nichtmals ob das Thema richtig zugeordnet ist. Es handelt sich um Optionsbewertung mit stochastischen Volatilitätsmodellen (also hab ich es unter stoch. Prozesse gepackt.)
Aber es ist auch ein diskretisiertes Modell, welches über die numerische Mehtode der Monte Carlo Simulation ermittelt wird. Daher k.a. ob ich es besser unter Numerik oder Diskretes hätte packen sollen.^^

zum inhalt:
Ich habe in C++ (programmierung siehe oben) das Heston Modell zwecks Bewertung einer einfach Call-Option programmiert mit einer Monte Carlo Simulation. Diskretisiertiert habe ich es mit "the transformed volatility scheme" von Zhu mit der moment-matching methode.
Nun mein Problem: Ich habe die gleichen Parameter gewählt wie Zhu in seinem Paper. aber während bei ihm preise von rund 47 rauskommen, erhalte ich immer preise um die 56. ich find aber den fehler in meiner programmierung nicht und wäre für eure hilfe sehr dankbar!!!!
(ich weiss ist sehr spezifisch. k.a., ob mathematiker mit C++ und so speziellen gebieten vertraut sind.)

zum mir: ich bin bwl'er und habe daher für gewöhnlich nichts mit programmiersprachen am hut. daher bitte ich um nachsicht für meinen vllt. schlechten programmier-stil. mir gings bisher nur darum, dass es funktioniert.^^ (was es bei einfacheren Modellen ja auch tat.)
ich hab mir C++ nur selber in ein paar wochen beibringen müssen (ohne irgend eine andere sprache zu können).

VIELEN DANK im voraus!!!
wäre klasse,  falls jdm den Fehler finden könnte!

grüße
tobias

(Ich habe diese Frage in keinem Forum auf anderen Internetseiten gestellt.)

        
Bezug
C++: Heston Modell-Zhu Scheme: Antwort
Status: (Antwort) fertig Status 
Datum: 09:52 Di 05.04.2011
Autor: felixf

Eingabefehler: "{" und "}" müssen immer paarweise auftreten, es wurde aber ein Teil ohne Entsprechung gefunden (siehe rote Markierung)

Moin!

> // HESTON MODELL - Transformed Volatility Scheme - Moment
> Matching Method
>  
> #include <cmath>
>  #include <cstdlib>
>  #include <iostream>
>  #include <stdio.h>
>  #include <math.h>
>  #include <ctime>
>  
> using namespace std;
>  
> // Eingabe der Parameter für die Optionsberechnung:
>  double T=6;                       // Laufzeit der Option
>  double K=70;                      // Strike
>  double S0=100;                    // Startkurs Basiswert
>  double Vola=0.15;                 // Start-Vola (sigma)
>  double r=0.04;                    // risikoloser Zins
> (c.c.)
>  double Speed=2;                   // Stärke des Mean
> Reverse (kappa)
>  double meanVar=0.16;              // durchscnittliche
> langfristige Varianz (theta)
>  double VolVol=0.3;                // Die Volatilität der
> Varianz des Underlying (xi)
>  unsigned long Pfade=20000;        // Anzahl
> Akitenpfad-Simulationen
>  double KnotenProJahr=32;          // Anzahl der
> unterjährigen Kursbeobachtungen (time steps)
>  double p=(-0.5);                  // Korrelation der ZVen
> zwischen Basiswert und Volatilität (rho)
>  // Ende Parametereingabe
>  
> double Var;                                 // Varianz des
> Basiswertes
>  double KnotenGesamt=KnotenProJahr*T;        // Anzahl der
> gesamten Kursbeobachtungen über gesamte Laufzeit
>  double t=(1/KnotenProJahr);                 // Dauer
> zwischen den Knoten (in Jahren)
>  
>
> // 1. Generierung normalverteilter Zufallszahlen
>  double NVZV()
>  {
>         double result;
>         double x;
>         double y;
>         double sizeSquared;
>         do
>         {                
> x = 2.0000*rand()/static_cast<double>(RAND_MAX)-1; //
> erstellt GVZV von -1 bis +1
>         y = 2.0000*rand()/static_cast<double>(RAND_MAX)-1;
>         sizeSquared = x*x + y*y;
>         }
>         while
>         ( sizeSquared >= 1.0000);
>         while
>         ( sizeSquared <= 0.0000);

Das tut sicher nicht was du willst: du hast hier eine do-while-Schleife, die wiederholt wird wenn sizeSquared >= 1 ist, und danach eine while-Schleife die solange durchgefuehrt wird wie sizeSquared <= 0 ist und die nichts tut.

Du willst eher eine do-while-Schleife haben mit der Wiederholungsbedingung ((sizeSquared >= 1) || (sizeSquared <= 0))Eingabefehler: "{" und "}" müssen immer paarweise auftreten, es wurde aber ein Teil ohne Entsprechung gefunden (siehe rote Markierung)

.

>         result = x*sqrt(-2*log(sizeSquared)/sizeSquared);
> return result;
>  }
>  // Ende 1.

Zur Info fuer alle, die es interessiert: das ist die []Polar-Methode zur Erzeugung von normalverteilten Zufallswerten.

> zur zuordnung:
>  meine erste Schwierigkeit: Ich weiss nichtmals ob das
> Thema richtig zugeordnet ist. Es handelt sich um
> Optionsbewertung mit stochastischen Volatilitätsmodellen
> (also hab ich es unter stoch. Prozesse gepackt.)
>  Aber es ist auch ein diskretisiertes Modell, welches über
> die numerische Mehtode der Monte Carlo Simulation ermittelt
> wird. Daher k.a. ob ich es besser unter Numerik oder
> Diskretes hätte packen sollen.^^

Ich denke hier passt es schon ganz gut.

> zum inhalt:
>  Ich habe in C++ (programmierung siehe oben) das Heston
> Modell zwecks Bewertung einer einfach Call-Option
> programmiert mit einer Monte Carlo Simulation.
> Diskretisiertiert habe ich es mit "the transformed
> volatility scheme" von Zhu mit der moment-matching
> methode.

Wie geht diese Methode denn?

>  Nun mein Problem: Ich habe die gleichen Parameter gewählt
> wie Zhu in seinem Paper.

Ein Link bzw. genauer Verweis auf das Paper waer nicht schlecht. Ansonsten kann man dir wirklich nicht so einfach helfen.

> (Ich habe diese Frage in keinem Forum auf anderen
> Internetseiten gestellt.)

Das stimmt nicht, du hast die Frage auch []hier gestellt.

Dort wurde ja auch schon etwas vorgeschlagen, woran es evtl. liegen koennte. Hast du das schonmal angeschaut?

LG Felix



Bezug
                
Bezug
C++: Heston Modell-Zhu Scheme: keine Frage, nur DANKE!
Status: (Mitteilung) Reaktion unnötig Status 
Datum: 17:51 Mi 13.04.2011
Autor: timyyyyyy

sry, erstmal, dass ich das hier als frage deklarieren musste. k.a. wie ich sonst hätte antworten können.^^ (pn geht ja nicht als newbie)

"Das stimmt nicht, du hast die Frage auch []hier gestellt."
=> stimmt(e) doch. denn zu diesem zeitpunkt hatte ich die frage wirklich noch nirgends anders gestellt! ;)

ich hab den fehler gefunden. ich habe einmal nur den einfachen (Vola) statt quadrierten (Varianz) Parameter verwendet.

Aber auf jeden Fall VIELEN DANK für die Hilfe und Mühe!
(Auch hinsichtlich der Tipps wie ich den konstruktiveren Beitrag / Frage hätte ausführlich beschreiben könnte.)

Bezug
Ansicht: [ geschachtelt ] | ^ Forum "stochastische Prozesse"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien


^ Seitenanfang ^
ev.vorhilfe.de
[ Startseite | Mitglieder | Impressum ]