Choosing Monte Carlo Sample Sizes for European Call Pricing

# How many monte carlo runs do I need for pricing a Call?


# How many monte carlo runs do I need for pricing a Call?












I have to price several calls using Monte Carlo. Obviously, there is a huge tradeoff between the number of runs and the fair price of the call option. I know I can check how the approximation changes has I decrease the number of simulations, but I was wondering whether there is a ballpark value.

At the moment I am running 1000 simulations. But perhaps 500 is enough?

## Answer by bcf (score 6, accepted)

https://quant.stackexchange.com/a/22161

It really, really, really depends on your parameters, i.e. $r$, $\sigma$, $K$, $T$, $S_0$. For example, here are some results from implementing the stopping criteria I explain in my answer here. These are the number of iterations requires in order for there to be an approximate 0.95 probability that the MC call price differs from the exact call price by less than 0.01 (one penny, e.g.):

$r = 0.02$, $\sigma = 0.2$, $K = 10$, $T = 1$, $S_0 = 10$: 72,382 iterations

$r = 0.02$, $\sigma = 0.2$, $K = 10$, $T = 10$, $S_0 = 10$: 1,391,379 iterations

$r = 0.02$, $\sigma = 0.5$, $K = 10$, $T = 1$, $S_0 = 10$: 625,365 iterations

Here's my MATLAB implementation of the stopping criteria, if you'd like try for yourself:

```
%%% Estimates the price of a European call option using MC.
% Continues MC estimation until we reach a 0.05 probability that
% MC call price differs by more than "tol" units from exact 
% call price.

function C = CallPricePointEstimate()
%%% BS parameters  - Try varying these to see how number of iters (n)
% changes %%%
K = 10;
S = 10;
r = 0.02;
T = 1;
sigma = 0.5;

%%% MC parameters %%%
% number of stock prices to generate, may need more, which are
% generated in the MC loop below if idx > N_MC
N_MC = 1000000;
tol = 0.01;  % price within $tol
bound = 5;  % something larger than tol
n = 1;  % current iteration number

%%% generate normal RVs and price paths %%%
Z = normrnd((r-sigma^2/2)*T, sigma*sqrt(T), N_MC, 1);
ST = S*exp(Z);

%%% init MC accumulators %%%
sampleMean = 0;
sampleVar = 0;
oldMean = 0;

idx = 1;  % will reset to 1 if idx > N_MC
%%% MC loop %%%
while ((bound > tol) || (n < 30))
    % if idx > N_MC, need to generate more normals
    if (idx > N_MC)
        Z = normrnd((r-sigma^2/2)*T, sigma*sqrt(T), N_MC, 1);
        ST = S*exp(Z);
        idx = 1;
    end
    payoff = exp(-r*T)*max((ST(idx) - K),0);

    % update mean and var
    sampleMean = oldMean + (payoff - oldMean)/n;
    if (n>1)
        sampleVar = (1-(1/(n-1)))*sampleVar + n*(sampleMean - oldMean)^2;
    end
    oldMean = sampleMean;

    bound = 1.96*sqrt(sampleVar/n);  %%% updated this line %%%
    n = n+1;
    idx = idx+1;
end

%%% Display num samples, statistics and vfy bound = tol %%%
n
sampleMean;
sampleVar;
bound;

C = sampleMean;  % call price

%%% exact BS price using BS formula %%%
d1 = 1/(sigma*sqrt(T)) * (log(S/K) + (r + sigma^2/2)*T);
d2 = d1 - sigma*sqrt(T);
exact = S*normcdf(d1) - K*exp(-r*T)*normcdf(d2)
```

Update: I realized an error in my code: where `bound` updated, `sampleVar/sqrt(n)` should be `sqrt(sampleVar/n)`. This results in faster convergence for given parameters. The number of iterations required has been updated.

## Answer by GodLovesATrier (score 2)

https://quant.stackexchange.com/a/22156

This will depend on the nature of the problem. You already mention a perfectly good strategy - observe your current estimate after N samples - did it change significantly? If you have a grasp of the scale of the answer to the problem then you may be able to set a convergence criteria on the basis of this change.

However let's say you have a far out of the money option, then to get good coverage of the area you are interested in (a small part of the total space) you will need a lot of samples. In such a tail-case you should exercise caution even if the estimate appears to settle down quickly. Sometimes a problem can benefit from sampling using a Quasi-random sequence that more "evenly" samples the available space (here is a related question).

You might be able to get away with 500, but some problems might require 1,000,000.