Discussion :

[dumbl]

Bonjour,

Je suis sur un petit casse tête, la partie graphique n'est pas mon fort.

Je cherche à coder un treillis mathématiques, plus exactement je crée un treillis CRR(finance) par le modèle binomial. Du coté de la partie théorique aucun problème.

Par contre j'aimerais en Swing faire un truc de ce genre : http://commons.wikimedia.org/wiki/Fi...ns_Reelles.png

Mais en Swing quelle algorithme utiliser ? Faut-il d'abord que je calcule l'angle du treillis?
J'aimerais pouvoir faire de même avec un modèle trinomial (plus précis).

Quelqu'un saurait-il me guider un peu ?

Merci d'avance pour votre aide

[joel.drigo]

Salut,

tu cherches un algo pour dessiner le graphe c'est ça ?

Moi je dirais qu'il faut déterminer une grille (chaque bloc/noeud est au centre d'une des cases). On fixe une taille de case (hauteur et largeur en pixels)

Pour connaitre la hauteur de la grille (en case), il faut déterminer le n max. Mais on est pas obligé

On peut incrémenter n petit à petit, par une translation, qui décale à chaque n de 1 case. (quand je parle de translation je parle de translation opérée par java.awt.geom.AffineTransform

On voit que les cases sont remplies en quinconce (d'ou une translation de 1 case à chaque n), et que la première de chaque n est dans la première case en partant du haut (translation prise en compte), et qu'ensuite les suivantes sont dessinées en sautant une case à chaque noeud.
C'est à dire :
- pour le rang 0 : la case est en coordonnées 0,0
- pour le rang 1 : on translate d'une case, la case du rang 0 passe en 0,1
et la case 1 du rang 1 est en 1,0, la case 2, en 1,2
- pour le rang 2 : on translate d'une case, la case du rang 0 passe en 0,2
et la case 1 du rang 1 passe en 1,1, la case 2, en 1,3,
la case 1 du rang 3 est en 2,0, la case 2 en 2,2, la case 3, en 2,4
et ainsi de suite

Il suffit donc d'une primitive de dessin de case, puis de primitives pour dessiner les liens entre cases (les flèches)

Le fait d'utiliser une translation fait qu'on a pas besoin de calculer de décalage de coordonnées : à la limite on peut encore plus simplifier en translatant pour chaque noeud d'une même colonne : dans ce cas toutes les coordonnées des éléments à dessiner sont toujours les mêmes... on ne fait que faire des translation à chaque fois qu'on se déplace dans les noeuds

On dessine chaque bloc de gauche à droite, et de haut en bas :
- on itère i de 0 à n,
- pour chaque i, on connait le nombre de noeuds à dessiner (à priori i + 1) : on translate vers le haut d'une case de grille (donc tout le graphe précédemment dessiné translate vers le bas), on dessine les n+1 noeuds de haut en bas, on dessine les liens avec les noeuds de la colonne i-1 (on se basant sur la quinconce, on peut en déduire les coordonnées)

[dumbl]

Oui merci, j'ai trouvé la reponse juste après la fatigue me prenait !!

voila la solution c'est tout simple :

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
 
public void paintComponent(Graphics g){
			String t="S";
			//g.drawString(t, 50, this.getY()/2);
			int x=this.getWidth();
			int y=this.getHeight();
			int cX=50;
			int cY=y/2;
			int n=Integer.parseInt(nbPeriode.getText());
			g.setColor(Color.BLACK);
 
			int cd;
			for (int i=0; i<n; i++){
				cd=cY;
				g.drawLine(cX, cY, cX+50, cY-30);
				g.drawLine(cX, cY, cX+50, cY+30);
				for (int j=0; j<i; j++){
					cd=cd+60;
					g.drawLine(cX, cd, cX+50, cd-30);
					g.drawLine(cX, cd, cX+50, cd+30);
				}
				cX+=70;
				cY=cY-30;
			}
 
			g.drawString(t, 160, y/2-30*2);
			g.drawString(t, 160, y/2+30*2);
 
		}

me reste lus qu'a y mettre mes valeurs du treillis une fois le calcul finis.

Merci

[joel.drigo]

Cool

Je pensais que tu voulais quelque chose de plus fidèle à l'image que tu avais donné en exemple.

Voilà mon ébauche de poc à moi :

[dumbl]

Pourquoi pas pour la suite, la je fais assez rapidement l'interface qui me prend déja assez de temps^^ Mais merci beaucoup pour ton aide je regarderais ton code.

Par contre j'ai un autre petit probleme, cette fois ci pas de SWING mais plus de contrainte de capacité. En effet pour calculer mon option, je fais cette formule :
for(int i=0; i<n; i++){
price_call+=binom(n,k)*...
}
Le problème est pour calculer le binôme de Newton :

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
 
public Double factoriel(long nbPeriodes, long k){
	long nfact=1;
			if (nbPeriodes==0){
				nfact=1;
			}else{
			for (int i=1; i<=nbPeriodes; i++){
				nfact*=i;
			}
		}
		System.out.println("nfact  "+nfact);
		long kfact=1;
		if (k==0){
			kfact=1;
		}else{
			for (int i=1; i<=k; i++){
				kfact*=i;
			}
		}
		System.out.println("k : "+k+ " ,kfact : "+kfact);
		long nkfact=1;
		if ((nbPeriodes-k)==0){
			nkfact=1;
		}else{
			for (int i=1; i<=(nbPeriodes-k); i++){
				nkfact*=i;
			}
		}
		System.out.println("nkfact : "+nkfact);
		double fact=nfact/(kfact*nkfact);
		System.out.println("fact : "+fact);
		return fact; 
	}

il y a un probleme de capactité. quand je mets mon nombre de périodes n trop grand.

[joel.drigo]

Tu veux parler d'overflow, c'est ça : je viens de tester, ça va vite... rien que le nfact*i, ça monte vite !

Mes compétences en math sont limitées... c'est quoi le binôme de Newton

[dumbl]

Oui c'est ça je pense. Je peux toujours pricer par une autre méthode mais pour une fois qu'il existe une formule toute simple...

[joel.drigo]

Tu as un lien sur la formule ?

Ca m'éviterait de faire de RE...

EDIT : j'ai trouvé ça : C(n.0)=C(n,n)=1 et C(n,p)=C(n-1,p)+C(n-1,p-1)

mais ça doit pas être ça : la c'est une simple addition, pas de factorielle

[dumbl]

euh oui jte la donne.
Enfin la où ça bloque c'est dans le Binome.
ma formule général de pricing est :
for (int i=0; i<n; i++){
Call+=(n,i)*p_up^k*p_down^(n-i)*Max(C-K*u^i*d^(n-i)
}

avec n : le nombre de période du treillis,
q_up et q_down les probabilité neutre au risque de monter ou de descendre
u et d les multiplicateurs du sous jacents d'une période à une autre selon les différents états de la nature.

Mais la où ça bloque c'est le (n, k) : le binome, qui correspond à la fonction que j'ai mis.

[dumbl]

Par exemple la fonction fonctionne bien pour (5,k) par exemple mais pas pour (1000, k)

[dumbl]

Sinon en VBA celà fonctionne très bien mais la fonction du binome existe déja :

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
 
Function eurcall(S As Double, K As Double, sigma As Double, rf As Double, T As Double, n As Integer) As Double
 
Dim u As Double, d As Double, r As Double, q_up As Double, q_down As Double, val_call As Double
Dim i As Integer
Dim dt As Double
 
 
'Dans un premier temps, nous définissons le pas du temps
dt = T / n
 
'Nous déterminons les paramètres utilisés dans le calcul des probabilité risque neutre
' calibrage CRR
 
u = Math.Exp(sigma * Math.Sqr(dt))
d = 1 / u
r = Exp(-rf * T)
 
'Calcul des probabilités risque neutre
q_up = (Exp(rf * dt) - d) / (u - d)
q_down = 1 - q_up
 
'initialiser la valeur du call
val_call = 0
 
'Evaluation du call
' Fonction pour les combinaisons : "Application.WorksheetFunction.Combin(N, i)"
' fonction pour le max  Application.WorksheetFunction.Max
' Utiliser une boucle pour la 'somme' sur les N+1 états de la nature
'=================================================================================================
For i = 0 To n
val_call = val_call + Application.WorksheetFunction.Combin(n, i) * WorksheetFunction.Power(q_up, i) * WorksheetFunction.Power(q_down, n - i) * WorksheetFunction.Max(S * WorksheetFunction.Power(u, i) * WorksheetFunction.Power(d, n - i) - K, 0)
Next i
'====================================================================================================================
val_call = r * val_call
 
eurcall = val_call
 
End Function

[joel.drigo]

c'est évident déjà pour nbPeriodes=22 tu es en overlow sur du long !

[joel.drigo]

Avec du double, tu va monter un peu plus haut.

Mais je ne comprends le but de créer 3 nombres aussi grands pour les rediviser entre eux : y'a pas moyen de la simplifier cette formule, pour éviter de monter si haut (genre y'a pas un mathématicien qui a sorti un algo pour calculer ça sans faire des 1000!) ?

Parce qu'à la limite il y a les bigdecimal, mais à un moment donné tu auras toujours de l'overflow...

[dumbl]

Me mettre sur un double changera-t-il la donne de façon durable?
Pour =1000?

Car mon but est après de faire des test suivant le nombre de période ( faire tendre faire la formule de Blask-Scholes), de même pour la méthode de monte carlo et surement d'autre que je ne connais pas encore..

[joel.drigo]

en double, je monte à 171

[dumbl]

Si je peux résoudre le problème par chemin inverse du treillis, je voulais juste savoir s'il été possible de le faire avec la formule.

Peux tu me montrer un exemple des Big? je n'ai jamais eu l'occasion de les utiliser?

[joel.drigo]

quand je vois un truc comme ça :

Code :

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

double fact = nfact / (kfact * nkfact);

alors que nfact et kfact et nkfact sont des factorielles, je me dit que ça sent la simplificaiton (mais je ne suis pas matheux)

[dumbl]

Je peux résoudre de cette façon la (la c'est la trinome) mais pour l'approche binomial c'est plus simple.

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
 
Function tri_nom(S As Double, K As Double, rf As Double, sigma As Double, T As Double, n As Integer) As Double
Dim q_up As Double, q_down As Double, q_m As Double
Dim u As Double, d As Double, m As Double
Dim optionPrice As Variant, assetPrice As Variant
Dim dt As Double
Dim r As Double
 
Dim i As Integer, j As Integer
 
 
dt = T / n
 
'les coefficients de variation du sous jacent durant delta t
u = Exp(sigma * (2 * dt) ^ (0.5))
d = Exp(-sigma * (2 * dt) ^ (0.5))
m = 1
r = Exp(-rf * dt)
'probabilité neutre au risque
 
q_up = ((Exp(rf * dt / 2) - Exp(-sigma * Sqr(dt / 2))) / (Exp(sigma * Sqr(dt / 2)) - Exp(-sigma * Sqr(dt / 2)))) ^ 2
q_down = ((Math.Exp(sigma * Sqr(dt / 2)) - Exp(rf * dt / 2)) / (Exp(sigma * Sqr(dt / 2)) - Exp(-sigma * Sqr(dt / 2)))) ^ 2
q_m = 1 - q_up - q_down
 
'on calcul les prix du dernier états du sous jacent à la date de maturité.
ReDim optionPrice(2 * n + 1)
optionPrice(0) = Application.WorksheetFunction.Max(0, S * WorksheetFunction.Power(u, n) - K)
For i = 0 To n * 2
optionPrice(i) = Application.WorksheetFunction.Max(0, S * WorksheetFunction.Power(u, WorksheetFunction.Max((i - n), 0)) * WorksheetFunction.Power(d, WorksheetFunction.Max(n - i, 0)) - K)
Next i
 
'fonction backward
'Selon les la position dans le temps j
'selon l'état du monde i
For j = n - 1 To 0 Step -1
    For i = 0 To (j * 2)
    optionPrice(i) = r * (q_up * optionPrice(i + 2) + q_m * optionPrice(i + 1) + q_down * optionPrice(i))
    Next i
Next j
tri_nom = optionPrice(0)
End Function

[dumbl]

J'aimerais bien savoir ce qu'il se cache derrière la formule d'excel :p

Bon merci en tout cas pour ton aide, je vais faire l'autre méthode.

[joel.drigo]

Voilà le code avec BigDecimal :

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
public static double factoriel(long nbPeriodes, long k) { 
		BigDecimal nfact = BigDecimal.ONE;
		if (nbPeriodes > 1) {
			for (int i = 2; i <= nbPeriodes; i++) { 
				nfact = nfact.multiply(new BigDecimal(i));
			}
		}
		System.out.println("nfact  " + nfact);
		BigDecimal  kfact = BigDecimal.ONE;
		if (k > 1) {
			for (int i = 2; i <= k; i++) {
				kfact = kfact.multiply(new BigDecimal( i));
			}
		}
		System.out.println("k : " + k + " ,kfact : " + kfact);
		BigDecimal nkfact =BigDecimal.ONE;
		long nk = (nbPeriodes - k) ;
		if ( nk> 1) {
			for (int i = 2; i <= nk; i++) {
				nkfact = nkfact.multiply(new BigDecimal( i));
			}
		}
		System.out.println("nkfact : " + nkfact);
		BigDecimal fact = nfact.divide( kfact.multiply(nkfact) );
		System.out.println("fact : " + fact);
		return fact.doubleValue();
	}