CPPI und Protective Put (in MatLab)

[100]

Okay, jetzt wollte ich es so machen:

 

Ich habe ja die Daten von 1967 bis 2007 Monatsweise aus der Excel-Tabelle in MatLab eingelesen.

 

Jetzt würde ich gern (willkürlich) festlegen, dass die Puts, die gekauft werden, jeweils 12 Monate laufen (Zeitwert beachte ich wohl nicht, oder so).

 

Wie berechne ich von dem Vektor, der 486x1 umfasst, jeweils den Durchschnitt der ersten/nächsten 12 Elemente?

Am besten noch so, dass pro Jahr dann eine Variable erzeugt wird, die die Jahresperformance, also diesen Durchschnitt, enthält.

 

Dann würde ich dies nämlich tun und hätte immer die Performance eines Jahres.

 

DANN lasse ich in jedem Jahr 10% vom investierten Kapital in den Put fließen und 90% in das Asset.

dann lasse ich ihn per if-Schleife sehen, ob die Performance positiv oder negativ war.

wenn positiv, dann lasse ich den Put-Wert verfallen, wenn negativ, dann wird Assetwert angepasst und Put-Wert mit einem Delta multipliziert, das ich bisher einfach willkürlich auf -1 gesetzt habe.

[DerKlammeSparer]

Wie berechne ich von dem Vektor, der 486x1 umfasst, jeweils den Durchschnitt der ersten/nächsten 12 Elemente?

Am besten noch so, dass pro Jahr dann eine Variable erzeugt wird, die die Jahresperformance, also diesen Durchschnitt, enthält.

Z.B. eine Funktion schreiben, die dir die 12 Monatsrendite ausrechnet. Input ist dein Vektor mit allen Monatsrenditen und die Position, ab dem die Rendite für die nächsten 12 Monate berechnet werden soll. Die Funktion summiert die gewünschten Monatsrenditen auf, berecehnet die Jahresrendite und gibt noch den letzten Monat zurück, um dann wieder die Startposition für die nächste Jahresrendite zu haben. Dann kannst du die Funktion in einer weiteren Funktion per Schleife 3, 5 oder was auch immer Jahresrenditen ausrechnen lassen.

 

Nur so als Idee, gibt sicher noch andere/ elegantere Wege.

[100]

Wie berechne ich von dem Vektor, der 486x1 umfasst, jeweils den Durchschnitt der ersten/nächsten 12 Elemente?

Am besten noch so, dass pro Jahr dann eine Variable erzeugt wird, die die Jahresperformance, also diesen Durchschnitt, enthält.

Z.B. eine Funktion schreiben, die dir die 12 Monatsrendite ausrechnet. Input ist dein Vektor mit allen Monatsrenditen und die Position, ab dem die Rendite für die nächsten 12 Monate berechnet werden soll. Die Funktion summiert die gewünschten Monatsrenditen auf, berecehnet die Jahresrendite und gibt noch den letzten Monat zurück, um dann wieder die Startposition für die nächste Jahresrendite zu haben. Dann kannst du die Funktion in einer weiteren Funktion per Schleife 3, 5 oder was auch immer Jahresrenditen ausrechnen lassen.

 

Nur so als Idee, gibt sicher noch andere/ elegantere Wege.

 

EDIT: hat sich erledigt.

 

Versuche jetzt diese Funktion, finde das aber sehr schwer.

Versuche nun hinzubekommen, dass er für jedes Jahr eine eigene Variable erzeugt.

[100]

Das hier habe ich grad versucht:

 

%vorgeben mit welchem Wert des DAXPerform-Vektors angefangen wird

Startwert = 1

%den Durchschnitt der ersten 12 Werte berechnen, dann den Startwert für den

%nächsten Durchlauf auf den letzten Endwert+1 (bzw.startwert+12) setzen

Durchschnitt1 = cumsum(Startwert:(startwert+11))

Startwert = (Startwert+12)

 

 

aber die fett markierte Zeile funktioniert nicht. die MatLab Hilfe-Beschreibung scheint mir, als wenn man mit sum und cumsum nur den kompletten Vektor addieren kann, nicht aber die ersten 12 elemente. Mit welcher Funktion könnte ich das ?

 

und mit welcher Funktion kann ich einstellen, dass er von alleine die Ausgabe-Variablen Jahresperformance1 - Jahresperformance10 erstellt?

[ZappBrannigan]

Durchschnitt1 = cumsum(Startwert:(startwert+11))

Durchschnitt1 = cumsum(DAXPerform(Startwert:(Startwert+11)))

 

aber die fett markierte Zeile funktioniert nicht. die MatLab Hilfe-Beschreibung scheint mir, als wenn man mit sum und cumsum nur den kompletten Vektor addieren kann, nicht aber die ersten 12 elemente.

