Hi,

I have been using F# increasingly recently with application to probabilistic modelling. There are some classic methods in actuarial literature which lend themselves well to implementation in a recursive style.

One such method is for evaluating the probability mass functions (pmf) of Panjer's (a,b,0) class of discrete distributions. (This includes Poisson, Binomial, Negative Binomial and Geometric).

The implementation with Seq.unfold works nicely :

let ab0_pmf a b (k: int) (pk:float) =

Seq.unfold (fun ((k: int),(pk: float)) -> Some ((pk),((k + 1),((a + (b / float (k+1)) ) * pk))) ) (k,pk)

To obtain the Poisson pmf:

let poisson_pmf rate =

ab0_pmf 0. rate 0 (exp (-rate))

For the negative binomial pmf:

let negbin_pmf r beta =

let a = beta / (1. + beta) in

ab0_pmf a (a * (r - 1.)) 0 ((1. + beta) ** -r)

And for the binomial:

let binomial_pmf (m: int) (q: float) =

ab0_pmf (-q/(1. - q)) ((float m + 1.)*q/(1. - q)) 0 ((1. - q) ** (float m))

Of course, there are simple non-recursive methods for evaluating the pmf of each of these for integer values, but the sequence approach is useful if you wish to recover the pmf and combine with Seq.filter e.g. in finding all integer values having probability above a certain threshold.

F# is also useful when defining combinators to act on these pmf's; in particular, there are very nice solutions for zero-inflation and zero-truncation of the discrete distributions outlined above.

I would be very interested to hear if anyone else is using F# in the financial/actuarial/probability field.

Hope the functions above prove useful.

Regards,

Michael