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++
codice:
//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;
}
matlab
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);
ebbene matlab per fare 100.000 generazioni ci mette 24 centesimi di secondo, contro i 38 del codice c++.

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