Ja, aber du kannst eben den Vektor entsprechend ausschneiden ("array slicing") und dann cumsum auf diesen neuen Vektor anwenden. Und genau das macht man in matlab mit den Klammern: test = test(5:35). Oder test = test([1 5 3 6 9])

[100]

Okay, Durchschnitt1 kann er jetzt berechnen.

Wie mache ich es nun, dass er selbstständig an den Variablennamen `Durchschnitt` statt einer 1 eine 2 anhängt und dies als nächste Variable speichert ?

 

evtl. mit for-Schleife und / oder mit eval, aber beides wird mir irgendwie nicht richtig klar wie es funktioniert.

[ZappBrannigan]

Wie mache ich es nun, dass er selbstständig an den Variablennamen `Durchschnitt` statt einer 1 eine 2 anhängt und dies als nächste Variable speichert ?

 

evtl. mit for-Schleife und / oder mit eval, aber beides wird mir irgendwie nicht richtig klar wie es funktioniert.

Mit eval könntest du das zwar hinbekommen, allerdings wäre das imho eine ziemlich hässliche Lösung. Besser ist es stattdessen eine einziges, mehrdimensionales Array zu verwenden:

 

durchschnRendite = zeros(numel(DAXperform),N); %nicht unbedingt notwendig, aber schöner und bei sehr großen Datensätzen Zeit sparend
for k=1:N
 start = 10*k; %oder 5*k oder was auch immer
 durchschnRendite(:,k) = cumsum(DAXperform(start+(1:10)));
end

[100]

 

Mit eval könntest du das zwar hinbekommen, allerdings wäre das imho eine ziemlich hässliche Lösung. Besser ist es stattdessen eine einziges, mehrdimensionales Array zu verwenden:

 

durchschnRendite = zeros(numel(DAXperform),N); %nicht unbedingt notwendig, aber schöner und bei sehr großen Datensätzen Zeit sparend
for k=1:N
 start = 10*k; %oder 5*k oder was auch immer
 durchschnRendite(:,k) = cumsum(DAXperform(start+(1:10)));
end

 

Ich versuch grad diese Schleife zu verstehen. Also als "durchschnRendite" erzeugt er eine Matrix, die so viele Zeilen hat, wie mein Vektor mit den Monatsrenditen "DAXPerform" aber N spalten - warum N spalten? Und diese erzeugte Matrix ist dann mit nullen gefüllt.

dann beginnt eine Schleife, bei der er von 1 bis N geht und den jeweiligen Wert mal 10(o.ä.) nimmt - warum?

und dann ersetzt er in der Matrix mit den Nullen jeweils jedes Element der Spalte k mit der kummulierten Summe von 10(oder12) Monatsrenditen.

 

Warum erzeugt man nicht eine Matrix mit nur einer Spalte? oder habe ich den Code falsch verstanden?

[ZappBrannigan]

Ich versuch grad diese Schleife zu verstehen. Also als "durchschnRendite" erzeugt er eine Matrix, die so viele Zeilen hat, wie mein Vektor mit den Monatsrenditen "DAXPerform" aber N spalten - warum N spalten?

N ist die Zahl der verschiedenen Abschnitte innerhalb des DAXperform-Vektors, die du betrachten möchtest. Da ich nicht wusste wieviele das sind hab ich sie einfach N genannt (die Schleife läuft dann auch von 1 bis N)

 

Und diese erzeugte Matrix ist dann mit nullen gefüllt.

Es ist etwas sauberer die Matrix mit der endgültigen Größe anzulegen anstatt sie bei jedem Schleifendurchlauf anwachsen zu lassen. Daher hab ich die Matrix erstmal einfach mit Nullen gefüllt. Die Zeile kannst du aber auch weglassen (bei großen Datensätzen verlangsamt das dann aber die Laufzeit).

 

dann beginnt eine Schleife, bei der er von 1 bis N geht und den jeweiligen Wert mal 10(o.ä.) nimmt - warum?

und dann ersetzt er in der Matrix mit den Nullen jeweils jedes Element der Spalte k mit der kummulierten Summe von 10(oder12) Monatsrenditen.

Ich hab einfach nur deinen Startwert neu ausgerechnet. Du hattest ja den Bereich Startwert:startwert+11 ausgewählt. Ich hab das etwas schlampig zu startwert+(1:10) vereinfacht (eigentlich müsste es eher startwert+(0:11) heissen).

 

Warum erzeugt man nicht eine Matrix mit nur einer Spalte? oder habe ich den Code falsch verstanden?

