1: open System.Text.RegularExpressions
  2: 
  3: type Date = System.DateTime
  4: let date d = System.DateTime.Parse(d)
  5: 
  6: type Period = { startDate:Date; endDate:Date }
  7: type Calendar = { weekendDays:System.DayOfWeek Set; holidays:Date Set }
  8: type Tenor = { years:int; months:int; days:int }
  9: 
 10: let tenor t =
 11:     let regex s = new Regex(s)
 12:     let pattern = regex ("(?<weeks>[0-9]+)W" + 
 13:                             "|(?<years>[0-9]+)Y(?<months>[0-9]+)M(?<days>[0-9]+)D" +
 14:                             "|(?<years>[0-9]+)Y(?<months>[0-9]+)M" + 
 15:                             "|(?<months>[0-9]+)M(?<days>[0-9]+)D" +
 16:                             "|(?<years>[0-9]+)Y" +
 17:                             "|(?<months>[0-9]+)M" +
 18:                             "|(?<days>[0-9]+)D")
 19:     let m = pattern.Match(t)
 20:     if m.Success then
 21:             { new Tenor with 
 22:                 years = (if m.Groups.["years"].Success 
 23:                          then int m.Groups.["years"].Value 
 24:                          else 0)
 25:                 and months = (if m.Groups.["months"].Success 
 26:                               then int m.Groups.["months"].Value 
 27:                               else 0) 
 28:                 and days = (if m.Groups.["days"].Success 
 29:                             then int m.Groups.["days"].Value 
 30:                             else if m.Groups.["weeks"].Success 
 31:                                  then int m.Groups.["weeks"].Value * 7 
 32:                                  else 0) }
 33:     else
 34:         failwith "Invalid tenor format. Valid formats include 1Y 3M 7D 2W 1Y6M, etc"
 35: 
 36: let offset tenor (date:Date) = 
 37:     date.AddDays(float tenor.days)
 38:         .AddMonths(tenor.months)
 39:         .AddYears(tenor.years)
 40: 
 41: let findNthWeekDay n weekDay (date:Date) =
 42:     let mutable d = new Date(date.Year, date.Month, 1)
 43:     while d.DayOfWeek <> weekDay do d <- d.AddDays(1.0)
 44:     for i = 1 to n - 1 do d <- d.AddDays(7.0)
 45:     if d.Month = date.Month then
 46:         d
 47:     else
 48:         failwith "No such day"
 49: 
 50: // Assume ACT/360 day count convention
 51: let Actual360 period = double (period.endDate - period.startDate).Days / 360.0
 52: 
 53: let rec schedule frequency period =
 54:     seq {
 55:         yield period.startDate
 56:         let next = frequency period.startDate
 57:         if (next <= period.endDate) then
 58:             yield! schedule frequency { startDate = next; endDate = period.endDate }
 59:     }
 60:     
 61: let semiAnnual (from:Date) = from.AddMonths(6)
 62: 
 63: let isBusinessDay (date:Date) calendar = 
 64:     not (calendar.weekendDays.Contains date.DayOfWeek || calendar.holidays.Contains date)
 65: 
 66: type RollRule =
 67:     | Actual = 0
 68:     | Following = 1
 69:     | Previous = 2
 70:     | ModifiedFollowing = 3
 71:     | ModifiedPrevious = 4
 72: 
 73: let dayAfter (date:Date) = date.AddDays(1.0)
 74: let dayBefore (date:Date) = date.AddDays(-1.0)
 75: 
 76: let deriv f x =
 77:     let dx = (x + max (1e-6 * x) 1e-12)
 78:     let fv = f x
 79:     let dfv = f dx
 80:     if (dx <= x) then
 81:         (dfv - fv) / 1e-12
 82:     else
 83:         (dfv - fv) / (dx - x)
 84: 
 85: // Newton's method with separate functions for f and df
 86: let newton f (guess:double) = 
 87:     guess - f guess / deriv f guess
 88: 
 89: // Simple recursive solver for Newton's method with separate functions for f and df, to a given accuracy
 90: let rec solveNewton f accuracy guess =
 91:     let root = (newton f guess)
 92:     if abs(root - guess) < accuracy then root else solveNewton f accuracy root
 93: 
 94: // Assume Log-Linear interpolation
 95: let logarithmic (sampleDate:Date) highDp lowDp = 
 96:     let (lowDate:Date), lowFactor = lowDp
 97:     let (highDate:Date), highFactor = highDp
 98:     lowFactor * 
 99:         ((highFactor / lowFactor) ** 
100:             (double (sampleDate - lowDate).Days / double (highDate - lowDate).Days))
101: 
102: let rec roll rule calendar date =
103:     if isBusinessDay date calendar then
104:         date
105:     else
106:         match rule with
107:         | RollRule.Actual -> date
108:         | RollRule.Following -> dayAfter date |> roll rule calendar
109:         | RollRule.Previous -> dayBefore date |> roll rule calendar
110:         | RollRule.ModifiedFollowing ->
111:             let next = roll RollRule.Following calendar date
112:             if next.Month <> date.Month then
113:                 roll RollRule.Previous calendar date
114:             else
115:                 next
116:         | RollRule.ModifiedPrevious ->
117:             let prev = roll RollRule.Previous calendar date
118:             if prev.Month <> date.Month then
119:                 roll RollRule.Following calendar date
120:             else
121:                 prev
122:         | _ -> failwith "Invalid RollRule"
123: 
124: let rec rollBy n rule calendar (date:Date) =
125:     match n with
126:     | 0 -> date
127:     | x -> 
128:         match rule with
129:         | RollRule.Actual -> date.AddDays(float x)
130: 
131:         | RollRule.Following -> dayAfter date
132:                                 |> roll rule calendar
133:                                 |> rollBy (x - 1) rule calendar
134: 
135:         | RollRule.Previous -> roll rule calendar date
136:                                 |> dayBefore
137:                                 |> roll rule calendar
138:                                 |> rollBy (x - 1) rule calendar
139: 
140:         | RollRule.ModifiedFollowing -> 
141:             // Roll n-1 days Following
142:             let next = rollBy (x - 1) RollRule.Following calendar date
143:                     
144:             // Roll the last day ModifiedFollowing
145:             let final = roll RollRule.Following calendar (dayAfter next)
146:             if final.Month <> next.Month then
147:                 roll RollRule.Previous calendar next
148:             else
149:                 final
150: 
151:         | RollRule.ModifiedPrevious -> 
152:             // Roll n-1 days Previous
153:             let next = rollBy (x - 1) RollRule.Previous calendar date
154:                     
155:             // Roll the last day ModifiedPrevious
156:             let final = roll RollRule.Previous calendar (dayAfter next)
157:             if final.Month <> next.Month then
158:                 roll RollRule.Following calendar next
159:             else
160:                 final
161: 
162:         | _ -> failwith "Invalid RollRule"
163: 
164: let rec findDf interpolate sampleDate =
165:     function
166:         // exact match
167:         (dpDate:Date, dpFactor:double) :: tail when dpDate = sampleDate
168:         -> dpFactor
169:                     
170:         // falls between two points - interpolate    
171:         | (highDate:Date, highFactor:double) :: (lowDate:Date, lowFactor:double) :: tail 
172:             when lowDate < sampleDate && sampleDate < highDate
173:         -> interpolate sampleDate (highDate, highFactor) (lowDate, lowFactor)
174:               
175:         // recurse      
176:         | head :: tail -> findDf interpolate sampleDate tail
177:               
178:         // falls outside the curve
179:         | [] -> failwith "Outside the bounds of the discount curve"
180: 
181: let findPeriodDf period discountCurve = 
182:     let payDf = findDf logarithmic period.endDate discountCurve
183:     let valueDf = findDf logarithmic period.startDate discountCurve
184:     payDf / valueDf
185: 
186: let computeDf dayCount fromDf toQuote =
187:     let dpDate, dpFactor = fromDf
188:     let qDate, qValue = toQuote
189:     (qDate, dpFactor * (1.0 / 
190:                         (1.0 + qValue * dayCount { startDate = dpDate; 
191:                                                     endDate = qDate })))
192: 
193: // Just to compute f(guess)
194: let computeSwapDf dayCount spotDate swapQuote discountCurve swapSchedule (guessDf:double) =
195:     let qDate, qQuote = swapQuote
196:     let guessDiscountCurve = (qDate, guessDf) :: discountCurve 
197:     let spotDf = findDf logarithmic spotDate discountCurve
198:     let swapDf = findPeriodDf { startDate = spotDate; endDate = qDate } guessDiscountCurve
199:     let swapVal =
200:         let rec _computeSwapDf a spotDate qQuote guessDiscountCurve =
201:             function
202:                 swapPeriod :: tail ->
203:                 let couponDf = findPeriodDf { startDate = spotDate; 
204:                                               endDate = swapPeriod.endDate } guessDiscountCurve
205:                 _computeSwapDf (couponDf * (dayCount swapPeriod) * qQuote + a) 
206:                     spotDate qQuote guessDiscountCurve tail
207: 
208:                 | [] -> a
209:         _computeSwapDf -1.0 spotDate qQuote guessDiscountCurve swapSchedule
210:     spotDf * (swapVal + swapDf)
211: 
212: [<Measure>] type bp
213: [<Measure>] type percent
214: [<Measure>] type price
215:         
216: let convertPercentToRate (x:float<percent>) = x / 100.0<percent>
217: let convertPriceToRate (x:float<price>) = (100.0<price> - x) / 100.0<price>
218:         
219: type InterestRateQuote =
220:     | Rate of float
221:     | Percent of float<percent>
222:     | BasisPoints of float<bp>
223:     with
224:         member x.ToRate() =
225:             match x with
226:             | Rate r -> r
227:             | Percent p -> p / 100.0<percent>
228:             | BasisPoints bp -> bp / 10000.0<bp>
229:                     
230:         member x.ToPercentage() =
231:             match x with
232:             | Rate r -> r * 100.0<percent>
233:             | Percent p -> p
234:             | BasisPoints bp -> bp / 100.0<bp/percent>
235:                     
236:         member x.ToBasisPoints() =
237:             match x with
238:             | Rate r -> r * 10000.0<bp>
239:             | Percent p -> p * 100.0<bp/percent>
240:             | BasisPoints bp -> bp
241:     end
242:                 
243: type FuturesContract = Date
244: let contract d = date d
245: 
246: type QuoteType =
247: | Overnight                     // the overnight rate (one day period)
248: | TomorrowNext                  // the one day period starting "tomorrow"
249: | TomorrowTomorrowNext          // the one day period starting the day after "tomorrow"
250: | Cash of Tenor                 // cash deposit period in days, weeks, months
251: | Futures of FuturesContract    // year and month of futures contract expiry
252: | Swap of Tenor                 // swap period in years
253: 
254: // Bootstrap the next discount factor from the previous one
255: let rec bootstrap dayCount quotes discountCurve =
256:     match quotes with
257:         quote :: tail -> 
258:         let newDf = computeDf dayCount (List.head discountCurve) quote
259:         bootstrap dayCount tail (newDf :: discountCurve)
260:         | [] -> discountCurve
261: 
262: // Generate the next discount factor from a fixed point on the curve 
263: // (cash points are wrt to spot, not the previous df)
264: let rec bootstrapCash dayCount spotDate quotes discountCurve =
265:     match quotes with
266:         quote :: tail -> 
267:         let spotDf = (spotDate, findDf logarithmic spotDate discountCurve)
268:         let newDf = computeDf dayCount spotDf quote
269:         bootstrapCash dayCount spotDate tail (newDf :: discountCurve)
270:         | [] -> discountCurve
271: 
272: let bootstrapFutures dayCount futuresStartDate quotes discountCurve =
273:     match futuresStartDate with
274:     | Some d ->
275:         bootstrap dayCount
276:                     (Seq.toList quotes) 
277:                     ((d, findDf logarithmic d discountCurve) :: discountCurve)
278:     | None -> discountCurve
279: 
280: // Swaps are computed from a schedule generated from spot and priced 
281: // according to the curve built thusfar
282: let rec bootstrapSwaps dayCount spotDate calendar swapQuotes discountCurve =
283:     match swapQuotes with
284:         (qDate, qQuote) :: tail ->
285:         // build the schedule for this swap                
286:         let swapDates = schedule semiAnnual { startDate = spotDate; endDate = qDate }
287:         let rolledSwapDates = Seq.map (fun (d:Date) -> roll RollRule.Following calendar d) 
288:                                         swapDates
289:         let swapPeriods = Seq.toList (Seq.map (fun (s, e) -> 
290:                                                 { startDate = s; 
291:                                                   endDate = e }) (Seq.pairwise rolledSwapDates))
292:                 
293:         // solve
294:         let accuracy = 1e-12
295:         let spotFactor = findDf logarithmic spotDate discountCurve
296:         let f = computeSwapDf dayCount spotDate (qDate, qQuote) discountCurve swapPeriods
297:         let newDf = solveNewton f accuracy spotFactor
298: 
299:         bootstrapSwaps dayCount spotDate calendar tail ((qDate, newDf) :: discountCurve)
300:         | [] -> discountCurve
301: 
302: let USD = { weekendDays = Set [ System.DayOfWeek.Saturday; System.DayOfWeek.Sunday ]; 
303:             holidays = Set [ date "2009-01-01"; 
304:                              date "2009-01-19"; 
305:                              date "2009-02-16"; 
306:                              date "2009-05-25"; 
307:                              date "2009-07-03"; 
308:                              date "2009-09-07"; 
309:                              date "2009-10-12"; 
310:                              date "2009-11-11"; 
311:                              date "2009-11-26"; 
312:                              date "2009-12-25" ] }
313:         
314: let curveDate = date "2009-05-01"
315: let spotDate = rollBy 2 RollRule.Following USD curveDate
316: 
317: let quotes = [ (Overnight, 0.045);
318:                (TomorrowNext, 0.045);
319:                (Cash (tenor "1W"), 0.0462);
320:                (Cash (tenor "2W"), 0.0464);
321:                (Cash (tenor "3W"), 0.0465);
322:                (Cash (tenor "1M"), 0.0467);
323:                (Cash (tenor "3M"), 0.0493);
324:                (Futures (contract "Jun2009"), 95.150);
325:                (Futures (contract "Sep2009"), 95.595);
326:                (Futures (contract "Dec2009"), 95.795);
327:                (Futures (contract "Mar2010"), 95.900);
328:                (Futures (contract "Jun2010"), 95.910);
329:                (Swap (tenor "2Y"), 0.04404);
330:                (Swap (tenor "3Y"), 0.04474);
331:                (Swap (tenor "4Y"), 0.04580);
332:                (Swap (tenor "5Y"), 0.04686);
333:                (Swap (tenor "6Y"), 0.04772);
334:                (Swap (tenor "7Y"), 0.04857);
335:                (Swap (tenor "8Y"), 0.04924);
336:                (Swap (tenor "9Y"), 0.04983);
337:                (Swap (tenor "10Y"), 0.0504);
338:                (Swap (tenor "12Y"), 0.05119);
339:                (Swap (tenor "15Y"), 0.05201);
340:                (Swap (tenor "20Y"), 0.05276);
341:                (Swap (tenor "25Y"), 0.05294);
342:                (Swap (tenor "30Y"), 0.05306) ]
343: 
344: let spotPoints = quotes
345:                     |> List.choose (fun (t, q) -> 
346:                         match t with
347:                         | Overnight _ -> Some (rollBy 1 RollRule.Following USD curveDate, q)
348:                         | TomorrowNext _ -> Some (rollBy 2 RollRule.Following USD curveDate, q)
349:                         | TomorrowTomorrowNext _ -> Some (rollBy 3 RollRule.Following USD curveDate, q)
350:                         | _ -> None)
351:                     |> List.sortBy (fun (d, _) -> d)
352: 
353: let cashPoints = quotes
354:                     |> List.choose (fun (t, q) -> 
355:                         match t with
356:                         | Cash c -> Some (offset c spotDate |> roll RollRule.Following USD, q)
357:                         | _ -> None)
358:                     |> List.sortBy (fun (d, _) -> d)
359: 
360: let futuresQuotes = quotes
361:                     |> List.choose (fun (t, q) -> 
362:                         match t with
363:                         | Futures f -> Some (f, q)
364:                         | _ -> None)
365:                     |> List.sortBy (fun (c, _) -> c)
366:                                 
367: let (sc, _) = List.head futuresQuotes
368: let (ec, _) = futuresQuotes.[futuresQuotes.Length - 1]   
369: let futuresStartDate = findNthWeekDay 3 System.DayOfWeek.Wednesday sc 
370:                         |> roll RollRule.ModifiedFollowing USD
371: let futuresEndDate = (new Date(ec.Year, ec.Month, 1)).AddMonths(3)
372: 
373: // "invent" an additional contract to capture the end of the futures schedule
374: let endContract = (futuresEndDate, 0.0)
375:             
376: let futuresPoints = Seq.append futuresQuotes [endContract]
377:                     |> Seq.pairwise
378:                     |> Seq.map (fun ((_, q1), (c2, _)) -> 
379:                         (findNthWeekDay 3 System.DayOfWeek.Wednesday c2 
380:                             |> roll RollRule.ModifiedFollowing USD, (100.0 - q1) / 100.0))
381:                     |> Seq.toList            
382:             
383: let swapPoints = quotes
384:                     |> List.choose (fun (t, q) -> 
385:                         match t with
386:                         | Swap s -> Some (offset s spotDate |> roll RollRule.Following USD, q)
387:                         | _ -> None)
388:                     |> List.sortBy (fun (d, _) -> d)
389: 
390: let discountFactors = [ (curveDate, 1.0) ]
391:                         |> bootstrap Actual360 spotPoints 
392:                         |> bootstrapCash Actual360 spotDate cashPoints
393:                         |> bootstrapFutures Actual360 (Some futuresStartDate) futuresPoints
394:                         |> bootstrapSwaps Actual360 spotDate USD swapPoints
395:                         |> Seq.sortBy (fun (qDate, _) -> qDate)
396: 
397: printfn "Discount Factors"
398: Seq.iter (fun (d:Date, v) -> printfn "\t%s\t%.13F" (d.ToString("yyyy-MM-dd")) v) discountFactors
399:             
400: let zeroCouponRates = discountFactors 
401:                       |> Seq.map (fun (d, f) 
402:                                     -> (d, 100.0 * -log(f) * 365.25 / double (d - curveDate).Days))
403: 
404: printfn "Zero-Coupon Rates"
405: Seq.iter (fun (d:Date, v) -> printfn "\t%s\t%.13F" (d.ToString("yyyy-MM-dd")) v) zeroCouponRates
406: