Discussion :

[nico55]

Bonjour,

Je ne suis pas encore très à l'aise avec certaines subtilités / points particuliers de Python.
J'ai un programme qui génère un certains nombres de matrices avec une boucle for (dans mon cas, 50). J'aimerai ensuite créer une nouvelle matrice (une matrice colonne si possible) qui contient simplement le chiffre qui se trouve en [0,0] de chaque matrice.
En gros une matrice qui en [0,0] me donne le chiffre [0,0] de la première matrice, en [1,0] me donne le chiffre [0,0] de la deuxième matrice etc...

Y a-t-il une astuce ?
Je n'arrive pas à faire en sorte que le programme garde les valeurs précédentes en mémoire, ca m'efface tout dès que la boucle for recommence...

Merci !

[flapili]

si vous dites vaguement ce que vous avez essayé sans montrer de code on ne va pas pouvoir vous aider, de plus le code n'est que la traduction d'une idée claire et précise de quelque chose, or là rien ne semble clair et précis.

[nico55]

Voilà mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import numpy as np
from math import exp
import matplotlib.pyplot as plt
 
def Graph(S, N, r, M, sigma):
    NT = M/(N-1)
    d = exp(-sigma*np.sqrt(NT))
    u = 1/d
    a=exp(r*NT)
    p=(a-d)/(u-d)
    for L in range(2,N+1):
        A=np.zeros((L,L))  
        for i in range(L):
            for j in range(L):
                if i>j:
                    A[i,j]=np.nan
                elif i<=j:
                    A[i,j]= S * (d**i) * (u**(j-i))
        C=np.zeros((L,L))
        D=np.zeros(((N,1)))
        W=np.zeros((N,2))
        for i in reversed(range(L)):
            for j in reversed(range(L)):
                if j==L-1:
                    C[i,j] = max(S - A[i,j], 0)
                elif i > j:
                    C[i,j]=np.nan
                elif i<= j:
                    C[i,j]=max(S - A[i,j], ( p*C[i,j+1] + (1-p)*C[i+1,j+1] ) *exp(-r*(M/(N-1))))
                Z=C[0,0]
                D[L-1,0]=Z
        print(D)
        L =+ L+1
        W[:,0]=range(1,N+1)
        W[:,1]=D[:,0]
    print(W)
    plt.plot(W[:,1])
    plt.ylim(3.3, 5.3)
    plt.title("Convergence of the price of the option")
    plt.ylabel("Option Value")
    plt.xlabel("No. of steps")
    plt.show()
    plt.close()

L'objectif est de montrer graphiquement la convergence de la valeur d'une option (vers 4.3 environ) en fonction du nombre d'itérations (ici 50).
Mon problème vient à la fin, avec mes matrices D, elles prennent chacune la bonne valeur au bon endroit mais ne gardent pas en mémoire les résultats des matrices précédentes. Ainsi quand je veux générer ma matrice W pour la représentation graphique, elle prend uniquement les valeurs de la dernières matrice D obtenue (j'ai fait en sorte d'afficher les matrices quand on lance le programme, ca sera surement plus simple à comprendre en voyant la chose).

Voici les paramètres avec lesquels il est préférable de lancer le programme, histoire d'avoir des résultats cohérents : Graph(50,50,0.1,5/12,0.4)

Merci

[marco056]

Un peu compliqué ton programme mais bon.
J'ai ajouté qqs lignes repérées par ######################

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import numpy as np
from math import exp
import matplotlib.pyplot as plt
 
def Graph(S, N, r, M, sigma):
    abscisse = np.linspace(0,N,N) ###########################
    mat_graph = np.zeros(N) ###########################
    NT = M/(N-1)
    d = exp(-sigma*np.sqrt(NT))
    u = 1/d
    a=exp(r*NT)
    p=(a-d)/(u-d)
    for L in range(2,N+1):
        A=np.zeros((L,L))  
        for i in range(L):
            for j in range(L):
                if i>j:
                    A[i,j]=np.nan
                elif i<=j:
                    A[i,j]= S * (d**i) * (u**(j-i))
        C=np.zeros((L,L))
        D=np.zeros(((N,1)))
        W=np.zeros((N,2))
        for i in reversed(range(L)):
            for j in reversed(range(L)):
                if j==L-1:
                    C[i,j] = max(S - A[i,j], 0)
                elif i > j:
                    C[i,j]=np.nan
                elif i<= j:
                    C[i,j]=max(S - A[i,j], ( p*C[i,j+1] + (1-p)*C[i+1,j+1] ) *exp(-r*(M/(N-1))))
                Z=C[0,0]
                D[L-1,0]=Z
        print(D)
        for k in range(len(D)): ###########################
            if D[k] != 0: ###########################
                print(D[k]) ###########################
                mat_graph[k]=D[k] ###########################
 
        L =+ L+1
        W[:,0]=range(1,N+1)
        W[:,1]=D[:,0]
    print(W)
    print(mat_graph) ###########################
    plt.plot(W[:,1])
    plt.plot(abscisse,mat_graph) ###########################
    plt.ylim(3.3, 5.3) ###########################
    plt.title("Convergence of the price of the option")
    plt.ylim(0,5)
    plt.ylabel("Option Value")
    plt.xlabel("No. of steps")
    plt.show()
    plt.close()
 
Graph(50,50,0.1,5/12,0.4)

Tu feras le ménage avec W qui ne sert plus.
Tu peux mettre np.linspace (1,N+1,N) à la place de np.linspace(0,N,N) si tu préfères.

[nico55]

Merci beaucoup ! Ca marche parfaitement