Du meintest du wolltest verschiedene Abschnitte betrachten. Ich habe alle N betrachteten Abschnitte in einer Matrix gespeichert, statt sie wie du geplant hattest mit eval in verschiedene Variablen zu schreiben.

[100]

ich verstehe das immer noch nicht ganz.

ich erzeuge eine matrix mit genausovielen zeilen wie die daxperform-matrix, aber mit spalten gleich der anzahl variablen, die ich erzeugen will.

also es sind 40 jahre, deren durchschnitte ich will, daher N=40. es sind ca 480 elemente in der quell-matrix.

hat man dann eine null-matrix erzeugt, die 480x40 groß ist ? müsste die zeilenanzahl nicht kleiner sein?

 

 

Edit: und noch was anderes- wenn ich funktionen programmiere und als Input Variablen definiere, bspw. Startwert und dann schreibe ich innerhalb der Funktion iwo `Startwert=100` und später wird damit gerechnet, dann unterlegt MatLab mir die Input-Variable in braun und wenn man mit dem Cursor drübergeht, steht da `might be unused, consider to replace variable`.

Warum ist das? in welcher Art und Weise muss denn eine Variable, die man als Input oder Output in einer Funktion aufführt, benutzt werden?

[ZappBrannigan]

ich verstehe das immer noch nicht ganz.

ich erzeuge eine matrix mit genausovielen zeilen wie die daxperform-matrix, aber mit spalten gleich der anzahl variablen, die ich erzeugen will.

also es sind 40 jahre, deren durchschnitte ich will, daher N=40. es sind ca 480 elemente in der quell-matrix.

hat man dann eine null-matrix erzeugt, die 480x40 groß ist ? müsste die zeilenanzahl nicht kleiner sein?

Ja, da hast du natürlich recht. Es müssten in deinem Fall eher 12x40 Einträge sein.

[100]

ich verstehe das immer noch nicht ganz.

ich erzeuge eine matrix mit genausovielen zeilen wie die daxperform-matrix, aber mit spalten gleich der anzahl variablen, die ich erzeugen will.

also es sind 40 jahre, deren durchschnitte ich will, daher N=40. es sind ca 480 elemente in der quell-matrix.

hat man dann eine null-matrix erzeugt, die 480x40 groß ist ? müsste die zeilenanzahl nicht kleiner sein?

Ja, da hast du natürlich recht. Es müssten in deinem Fall eher 12x40 Einträge sein.

 

wieso 12x40? Eigentlich brauche ich doch nur 1x40 oder 40x1, nämlich 40 Jahresrenditen, oder? Das Ergebnis könnte doch ruhig ein 40x1 Rendite-Vektor sein.

[100]

Hallo,

ich habe nun einige Zeit an einem anderen Projekt gearbeitet und nun geht`s mit diesem weiter. Also:

 

Ziel ist die Berechnung der Performance einer Protective Put Strategie.

Gegeben ist eine Excel-Datei, die die historische Monatsperformance des DAX und REX enthält

und das Startkapital (z.B. 100).

 

Lösungsweg:

Erstmal soll eine Strategie mit Strike von 95% des Basiswerts gewählt werden.

Heißt, wenn der Basiswert 100 kostet, ist der Strike des Puts bei 95.

Die Puts sollen monatlich rolliert werden, also jeden Monat einen neuen kaufen.

Steht der Basiswert am Ende des Monats bei 110, wird der alte Put verkauft und ein neuer

mit Strike bei 104,5 gekauft usw.

 

Aktuelles Problem: Berechnung des Preises eines (fiktiven) Puts.

(Dies soll mit dem Black-Scholes-Modell gemacht werden.)

Ich habe hier im Forum eine Excel-Datei gefunden, die mit Black-Scholes den Preis von Puts und

Calls berechnet und dafür folgende Input-Variablen braucht:

 

-Preis des Underlyings (wird durch die historischen Performances des DAX gegeben)

-Basispreis (soll 95% des Basiswerts sein)

-Risikoloser Zins (nehme ich an, muss ich fiktiv wählen, also einfach 1%? )

-Laufzeit der Option (Muss ich wohl auch willkürlich festlegen, vllt. immer 1 Jahr Laufzeit, aber nach `nem Monat auswechseln?)

-Volatilität (Kann man laut meinen Unterlagen berechnen anhand des Höchst- und Tiefst-Kurses der vergangenen Periode (Jahr),

Höchst- und Tiefst-Kurse sind dann durch die historischen Daten gegeben.)

 

Also muss ich nun in MatLab eine Funktion programmieren, die anhand dieser Inputs den Preis eines Puts berechnet,

diesen Preis dann vom Startkapital abzieht und den Rest des Startkapitals in den DAX investiert.

