Transcription algorithme r�cursif Matlab/C++

Version imprimable

Bonsoir,

Apr�s avoir �crit une fonction sous Matlab me permettant de calculer l'ensemble des combinaisons possibles d'allocations de portefeuilles comme ci-dessous :
Code:

1 2 3 4 5 6 t{1} = 0:0.1:1; t{2} = 0:0.2:1; t{3} = 0:0.5:1; resultattemporaire = []; resultat = []; resultat = allocation(t,resultattemporaire,resultat);
Avec la fonction r�cursive allocation :
Code:

1 2 3 4 5 6 7 8 9 10 11 function resultat = allocation(t,resultattemporaire,resultat) indice = length(resultattemporaire)+1; for k=1:length(t{indice}) if sum(resultattemporaire)+t{indice}(k)<=1 && indice<numel(t) resultattemporaire2 = [resultattemporaire t{indice}(k)]; resultat = allocation(t,resultattemporaire2,resultat); elseif sum(resultattemporaire)+t{indice}(k)==1 && indice==numel(t) resultat = [resultat;[resultattemporaire t{indice}(k)]]; end end
Me donne toutes les combinaisons < 1 de t{1} � t{3} suivant les pas d'incr�mentations t{2}
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 >> resultat resultat = 0 0 1.0000 0 1.0000 0 0.1000 0.4000 0.5000 0.2000 0.8000 0 0.3000 0.2000 0.5000 0.4000 0.6000 0 0.5000 0 0.5000 0.6000 0.4000 0 0.8000 0.2000 0 1.0000 0 0
Le soucis est que pour des vecteurs de 50 lignes par exemple, le temps d'execution de cette fonction est extr�ment long :calim2:
Je souhaite donc re-�crire la fonction allocation.m en C++ puis la convertire en format MEX en esp�rant r�duire le temps de calcul sous Matlab.

Le fait est que j'ai beaucoup de mal � �crire cette fonction r�cursive en C++ :aie: En fait j'ai du mal avec toutes les fonctions r�cursives :aie:.

Une aide serait la bienvenue :mrgreen:

Merci !

07/03/2010, 10h52
Goten

Le C++ est pas ce qu'il y'a de plus adapt�e pour faire des fonctions r�cursives.. J'ai peur qu'avec des grosses r�cursions tu fasses p�ter la pile. Une bonne id�e serait de transformer ton algorithme r�cursif en it�ratif...

Salut !

� plus forte raison que g�n�rer des combinaisons de portefeuille avec un pas est quand m�me pas quelque chose de tr�s lourd en calcul !

Deux boucles, et sans r�cursion, font l'affaire :
Code:

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 #include <cstdlib> #include <vector> #include <iostream> struct portefeuille { float actions; float hedge; float obligs; }; typedef struct portefeuille Portefeuille; int main(int argc, char* argv[]) { std::vector<Portefeuille> possibilites; const float pas = 0.1f; float partAction = 0.f; float partHedge = 0.f; float partOblig = 0.f; float restant; while(partAction <= 1.f){ restant = 1.f - partAction; partHedge = 0.f; while(partHedge <= restant){ partOblig = restant - partHedge;; Portefeuille courant = {partAction,partHedge,partOblig}; possibilites.push_back(courant); partHedge += pas; } partAction += pas; } // Affichage for(std::vector<Portefeuille>::iterator it = possibilites.begin(); it != possibilites.end(); it ++){ std::cout << it->actions << "," << it->hedge << "," << it->obligs << std::endl; } return 0; }
J'ai pas fait de matlab depuis longtemps alors je te l'ai fait en C++ mais �a s'adapte easy.

Edit : je viens de percuter qu'en fait, ton nombre d'actifs est variable donc ma solution ne sert � rien :aie:. Anyway, je suis s�r qu'on doit pouvoir trouver une solution simple qui calculer assez vite.

09/03/2010, 21h00
Joel F

Citation:

Envoy� par Goten

Le C++ est pas ce qu'il y'a de plus adapt�e pour faire des fonctions r�cursives.. J'ai peur qu'avec des grosses r�cursions tu fasses p�ter la pile. Une bonne id�e serait de transformer ton algorithme r�cursif en it�ratif...

Si la fonction est tail-recursive, la plupart des compilateurs s�rieux le font tout seul.

Tail-recursive: http://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale

