Every model's assumptions get thrown out the window as soon as things get really rocky.

Every model is short vol.

Even those for which getting volatility right is crucial!

Take the binomial tree approach to pricing options for example. See my previous post here.

From 'Paul Wilmott Introduces Finance'

Unfortunately as volatility increases, larger terminal equity prices are sampled at lower frequencies. This might not be helpful if we need a decent resolution at those high stock levels (e.g. barriers).

Luckily finite differences can help. We price using a fixed grid in a similar manner to the binomial tree.

I tweaked the previous lazy binomial tree code, the Javascript FD code can be downloaded here.

Again, I 'unfold' out the grid, just as I did with the tree.

The starting node looks like this,

`[{s:100,t:0,weight:1}]`

with the stock spot price at 100.

Then we unfold this node into three nodes bumping the stock prices up and down

`[{s:100+ds,t:0+dt,weight:1*a},`

`{s:100 ,t:0+dt,weight:1*b},`

`{s:100-ds,t:0+dt,weight:1*c}]`

updating the weights as we go, continuing on until we hit the boundaries of the grid.

After each set of nodes is unfolded, they are 'recombined' just as we did with the binomial tree in order to keep size in check.

The code's pretty straight forward, if you have already looked through the lazy binomial tree code in the previous posts.

I spent quite a while thinking about different approaches to this and believe this is about the most elegant and robust (unfortunately tail recursion is not possible!).

No doubt someone has something smarter out there, if so end me an email!

John.Orford@gmail.com