Ciao a tutti!
spero che l'argomento possa essere di interesse a qualcuno visto che per la mia testolina da programmatore della domenica non è banale
allora sto scrivendo un software che attraverso simulazione di montecarlo trovi il prezzo di un certo derivato esotico (precisamente una opzione magrabe ma non credo vi sia di interesse)
l'ho fatto sia in matlab che in c++, sicuro che il c++ avrebbe stracciato matlab di tanto... e invece mi ritrovo con un codice matlab piu veloce
eccovi le due funzioni incriminate
c++
matlabcodice://using normal distribution object from Technical Report 1 typedef std::tr1::ranlux64_base_01 Myeng; typedef std::tr1::normal_distribution<double> ndistr; double Margrabe_option_MC_price(double r, double t, double s1, double s2, double q1, double q2, double std1, double std2, double corr, double iterations){ //variables and objects initialization register long x; double price = 0; //the final price will be stored here double payoff; double z1, z2; //to store generated random numbers double matr21, matr22; double sigma1, sigma2; double part1, part2, sqrtt; clock_t start, stop; Myeng eng; ndistr stdnorm(0, 1); //creating the standard normal distribution generator //seeding the random number generator eng.seed((unsigned long) time(NULL)); //calculating sigmas matr21 = corr * std2; matr22 = sqrt(1-corr*corr) * std2; //precalculating fixed part of drive formula part1 = exp((r - q1 - 0.5*std1*std1)*t); part2 = exp((r - q2 - 0.5*std2*std2)*t); sqrtt = sqrt(t); for(x=0; x < iterations ;x++){ //generating random numbers z1 = stdnorm(eng); z2 = stdnorm(eng); //creating sigmas sigma1 = z1 * std1; sigma2 = matr21 * z1 + matr22 * z2; //calculating payoff payoff = (s1 * part1 * exp(sqrtt * sigma1)) - (s2 * part2 * exp(sqrtt * sigma2)); price += (payoff > 0) ? payoff : 0; } price /= iterations; price *= exp((-r)*t); return price; }
ebbene matlab per fare 100.000 generazioni ci mette 24 centesimi di secondo, contro i 38 del codice c++.codice:function [p,ci] = ExchangeMC(V0,U0,sigmaV,sigmaU,rho,T,r,NRepl) eps1 = randn(1,NRepl); eps2 = rho*eps1 + sqrt(1-rho^2)*randn(1,NRepl); VT = V0*exp((r - 0.5*sigmaV^2)*T + sigmaV*sqrt(T)*eps1); UT = U0*exp((r - 0.5*sigmaU^2)*T + sigmaU*sqrt(T)*eps2); DiscPayoff = exp(-r*T)*max(VT-UT, 0); [p,s,ci] = normfit(DiscPayoff);
Considerando che ho sempre pensato il c/c++ essere i linguaggi di alto livello piu performanti che esistono (correggetemi se sbaglio) devo aver sbagliato io qualcosa.
come rendereste voi il codice c piu efficiente?
da ignorante mi è venuto da pensare che il problema potrebbe essere nella funziona di generazione di numeri casuali di una normale standard!!
ho controllato e matlab lo risolve con questi calcoli
eps1 = randn(1,NRepl);
eps2 = rho*eps1 + sqrt(1-rho^2)*randn(1,NRepl);
in un elegante 8 centesimi
mentre la funzione che ho trovato io nelle librerie del boost che da quel che ho capito riscreano il pacchetto aggiuntivo Technical Report 1
for(x=0; x < iterations ;x++){
//generating random numbers
z1 = stdnorm(eng);
z2 = stdnorm(eng);
}
se ne esce con un goffo 26 centesimi di secondo
come posso migliorare questo aspetto?
inoltre avete altre osservazioni sui codici??
ci tengo particolarmente a rendere il c++ piu performante...
grazie
Marco
Rispondi quotando
