Wednesday

Jun082011

## Discount/Zero Curve Construction in F# – Update

Wednesday, June 8, 2011 at 11:16PM

For convenience of copy-paste and experimentation, I’ve posted a full working snippet (if that’s the right word – it’s over 400 lines!) of the discount curve bootstrapper to the excellent fssnip.net site.

open System.Text.RegularExpressions type Date = System.DateTime let date d = System.DateTime.Parse(d) type Period = { startDate:Date; endDate:Date } type Calendar = { weekendDays:System.DayOfWeek Set; holidays:Date Set } type Tenor = { years:int; months:int; days:int } let tenor t = let regex s = new Regex(s) let pattern = regex ("(?<weeks>[0-9]+)W" + "|(?<years>[0-9]+)Y(?<months>[0-9]+)M(?<days>[0-9]+)D" + "|(?<years>[0-9]+)Y(?<months>[0-9]+)M" + "|(?<months>[0-9]+)M(?<days>[0-9]+)D" + "|(?<years>[0-9]+)Y" + "|(?<months>[0-9]+)M" + "|(?<days>[0-9]+)D") let m = pattern.Match(t) if m.Success then { new Tenor with years = (if m.Groups.["years"].Success then int m.Groups.["years"].Value else 0) and months = (if m.Groups.["months"].Success then int m.Groups.["months"].Value else 0) and days = (if m.Groups.["days"].Success then int m.Groups.["days"].Value else if m.Groups.["weeks"].Success then int m.Groups.["weeks"].Value * 7 else 0) } else failwith "Invalid tenor format. Valid formats include 1Y 3M 7D 2W 1Y6M, etc" let offset tenor (date:Date) = date.AddDays(float tenor.days) .AddMonths(tenor.months) .AddYears(tenor.years) let findNthWeekDay n weekDay (date:Date) = let mutable d = new Date(date.Year, date.Month, 1) while d.DayOfWeek <> weekDay do d <- d.AddDays(1.0) for i = 1 to n - 1 do d <- d.AddDays(7.0) if d.Month = date.Month then d else failwith "No such day" // Assume ACT/360 day count convention let Actual360 period = double (period.endDate - period.startDate).Days / 360.0 let rec schedule frequency period = seq { yield period.startDate let next = frequency period.startDate if (next <= period.endDate) then yield! schedule frequency { startDate = next; endDate = period.endDate } } let semiAnnual (from:Date) = from.AddMonths(6) let isBusinessDay (date:Date) calendar = not (calendar.weekendDays.Contains date.DayOfWeek || calendar.holidays.Contains date) type RollRule = | Actual = 0 | Following = 1 | Previous = 2 | ModifiedFollowing = 3 | ModifiedPrevious = 4 let dayAfter (date:Date) = date.AddDays(1.0) let dayBefore (date:Date) = date.AddDays(-1.0) let deriv f x = let dx = (x + max (1e-6 * x) 1e-12) let fv = f x let dfv = f dx if (dx <= x) then (dfv - fv) / 1e-12 else (dfv - fv) / (dx - x) // Newton's method with separate functions for f and df let newton f (guess:double) = guess - f guess / deriv f guess // Simple recursive solver for Newton's method with separate functions for f and df, to a given accuracy let rec solveNewton f accuracy guess = let root = (newton f guess) if abs(root - guess) < accuracy then root else solveNewton f accuracy root // Assume Log-Linear interpolation let logarithmic (sampleDate:Date) highDp lowDp = let (lowDate:Date), lowFactor = lowDp let (highDate:Date), highFactor = highDp lowFactor * ((highFactor / lowFactor) ** (double (sampleDate - lowDate).Days / double (highDate - lowDate).Days)) let rec roll rule calendar date = if isBusinessDay date calendar then date else match rule with | RollRule.Actual -> date | RollRule.Following -> dayAfter date |> roll rule calendar | RollRule.Previous -> dayBefore date |> roll rule calendar | RollRule.ModifiedFollowing -> let next = roll RollRule.Following calendar date if next.Month <> date.Month then roll RollRule.Previous calendar date else next | RollRule.ModifiedPrevious -> let prev = roll RollRule.Previous calendar date if prev.Month <> date.Month then roll RollRule.Following calendar date else prev | _ -> failwith "Invalid RollRule" let rec rollBy n rule calendar (date:Date) = match n with | 0 -> date | x -> match rule with | RollRule.Actual -> date.AddDays(float x) | RollRule.Following -> dayAfter date |> roll rule calendar |> rollBy (x - 1) rule calendar | RollRule.Previous -> roll rule calendar date |> dayBefore |> roll rule calendar |> rollBy (x - 1) rule calendar | RollRule.ModifiedFollowing -> // Roll n-1 days Following let next = rollBy (x - 1) RollRule.Following calendar date // Roll the last day ModifiedFollowing let final = roll RollRule.Following calendar (dayAfter next) if final.Month <> next.Month then roll RollRule.Previous calendar next else final | RollRule.ModifiedPrevious -> // Roll n-1 days Previous let next = rollBy (x - 1) RollRule.Previous calendar date // Roll the last day ModifiedPrevious let final = roll RollRule.Previous calendar (dayAfter next) if final.Month <> next.Month then roll RollRule.Following calendar next else final | _ -> failwith "Invalid RollRule" let rec findDf interpolate sampleDate = function // exact match (dpDate:Date, dpFactor:double) :: tail when dpDate = sampleDate -> dpFactor // falls between two points - interpolate | (highDate:Date, highFactor:double) :: (lowDate:Date, lowFactor:double) :: tail when lowDate < sampleDate && sampleDate < highDate -> interpolate sampleDate (highDate, highFactor) (lowDate, lowFactor) // recurse | head :: tail -> findDf interpolate sampleDate tail // falls outside the curve | [] -> failwith "Outside the bounds of the discount curve" let findPeriodDf period discountCurve = let payDf = findDf logarithmic period.endDate discountCurve let valueDf = findDf logarithmic period.startDate discountCurve payDf / valueDf let computeDf dayCount fromDf toQuote = let dpDate, dpFactor = fromDf let qDate, qValue = toQuote (qDate, dpFactor * (1.0 / (1.0 + qValue * dayCount { startDate = dpDate; endDate = qDate }))) // Just to compute f(guess) let computeSwapDf dayCount spotDate swapQuote discountCurve swapSchedule (guessDf:double) = let qDate, qQuote = swapQuote let guessDiscountCurve = (qDate, guessDf) :: discountCurve let spotDf = findDf logarithmic spotDate discountCurve let swapDf = findPeriodDf { startDate = spotDate; endDate = qDate } guessDiscountCurve let swapVal = let rec _computeSwapDf a spotDate qQuote guessDiscountCurve = function swapPeriod :: tail -> let couponDf = findPeriodDf { startDate = spotDate; endDate = swapPeriod.endDate } guessDiscountCurve _computeSwapDf (couponDf * (dayCount swapPeriod) * qQuote + a) spotDate qQuote guessDiscountCurve tail | [] -> a _computeSwapDf -1.0 spotDate qQuote guessDiscountCurve swapSchedule spotDf * (swapVal + swapDf) [<Measure>] type bp [<Measure>] type percent [<Measure>] type price let convertPercentToRate (x:float<percent>) = x / 100.0<percent> let convertPriceToRate (x:float<price>) = (100.0<price> - x) / 100.0<price> type InterestRateQuote = | Rate of float | Percent of float<percent> | BasisPoints of float<bp> with member x.ToRate() = match x with | Rate r -> r | Percent p -> p / 100.0<percent> | BasisPoints bp -> bp / 10000.0<bp> member x.ToPercentage() = match x with | Rate r -> r * 100.0<percent> | Percent p -> p | BasisPoints bp -> bp / 100.0<bp/percent> member x.ToBasisPoints() = match x with | Rate r -> r * 10000.0<bp> | Percent p -> p * 100.0<bp/percent> | BasisPoints bp -> bp end type FuturesContract = Date let contract d = date d type QuoteType = | Overnight // the overnight rate (one day period) | TomorrowNext // the one day period starting "tomorrow" | TomorrowTomorrowNext // the one day period starting the day after "tomorrow" | Cash of Tenor // cash deposit period in days, weeks, months | Futures of FuturesContract // year and month of futures contract expiry | Swap of Tenor // swap period in years // Bootstrap the next discount factor from the previous one let rec bootstrap dayCount quotes discountCurve = match quotes with quote :: tail -> let newDf = computeDf dayCount (List.head discountCurve) quote bootstrap dayCount tail (newDf :: discountCurve) | [] -> discountCurve // Generate the next discount factor from a fixed point on the curve // (cash points are wrt to spot, not the previous df) let rec bootstrapCash dayCount spotDate quotes discountCurve = match quotes with quote :: tail -> let spotDf = (spotDate, findDf logarithmic spotDate discountCurve) let newDf = computeDf dayCount spotDf quote bootstrapCash dayCount spotDate tail (newDf :: discountCurve) | [] -> discountCurve let bootstrapFutures dayCount futuresStartDate quotes discountCurve = match futuresStartDate with | Some d -> bootstrap dayCount (Seq.toList quotes) ((d, findDf logarithmic d discountCurve) :: discountCurve) | None -> discountCurve // Swaps are computed from a schedule generated from spot and priced // according to the curve built thusfar let rec bootstrapSwaps dayCount spotDate calendar swapQuotes discountCurve = match swapQuotes with (qDate, qQuote) :: tail -> // build the schedule for this swap let swapDates = schedule semiAnnual { startDate = spotDate; endDate = qDate } let rolledSwapDates = Seq.map (fun (d:Date) -> roll RollRule.Following calendar d) swapDates let swapPeriods = Seq.toList (Seq.map (fun (s, e) -> { startDate = s; endDate = e }) (Seq.pairwise rolledSwapDates)) // solve let accuracy = 1e-12 let spotFactor = findDf logarithmic spotDate discountCurve let f = computeSwapDf dayCount spotDate (qDate, qQuote) discountCurve swapPeriods let newDf = solveNewton f accuracy spotFactor bootstrapSwaps dayCount spotDate calendar tail ((qDate, newDf) :: discountCurve) | [] -> discountCurve let USD = { weekendDays = Set [ System.DayOfWeek.Saturday; System.DayOfWeek.Sunday ]; holidays = Set [ date "2009-01-01"; date "2009-01-19"; date "2009-02-16"; date "2009-05-25"; date "2009-07-03"; date "2009-09-07"; date "2009-10-12"; date "2009-11-11"; date "2009-11-26"; date "2009-12-25" ] } let curveDate = date "2009-05-01" let spotDate = rollBy 2 RollRule.Following USD curveDate let quotes = [ (Overnight, 0.045); (TomorrowNext, 0.045); (Cash (tenor "1W"), 0.0462); (Cash (tenor "2W"), 0.0464); (Cash (tenor "3W"), 0.0465); (Cash (tenor "1M"), 0.0467); (Cash (tenor "3M"), 0.0493); (Futures (contract "Jun2009"), 95.150); (Futures (contract "Sep2009"), 95.595); (Futures (contract "Dec2009"), 95.795); (Futures (contract "Mar2010"), 95.900); (Futures (contract "Jun2010"), 95.910); (Swap (tenor "2Y"), 0.04404); (Swap (tenor "3Y"), 0.04474); (Swap (tenor "4Y"), 0.04580); (Swap (tenor "5Y"), 0.04686); (Swap (tenor "6Y"), 0.04772); (Swap (tenor "7Y"), 0.04857); (Swap (tenor "8Y"), 0.04924); (Swap (tenor "9Y"), 0.04983); (Swap (tenor "10Y"), 0.0504); (Swap (tenor "12Y"), 0.05119); (Swap (tenor "15Y"), 0.05201); (Swap (tenor "20Y"), 0.05276); (Swap (tenor "25Y"), 0.05294); (Swap (tenor "30Y"), 0.05306) ] let spotPoints = quotes |> List.choose (fun (t, q) -> match t with | Overnight _ -> Some (rollBy 1 RollRule.Following USD curveDate, q) | TomorrowNext _ -> Some (rollBy 2 RollRule.Following USD curveDate, q) | TomorrowTomorrowNext _ -> Some (rollBy 3 RollRule.Following USD curveDate, q) | _ -> None) |> List.sortBy (fun (d, _) -> d) let cashPoints = quotes |> List.choose (fun (t, q) -> match t with | Cash c -> Some (offset c spotDate |> roll RollRule.Following USD, q) | _ -> None) |> List.sortBy (fun (d, _) -> d) let futuresQuotes = quotes |> List.choose (fun (t, q) -> match t with | Futures f -> Some (f, q) | _ -> None) |> List.sortBy (fun (c, _) -> c) let (sc, _) = List.head futuresQuotes let (ec, _) = futuresQuotes.[futuresQuotes.Length - 1] let futuresStartDate = findNthWeekDay 3 System.DayOfWeek.Wednesday sc |> roll RollRule.ModifiedFollowing USD let futuresEndDate = (new Date(ec.Year, ec.Month, 1)).AddMonths(3) // "invent" an additional contract to capture the end of the futures schedule let endContract = (futuresEndDate, 0.0) let futuresPoints = Seq.append futuresQuotes [endContract] |> Seq.pairwise |> Seq.map (fun ((_, q1), (c2, _)) -> (findNthWeekDay 3 System.DayOfWeek.Wednesday c2 |> roll RollRule.ModifiedFollowing USD, (100.0 - q1) / 100.0)) |> Seq.toList let swapPoints = quotes |> List.choose (fun (t, q) -> match t with | Swap s -> Some (offset s spotDate |> roll RollRule.Following USD, q) | _ -> None) |> List.sortBy (fun (d, _) -> d) let discountFactors = [ (curveDate, 1.0) ] |> bootstrap Actual360 spotPoints |> bootstrapCash Actual360 spotDate cashPoints |> bootstrapFutures Actual360 (Some futuresStartDate) futuresPoints |> bootstrapSwaps Actual360 spotDate USD swapPoints |> Seq.sortBy (fun (qDate, _) -> qDate) printfn "Discount Factors" Seq.iter (fun (d:Date, v) -> printfn "\t%s\t%.13F" (d.ToString("yyyy-MM-dd")) v) discountFactors let zeroCouponRates = discountFactors |> Seq.map (fun (d, f) -> (d, 100.0 * -log(f) * 365.25 / double (d - curveDate).Days)) printfn "Zero-Coupon Rates" Seq.iter (fun (d:Date, v) -> printfn "\t%s\t%.13F" (d.ToString("yyyy-MM-dd")) v) zeroCouponRates

## Reader Comments (1)

Sweet F# code thanks!