Dann muss nach jedem Monat der neue Preis des Puts berechnet werden, er muss verkauft werden und ein neuer gekauft werden.

Am Ende des Jahres soll dann die Gesamtperformance angezeigt werden, die sich zusammensetzt aus der Performance der Puts

und der Performance des DAX.

 

Fragen:

-Sind meine Überlegungen bis hier soweit richtig (vor allem die unterstrichenen Stellen, aber auch generell alles) ?

-Wie setze ich das am besten um?

-Ist es korrekt, wenn ich die Puts so modelliere, dass sie immer bei Kauf 1 Jahr Laufzeit haben, aber nach 1 Monat ausgewechselt werden?

 

EDIT: die Datei für Black-Scholes ist hier: https://www.wertpapier-forum.de/topic/19545-excelsheet-zur-optionspreisberechnung/

[100]

Ich hatte aus meiner Excel-Datei 'b13:b498' eingelesen.

 

Wie kann ich hieraus nur von den letzten zwölf Werten die Standardabweichung berechnen lassen?

[ZappBrannigan]

Ich hatte aus meiner Excel-Datei 'b13:b498' eingelesen.

 

Wie kann ich hieraus nur von den letzten zwölf Werten die Standardabweichung berechnen lassen?

In Matlab?

 

std(data(end-11:end))

 

Vielleicht solltest du mal ein Tutorial durcharbeiten.

[100]

Danke,

 

und wie setzt man folgenden Befehl aus Excel in MatLab um:

 

standnormvert(*gegebene funktion*)

[100]

okay, habe selbst was gefunden. Es gibt eine Funktion in MatLab, die den Preis einer Option auf Basis von Black-Scholes berechnet:

 

"[Call, Put] = blsprice(Price, Strike, Rate, Time, Volatility, Yield) computes European put and call option prices using a Black-Scholes model."

[100]

Die genannte Funktion gehört zur Finance Toolbox, die ich mit meiner Version nicht benutzen darf. Ich habe aber die Berechnung von Hand programmiert.

 

Ich habe bisher programmiert, dass ein Startkapital gegeben ist, dass berechnet wird wieviel Geld zu Beginn in den DAX gesteckt wird und wieviel zu Beginn ein Put kostet.

Gegeben ist ja ein Vektor, dessen Elemente die Monatsendstände des DAX über viele Jahre darstellen.

 

Wie programmiert man es nun, dass, nachdem der Putpreis zu Beginn berechnet ist, ein Monat vergeht, also der DAX-Stand eine Zeile weiter geht, und anhand dieser Zahl der

Putpreis erneut berechnet wird, dieser Wert gespeichert wird und auf Basis dieses gespeicherten Wertes entschieden wird, ob sich die Parameter der Putpreisberechnung

ändern, sprich ein neuer Put gekauft wird mit anderen Eigenschaften ?

 

Ich glaube das ist schwer nachzuvollziehen, also nochmal anschaulicher:

 

Ich habe PutPreis zu Beginn. Parameter dafür waren sein Strike, Basiswertpreis, Vola, Zins etc.

und ich habe den DAX-Stand zu Beginn und einen Vektor, die dessen Entwicklung der kommenden Jahre wiedergibt.

Das Programm soll jetzt die nächste Zahl in diesem Vektor ansehen und diese Zahl als Faktor "Basiswertpreis" wieder für die Berechnung des Put-Preises benutzen.

Die Änderung des PutPreises soll als (Zwischen)Ergebnis gespeichert werden und dies soll mit jedem Monat wiederholt werden und die PutPreis-Änderungen sollen

kummuliert werden.

[DerKlammeSparer]

Wie programmiert man es nun, dass, nachdem der Putpreis zu Beginn berechnet ist, ein Monat vergeht, also der DAX-Stand eine Zeile weiter geht, und anhand dieser Zahl der

Putpreis erneut berechnet wird, dieser Wert gespeichert wird und auf Basis dieses gespeicherten Wertes entschieden wird, ob sich die Parameter der Putpreisberechnung

ändern, sprich ein neuer Put gekauft wird mit anderen Eigenschaften ?

Du hast eine Funktion geschrieben, die dir den Putpreis anhand des Basiswerts berechnet. Dann geh doch mit einer Schleife deinen DAX Vektor durch und berechne in jedem Durchlauf mit deiner Funktion den Wert deines Puts mit dem "aktuellen" Basiswert. Da kannst du ja dann auch gleich deine weiteren Anforderungen (wird was neues gekauft/verkauft usw.) abarbeiten.

 

 

Das Durcharbeiten eines Tutorials mit den Basics von MatLab halte ich nach wie vor übrigens für sinnvoll.