@ jblecanard

Oui, je calcul des allocations sur des portefeuilles allant de 1 � 40 titres maximum, avec des incr�ments souvents diff�rents sur chaque titre :);

@ Joel F et Goten

Au final j'ai �crit en C++ hybride .mex une fonction it�rative :

Code:

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# include "mex.h"
 
 
// CALCUL DES ALLOCATIONS INITIALES DE PORTEFEUILLES.
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
	 double *PoidsDepart, *Pas, *PoidsFin, Allocations[40][500], *AllocationsFinales;
	 double Compteur;
	 int j, k, Numero;
	 double i[40];
 
	 mxArray *ValeursDepart;
	 mxArray *ValeursPas;
	 mxArray *ValeursFin;
 
         if (nrhs!=3)
	 {	
		mexErrMsgTxt ("Nombre d'arguments incorrect !");
	 }	
	 if (nlhs>1)
	 {	
		mexErrMsgTxt ("Une seule variable est calculée !");
	 }
 
	 ValeursDepart = prhs[0];
	 ValeursPas = prhs[1];
	 ValeursFin = prhs[2];
 
	 PoidsDepart = mxGetPr(ValeursDepart);
	 Pas = mxGetPr(ValeursPas);
	 PoidsFin = mxGetPr(ValeursFin);
 
	 Numero = 0;
 
	 for (i[0]=PoidsDepart[0]; i[0]<=(PoidsFin[0]+0.000001); i[0]=i[0]+Pas[0]) 
	 {for (i[1]=PoidsDepart[1]; i[1]<=(PoidsFin[1]+0.000001); i[1]=i[1]+Pas[1]) 
	 {for (i[2]=PoidsDepart[2]; i[2]<=(PoidsFin[2]+0.000001); i[2]=i[2]+Pas[2]) 
	 {for (i[3]=PoidsDepart[3]; i[3]<=(PoidsFin[3]+0.000001); i[3]=i[3]+Pas[3])
         {for (i[4]=PoidsDepart[4]; i[4]<=(PoidsFin[4]+0.000001); i[4]=i[4]+Pas[4]) 
	 {for (i[5]=PoidsDepart[5]; i[5]<=(PoidsFin[5]+0.000001); i[5]=i[5]+Pas[5]) 
	 {for (i[6]=PoidsDepart[6]; i[6]<=(PoidsFin[6]+0.000001); i[6]=i[6]+Pas[6]) 
	 {for (i[7]=PoidsDepart[7]; i[7]<=(PoidsFin[7]+0.000001); i[7]=i[7]+Pas[7]) 
	 {for (i[8]=PoidsDepart[8]; i[8]<=(PoidsFin[8]+0.000001); i[8]=i[8]+Pas[8])
	 {for (i[9]=PoidsDepart[9]; i[9]<=(PoidsFin[9]+0.000001); i[9]=i[9]+Pas[9])	
	 {for (i[10]=PoidsDepart[10]; i[10]<=(PoidsFin[10]+0.000001); i[10]=i[10]+Pas[10]) 
	 {for (i[11]=PoidsDepart[11]; i[11]<=(PoidsFin[11]+0.000001); i[11]=i[11]+Pas[11]) 
	 {for (i[12]=PoidsDepart[12]; i[12]<=(PoidsFin[12]+0.000001); i[12]=i[12]+Pas[12]) 
	 {for (i[13]=PoidsDepart[13]; i[13]<=(PoidsFin[13]+0.000001); i[13]=i[13]+Pas[13])
         {for (i[14]=PoidsDepart[14]; i[14]<=(PoidsFin[14]+0.000001); i[14]=i[14]+Pas[14]) 
	 {for (i[15]=PoidsDepart[15]; i[15]<=(PoidsFin[15]+0.000001); i[15]=i[15]+Pas[15]) 
	 {for (i[16]=PoidsDepart[16]; i[16]<=(PoidsFin[16]+0.000001); i[16]=i[16]+Pas[16]) 
	 {for (i[17]=PoidsDepart[17]; i[17]<=(PoidsFin[17]+0.000001); i[17]=i[17]+Pas[17]) 
	 {for (i[18]=PoidsDepart[18]; i[18]<=(PoidsFin[18]+0.000001); i[18]=i[18]+Pas[18])
	 {for (i[19]=PoidsDepart[19]; i[19]<=(PoidsFin[19]+0.000001); i[19]=i[19]+Pas[19])	 
	 {for (i[20]=PoidsDepart[20]; i[20]<=(PoidsFin[20]+0.000001); i[20]=i[20]+Pas[20]) 
	 {for (i[21]=PoidsDepart[21]; i[21]<=(PoidsFin[21]+0.000001); i[21]=i[21]+Pas[21]) 
	 {for (i[22]=PoidsDepart[22]; i[22]<=(PoidsFin[22]+0.000001); i[22]=i[22]+Pas[22]) 
	 {for (i[23]=PoidsDepart[23]; i[23]<=(PoidsFin[23]+0.000001); i[23]=i[23]+Pas[23])
         {for (i[24]=PoidsDepart[24]; i[24]<=(PoidsFin[24]+0.000001); i[24]=i[24]+Pas[24]) 
	 {for (i[25]=PoidsDepart[25]; i[25]<=(PoidsFin[25]+0.000001); i[25]=i[25]+Pas[25]) 
	 {for (i[26]=PoidsDepart[26]; i[26]<=(PoidsFin[26]+0.000001); i[26]=i[26]+Pas[26]) 
	 {for (i[27]=PoidsDepart[27]; i[27]<=(PoidsFin[27]+0.000001); i[27]=i[27]+Pas[27]) 
	 {for (i[28]=PoidsDepart[28]; i[28]<=(PoidsFin[28]+0.000001); i[28]=i[28]+Pas[28])
	 {for (i[29]=PoidsDepart[29]; i[29]<=(PoidsFin[29]+0.000001); i[29]=i[29]+Pas[29])	  
	 {for (i[30]=PoidsDepart[30]; i[30]<=(PoidsFin[30]+0.000001); i[30]=i[30]+Pas[30]) 
	 {for (i[31]=PoidsDepart[31]; i[31]<=(PoidsFin[31]+0.000001); i[31]=i[31]+Pas[31]) 
	 {for (i[32]=PoidsDepart[32]; i[32]<=(PoidsFin[32]+0.000001); i[32]=i[32]+Pas[32]) 
	 {for (i[33]=PoidsDepart[33]; i[33]<=(PoidsFin[33]+0.000001); i[33]=i[33]+Pas[33])
	 {for (i[34]=PoidsDepart[34]; i[34]<=(PoidsFin[34]+0.000001); i[34]=i[34]+Pas[34]) 
	 {for (i[35]=PoidsDepart[35]; i[35]<=(PoidsFin[35]+0.000001); i[35]=i[35]+Pas[35]) 
	 {for (i[36]=PoidsDepart[36]; i[36]<=(PoidsFin[36]+0.000001); i[36]=i[36]+Pas[36]) 
	 {for (i[37]=PoidsDepart[37]; i[37]<=(PoidsFin[37]+0.000001); i[37]=i[37]+Pas[37]) 
	 {for (i[38]=PoidsDepart[38]; i[38]<=(PoidsFin[38]+0.000001); i[38]=i[38]+Pas[38])
	 {for (i[39]=PoidsDepart[39]; i[39]<=(PoidsFin[39]+0.000001); i[39]=i[39]+Pas[39]) 
	 {
		 Compteur = 0; 
 
		 for (k=0; k<40; k++)
		 {
			 Compteur = Compteur + i[k];
		 }
	         if (Compteur<(1+0.000001) && Compteur>(1-0.000001))
	        {
		    Numero = Numero+1;      
 
		    if (Numero > 500)
		    {  
			   mexErrMsgTxt ("Nombre maximal de portefeuilles atteint !");
		    }
		    for (j=0; j<40; j++)
		    {	   
				Allocations[j][Numero-1] = i[j];
	        }
	     }
	  }
	 }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
	 plhs[0] = mxCreateDoubleMatrix(Numero, 40, mxREAL);
	 AllocationsFinales = mxGetData(plhs[0]); 
 
	 for (k=0; k<Numero; k++)
	 {
		 for (j=0; j<40; j++)
		 {
			 AllocationsFinales[k+(j*Numero)] = Allocations[j][k];
		 }
	 }	
}

Les temps d'executions sont tr�s courts (la limite de 500 portefeuilles y est pour beaucoup faut dire :mrgreen:).

En tout cas merci pour vos r�ponses :ccool: