I formatted your code snippet by putting it in pre tags.

optionPrice t s0 k r sigma n = f 0 0 where
    fs = [[f i j | j <- [-i..i] ] | i <- [0..n] ]
    f i j = if i == n
               then max ((s i j) - k) 0
               else max ((s i j) - k)
                           (exp(-r*dt) * (p * (fs!!(i+1)!!(i+j+2)) +
                                 (1-p) * (fs!!(i+1)!!(i+j))))
    s i j = s0 * u**(fromIntegral j)
    u = exp(sigma * sqrt dt)
    d = 1 / u
    dt = t / (fromIntegral n)
    p = (exp(r*dt)-d) / (u-d)

Here I’m creating a list of lists, fs, indexed by i then j, of values of (f i j), then using that list within f itself. Since Haskell is lazy, this doesn’t compute anything until you actually use it, then with how the lists are used it only computes it once for each pair of i and j. I also had to add (i+1) to the places where I’m using j to access the list to avoid an issue with negative indices.

It does look interesting. My next project, after finishing this darned book….

I was trying to demonstrate the similarity between the mathematical expression and the code, rather than trying to implement a good Binomial tree algorithm in Haskell. This point was lost in translation, unfortunately, because my LaTeX plugin didn’t handle the formulas too well. (My own plugin, so I can’t complain!)

Here’s a newer version that has an argument for call or put (CP = 1 is call, CP = -1 is put) and uses logs to speed things up. Still have to rewrite it to include tail recursion(but how?).

-module(crr).
-import(math, [log/1, sqrt/1, exp/1, pow/2]).
-export([optionPrice/7]).

max(X, Y) when X > Y -> X;
max(_X, Y) -> Y.

optionPrice(CP, S, K, T, R, V, N) ->
Dt = T / N,
Df = exp(-R * Dt),
U = exp(V * sqrt(Dt)),
D = 1 / U,
Pu = (exp(R * Dt) – D) / (U – D),
Pd = 1 – Pu,
S * f(0, 0, CP, K / S , Df, log(U), Pu, Pd, N).

s(J, U) ->
exp(J * U).

f(N, J, CP, X, _Df, U, _Pu, _Pd, N) ->
Sij = s(J, U),
max(CP * (Sij – X), 0);
f(I, J, CP, X, Df, U, Pu, Pd, N) ->
Sij = s(J, U),
Vij = Df * (Pu * f(I + 1, J + 1, CP, X, Df, U, Pu, Pd, N) + Pd * f(I + 1, J – 1, CP, X, Df, U, Pu, Pd, N)),
max(CP * (Sij – X), Vij).

riskyrisk

-module(crr).
-import(math, [sqrt/1, exp/1, pow/2]).
-export([optionPrice/6]).

max(X, Y) when X > Y -> X;
max(_X, Y) -> Y.

optionPrice(S, K, T, R, V, N) ->
Dt = T / N,
U = exp(V * sqrt(Dt)),
D = 1 / U,
P = (exp(R * Dt) – D) / (U – D),
f(0, 0, S, K, R, Dt, U, P, N).

s(J, S, U) ->
S * pow(U, J).

f(N, J, S, K, _R, _Dt, U, _P, N) ->
Sij = s(J, S, U),
max(Sij – K, 0);
f(I, J, S, K, R, Dt, U, P, N) ->
Sij = s(J, S, U),
Vij = exp(-R * Dt) * (P * f(I + 1, J + 1, S, K, R, Dt, U, P, N) + (1 – P) * f(I + 1, J – 1, S, K, R, Dt, U, P, N)),
max(Sij – K, Vij).

calling the function:
(emacs@localhost)13> crr:optionPrice(100,100,1,0.05,0.3,25).
14.341546969779252

riskyrisk