Monte-Carlo-Sim// Mit den Ergebnissen neues Array erstellen!

[doki1994]

Ich kann damit einen Call mit der Monte-Carlo-Simulation simulieren:

import math
from numpy import *
from time import time
# star import for shorter code
random.seed(20000)
t0 = time()
# Parameters
S0 = 100.; K = 105.; T = 1.0; r = 0.05; sigma = 0.2
M = 252; dt = T / M; I = 1
# Simulating I paths with M time steps
S = S0 * exp(cumsum((r - 0.5 * sigma ** 2) * dt + sigma * math.sqrt(dt) * random.standard_normal((M + 1, I)), axis=0))
# sum instead of cumsum would also do
# if only the final values are of interest
S[0] = S0
# Calculating the Monte Carlo estimator
C0 = math.exp(-r * T) * sum(maximum(S[-1] - K, 0)) / I
# Results output
tnp2 = time() - t0

Die Formel für einen Put kann man so formulieren: P0 = C0 +K*exp(-r*T)-S0.
Kann mit jemand helfen das P0 mit in die Simulation zu ziehen, somit ich mit einer Simulation beides Simuliere.
Weiter wäre meine Frage, dass ich ein Ergebnis als Array S bekomme mit den Werten der Simulation zum Beispiel (253,100).
Ich muss dann im nächsten Schritt ein neues Array erstellen in dem alle Ergebnisse von S (ich schreibe es mit Index mal S_i) in diese Formel packe:
S_i+1 = S0 * explodiert((S_i -S0) / S0) , brauche das Ergebnis wie Bei S dann als (253,100) Array.

[__blackjack__]

@doki1994: Das sieht alles sehr unübersichtlich und „unpythonisch“ aus.

Kommentare stehen über dem Code den sie kommentieren. Den Kommentar mit dem Sternchen-Import sollte man sich aber sparen, weil der Sternchen-Import schon nicht okay ist. Das Numpy-Modul wird per Konvention mit `np` abgekürzt. So viel zu tippen ist das jetzt auch nicht, und man holt sich da nicht Unmengen an Namen ins Modul, wobei zum Beispiel die `sum()`-Funktion überschrieben wird.

Mehrere Anweisungen auf einer Zeile machen den Code auch nicht gerade übersichtlicher.

`math` braucht man hier nicht zwingend, weil es die Funktionen die verwendet werden auch in `numpy` gibt.

Statt kryptischer Namen und dann Kommentaren die erklären was sie bedeuten, sollten die Namen selbst dem Leser ihre Bedeutung verraten.

Die Funktionen die auf dem globalen Zufallsgenerator operieren sollte man in neuem Code nicht mehr verwenden. Siehe Numpy-Dokumentation. Das gilt insbesondere wenn man einen Seed-Wert setzt um reproduzierbare Ergebnisse zu erhalten.

`time.time()` ist für Zeitmessungen weniger geeignet als `time.monotonic()`.

Möglicher Zwischenstand:

Code: Alles auswählen

#!/usr/bin/env python3
import time

import numpy as np


def main():
    rng = np.random.default_rng(20_000)
    start_time = time.monotonic()

    start_value = 100
    K = 105
    duration = 1
    r = 0.05
    sigma = 0.2
    time_step_count = 252
    step_duration = duration / time_step_count
    path_count = 1
    #
    # Simulating `path_count` paths with `time_step_count` time steps.
    #
    # `np.sum()` instead of `np.cumsum()` would also do if only the final values
    # are of interest.
    #
    S = start_value * np.exp(
        np.cumsum(
            (r - 0.5 * sigma ** 2) * step_duration
            + sigma
            * np.sqrt(step_duration)
            * rng.standard_normal((time_step_count + 1, path_count)),
            axis=0,
        )
    )
    S[0] = start_value
    monte_carlo_estimator = (
        np.exp(-r * duration) * sum(np.maximum(S[-1] - K, 0)) / path_count
    )

    elapsed_time = time.monotonic() - start_time
    print(
        f"Estimator: {monte_carlo_estimator} (in {elapsed_time * 1000:.2f} ms)"
    )


if __name__ == "__main__":
    main()