Discount/Zero Curve Construction

A simplistic discount curve bootstrapping process

Copy Source
Copy Link
Tools:
  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: 
namespace System
namespace System.Text
namespace System.Text.RegularExpressions
type Date = System.DateTime

Full name: Snippet.Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
type DateTime =
  struct
    new : int64 -> System.DateTime
    new : int64 * System.DateTimeKind -> System.DateTime
    new : int * int * int -> System.DateTime
    new : int * int * int * System.Globalization.Calendar -> System.DateTime
    new : int * int * int * int * int * int -> System.DateTime
    new : int * int * int * int * int * int * System.DateTimeKind -> System.DateTime
    new : int * int * int * int * int * int * System.Globalization.Calendar -> System.DateTime
    new : int * int * int * int * int * int * int -> System.DateTime
    new : int * int * int * int * int * int * int * System.DateTimeKind -> System.DateTime
    new : int * int * int * int * int * int * int * System.Globalization.Calendar -> System.DateTime
    new : int * int * int * int * int * int * int * System.Globalization.Calendar * System.DateTimeKind -> System.DateTime
    member Add : System.TimeSpan -> System.DateTime
    member AddDays : float -> System.DateTime
    member AddHours : float -> System.DateTime
    member AddMilliseconds : float -> System.DateTime
    member AddMinutes : float -> System.DateTime
    member AddMonths : int -> System.DateTime
    member AddSeconds : float -> System.DateTime
    member AddTicks : int64 -> System.DateTime
    member AddYears : int -> System.DateTime
    member CompareTo : obj -> int
    member CompareTo : System.DateTime -> int
    member Date : System.DateTime
    member Day : int
    member DayOfWeek : System.DayOfWeek
    member DayOfYear : int
    member Equals : obj -> bool
    member Equals : System.DateTime -> bool
    member GetDateTimeFormats : unit -> string []
    member GetDateTimeFormats : System.IFormatProvider -> string []
    member GetDateTimeFormats : char -> string []
    member GetDateTimeFormats : char * System.IFormatProvider -> string []
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member Hour : int
    member IsDaylightSavingTime : unit -> bool
    member Kind : System.DateTimeKind
    member Millisecond : int
    member Minute : int
    member Month : int
    member Second : int
    member Subtract : System.DateTime -> System.TimeSpan
    member Subtract : System.TimeSpan -> System.DateTime
    member Ticks : int64
    member TimeOfDay : System.TimeSpan
    member ToBinary : unit -> int64
    member ToFileTime : unit -> int64
    member ToFileTimeUtc : unit -> int64
    member ToLocalTime : unit -> System.DateTime
    member ToLongDateString : unit -> string
    member ToLongTimeString : unit -> string
    member ToOADate : unit -> float
    member ToShortDateString : unit -> string
    member ToShortTimeString : unit -> string
    member ToString : unit -> string
    member ToString : string -> string
    member ToString : System.IFormatProvider -> string
    member ToString : string * System.IFormatProvider -> string
    member ToUniversalTime : unit -> System.DateTime
    member Year : int
    static val MinValue : System.DateTime
    static val MaxValue : System.DateTime
    static member Compare : System.DateTime * System.DateTime -> int
    static member DaysInMonth : int * int -> int
    static member Equals : System.DateTime * System.DateTime -> bool
    static member FromBinary : int64 -> System.DateTime
    static member FromFileTime : int64 -> System.DateTime
    static member FromFileTimeUtc : int64 -> System.DateTime
    static member FromOADate : float -> System.DateTime
    static member IsLeapYear : int -> bool
    static member Now : System.DateTime
    static member Parse : string -> System.DateTime
    static member Parse : string * System.IFormatProvider -> System.DateTime
    static member Parse : string * System.IFormatProvider * System.Globalization.DateTimeStyles -> System.DateTime
    static member ParseExact : string * string * System.IFormatProvider -> System.DateTime
    static member ParseExact : string * string * System.IFormatProvider * System.Globalization.DateTimeStyles -> System.DateTime
    static member ParseExact : string * string [] * System.IFormatProvider * System.Globalization.DateTimeStyles -> System.DateTime
    static member SpecifyKind : System.DateTime * System.DateTimeKind -> System.DateTime
    static member Today : System.DateTime
    static member TryParse : string * System.DateTime -> bool
    static member TryParse : string * System.IFormatProvider * System.Globalization.DateTimeStyles * System.DateTime -> bool
    static member TryParseExact : string * string * System.IFormatProvider * System.Globalization.DateTimeStyles * System.DateTime -> bool
    static member TryParseExact : string * string [] * System.IFormatProvider * System.Globalization.DateTimeStyles * System.DateTime -> bool
    static member UtcNow : System.DateTime
  end

Full name: System.DateTime

  type: System.DateTime
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val date : string -> System.DateTime

Full name: Snippet.date
val d : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple overloads
System.DateTime.Parse(s: string) : System.DateTime
System.DateTime.Parse(s: string, provider: System.IFormatProvider) : System.DateTime
System.DateTime.Parse(s: string, provider: System.IFormatProvider, styles: System.Globalization.DateTimeStyles) : System.DateTime
type Period =
  {startDate: Date;
   endDate: Date;}

Full name: Snippet.Period

  type: Period
  implements: System.IEquatable<Period>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Period>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
Period.startDate: Date
Period.endDate: Date
type Calendar =
  {weekendDays: Set<System.DayOfWeek>;
   holidays: Set<Date>;}

Full name: Snippet.Calendar

  type: Calendar
  implements: System.IEquatable<Calendar>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Calendar>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
Calendar.weekendDays: Set<System.DayOfWeek>
type DayOfWeek =
  | Sunday = 0
  | Monday = 1
  | Tuesday = 2
  | Wednesday = 3
  | Thursday = 4
  | Friday = 5
  | Saturday = 6

Full name: System.DayOfWeek

  type: System.DayOfWeek
  inherits: System.Enum
  inherits: System.ValueType
Multiple items
module Set

from Microsoft.FSharp.Collections

--------------------

type Set<'T (requires comparison)> =
  class
    interface System.IComparable
    interface System.Collections.IEnumerable
    interface System.Collections.Generic.IEnumerable<'T>
    interface System.Collections.Generic.ICollection<'T>
    new : elements:seq<'T> -> Set<'T>
    member Add : value:'T -> Set<'T>
    member Contains : value:'T -> bool
    override Equals : obj -> bool
    member IsProperSubsetOf : otherSet:Set<'T> -> bool
    member IsProperSupersetOf : otherSet:Set<'T> -> bool
    member IsSubsetOf : otherSet:Set<'T> -> bool
    member IsSupersetOf : otherSet:Set<'T> -> bool
    member Remove : value:'T -> Set<'T>
    member Count : int
    member IsEmpty : bool
    member MaximumElement : 'T
    member MinimumElement : 'T
    static member ( + ) : set1:Set<'T> * set2:Set<'T> -> Set<'T>
    static member ( - ) : set1:Set<'T> * set2:Set<'T> -> Set<'T>
  end

Full name: Microsoft.FSharp.Collections.Set<_>

  type: Set<'T>
  implements: System.IComparable
  implements: System.Collections.Generic.ICollection<'T>
  implements: seq<'T>
  implements: System.Collections.IEnumerable
Calendar.holidays: Set<Date>
type Tenor =
  {years: int;
   months: int;
   days: int;}

Full name: Snippet.Tenor

  type: Tenor
  implements: System.IEquatable<Tenor>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Tenor>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
Tenor.years: int
Multiple items
val int : 'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------

type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

  type: int<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<int<'Measure>>
  implements: System.IEquatable<int<'Measure>>
  inherits: System.ValueType


--------------------

type int = int32

Full name: Microsoft.FSharp.Core.int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
Tenor.months: int
Tenor.days: int
val tenor : string -> Tenor

Full name: Snippet.tenor
val t : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val regex : (string -> Regex)
val s : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
type Regex =
  class
    new : string -> System.Text.RegularExpressions.Regex
    new : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
    member GetGroupNames : unit -> string []
    member GetGroupNumbers : unit -> int []
    member GroupNameFromNumber : int -> string
    member GroupNumberFromName : string -> int
    member IsMatch : string -> bool
    member IsMatch : string * int -> bool
    member Match : string -> System.Text.RegularExpressions.Match
    member Match : string * int -> System.Text.RegularExpressions.Match
    member Match : string * int * int -> System.Text.RegularExpressions.Match
    member Matches : string -> System.Text.RegularExpressions.MatchCollection
    member Matches : string * int -> System.Text.RegularExpressions.MatchCollection
    member Options : System.Text.RegularExpressions.RegexOptions
    member Replace : string * string -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string
    member Replace : string * string * int -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string
    member Replace : string * string * int * int -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string
    member RightToLeft : bool
    member Split : string -> string []
    member Split : string * int -> string []
    member Split : string * int * int -> string []
    member ToString : unit -> string
    static member CacheSize : int with get, set
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName -> unit
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder [] -> unit
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder [] * string -> unit
    static member Escape : string -> string
    static member IsMatch : string * string -> bool
    static member IsMatch : string * string * System.Text.RegularExpressions.RegexOptions -> bool
    static member Match : string * string -> System.Text.RegularExpressions.Match
    static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match
    static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection
    static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection
    static member Replace : string * string * string -> string
    static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string
    static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string
    static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string
    static member Split : string * string -> string []
    static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string []
    static member Unescape : string -> string
  end

Full name: System.Text.RegularExpressions.Regex

  type: Regex
  implements: System.Runtime.Serialization.ISerializable
val pattern : Regex

  type: Regex
  implements: System.Runtime.Serialization.ISerializable
val m : Match

  type: Match
  inherits: Group
  inherits: Capture
Multiple overloads
Regex.Match(input: string) : Match
Regex.Match(input: string, startat: int) : Match
Regex.Match(input: string, beginning: int, length: int) : Match
property Group.Success: bool
property Match.Groups: GroupCollection
val failwith : string -> 'T

Full name: Microsoft.FSharp.Core.Operators.failwith
val offset : Tenor -> Date -> System.DateTime

Full name: Snippet.offset
val tenor : Tenor

  type: Tenor
  implements: System.IEquatable<Tenor>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Tenor>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val date : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
System.DateTime.AddDays(value: float) : System.DateTime
Multiple items
val float : 'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------

type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

  type: float<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<'Measure>>
  implements: System.IEquatable<float<'Measure>>
  inherits: System.ValueType


--------------------

type float = System.Double

Full name: Microsoft.FSharp.Core.float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val findNthWeekDay : int -> System.DayOfWeek -> Date -> Date

Full name: Snippet.findNthWeekDay
val n : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val weekDay : System.DayOfWeek

  type: System.DayOfWeek
  inherits: System.Enum
  inherits: System.ValueType
val mutable d : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
property System.DateTime.Year: int
property System.DateTime.Month: int
property System.DateTime.DayOfWeek: System.DayOfWeek
val i : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val Actual360 : Period -> float

Full name: Snippet.Actual360
val period : Period

  type: Period
  implements: System.IEquatable<Period>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Period>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
Multiple items
val double : 'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.double

--------------------

type double = System.Double

Full name: Microsoft.FSharp.Core.double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val schedule : (Date -> Date) -> Period -> seq<Date>

Full name: Snippet.schedule
val frequency : (Date -> Date)
Multiple items
val seq : seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Core.Operators.seq

--------------------

type seq<'T> = System.Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>

  type: seq<'T>
  inherits: System.Collections.IEnumerable
val next : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val semiAnnual : Date -> System.DateTime

Full name: Snippet.semiAnnual
val from : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
System.DateTime.AddMonths(months: int) : System.DateTime
val isBusinessDay : Date -> Calendar -> bool

Full name: Snippet.isBusinessDay
val calendar : Calendar

  type: Calendar
  implements: System.IEquatable<Calendar>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Calendar>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val not : bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not
member Set.Contains : value:'T -> bool
type RollRule =
  | Actual = 0
  | Following = 1
  | Previous = 2
  | ModifiedFollowing = 3
  | ModifiedPrevious = 4

Full name: Snippet.RollRule

  type: RollRule
  inherits: System.Enum
  inherits: System.ValueType
RollRule.Actual: RollRule = 0
RollRule.Following: RollRule = 1
RollRule.Previous: RollRule = 2
RollRule.ModifiedFollowing: RollRule = 3
RollRule.ModifiedPrevious: RollRule = 4
val dayAfter : Date -> System.DateTime

Full name: Snippet.dayAfter
val dayBefore : Date -> System.DateTime

Full name: Snippet.dayBefore
val deriv : (float -> float) -> float -> float

Full name: Snippet.deriv
val f : (float -> float)
val x : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val dx : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val max : 'T -> 'T -> 'T (requires comparison)

Full name: Microsoft.FSharp.Core.Operators.max
val fv : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val dfv : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val newton : (double -> float) -> double -> double

Full name: Snippet.newton
val f : (double -> float)
val guess : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val solveNewton : (double -> float) -> double -> double -> double

Full name: Snippet.solveNewton
val accuracy : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val root : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val abs : 'T -> 'T (requires member Abs)

Full name: Microsoft.FSharp.Core.Operators.abs
val logarithmic : Date -> Date * double -> Date * double -> double

Full name: Snippet.logarithmic
val sampleDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val highDp : Date * double
val lowDp : Date * double
val lowDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val lowFactor : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val highDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val highFactor : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val roll : RollRule -> Calendar -> Date -> Date

Full name: Snippet.roll
val rule : RollRule

  type: RollRule
  inherits: System.Enum
  inherits: System.ValueType
val prev : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val rollBy : int -> RollRule -> Calendar -> Date -> Date

Full name: Snippet.rollBy
val x : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val final : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val findDf : (Date -> Date * double -> Date * double -> double) -> Date -> (Date * double) list -> double

Full name: Snippet.findDf
val interpolate : (Date -> Date * double -> Date * double -> double)
val dpDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val dpFactor : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val tail : (Date * double) list

  type: (Date * double) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * double>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * double>
  implements: System.Collections.IEnumerable
val head : Date * double
val findPeriodDf : Period -> (Date * double) list -> double

Full name: Snippet.findPeriodDf
val discountCurve : (Date * double) list

  type: (Date * double) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * double>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * double>
  implements: System.Collections.IEnumerable
val payDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val valueDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val computeDf : (Period -> float) -> Date * float -> Date * float -> Date * float

Full name: Snippet.computeDf
val dayCount : (Period -> float)
val fromDf : Date * float
val toQuote : Date * float
val dpFactor : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val qDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val qValue : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val computeSwapDf : (Period -> double) -> Date -> Date * double -> (Date * double) list -> Period list -> double -> double

Full name: Snippet.computeSwapDf
val dayCount : (Period -> double)
val spotDate : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val swapQuote : Date * double
val swapSchedule : Period list

  type: Period list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Period>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Period>
  implements: System.Collections.IEnumerable
val guessDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val qQuote : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val guessDiscountCurve : (Date * double) list

  type: (Date * double) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * double>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * double>
  implements: System.Collections.IEnumerable
val spotDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val swapDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val swapVal : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val _computeSwapDf : (double -> Date -> double -> (Date * double) list -> Period list -> double)
val a : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val swapPeriod : Period

  type: Period
  implements: System.IEquatable<Period>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Period>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val tail : Period list

  type: Period list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Period>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Period>
  implements: System.Collections.IEnumerable
val couponDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
Multiple items
module Measure

from Microsoft.FSharp.Math

--------------------

type MeasureAttribute =
  class
    inherit System.Attribute
    new : unit -> MeasureAttribute
  end

Full name: Microsoft.FSharp.Core.MeasureAttribute

  type: MeasureAttribute
  implements: System.Runtime.InteropServices._Attribute
  inherits: System.Attribute
[<Measure>]
type bp

Full name: Snippet.bp
[<Measure>]
type percent

Full name: Snippet.percent
[<Measure>]
type price

Full name: Snippet.price
val convertPercentToRate : float<percent> -> float

Full name: Snippet.convertPercentToRate
val x : float<percent>

  type: float<percent>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<percent>>
  implements: System.IEquatable<float<percent>>
  inherits: System.ValueType
val convertPriceToRate : float<price> -> float

Full name: Snippet.convertPriceToRate
val x : float<price>

  type: float<price>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<price>>
  implements: System.IEquatable<float<price>>
  inherits: System.ValueType
type InterestRateQuote =
  | Rate of float
  | Percent of float<percent>
  | BasisPoints of float<bp>
  with
    member ToBasisPoints : unit -> float<bp>
    member ToPercentage : unit -> float<percent>
    member ToRate : unit -> float
  end

Full name: Snippet.InterestRateQuote

  type: InterestRateQuote
  implements: System.IEquatable<InterestRateQuote>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<InterestRateQuote>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case InterestRateQuote.Rate: float -> InterestRateQuote
union case InterestRateQuote.Percent: float<percent> -> InterestRateQuote
union case InterestRateQuote.BasisPoints: float<bp> -> InterestRateQuote
val x : InterestRateQuote

  type: InterestRateQuote
  implements: System.IEquatable<InterestRateQuote>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<InterestRateQuote>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
member InterestRateQuote.ToRate : unit -> float

Full name: Snippet.InterestRateQuote.ToRate
val r : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val p : float<percent>

  type: float<percent>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<percent>>
  implements: System.IEquatable<float<percent>>
  inherits: System.ValueType
Multiple items
val bp : float<bp>

  type: float<bp>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<bp>>
  implements: System.IEquatable<float<bp>>
  inherits: System.ValueType


--------------------

[<Measure>]
type bp

Full name: Snippet.bp
member InterestRateQuote.ToPercentage : unit -> float<percent>

Full name: Snippet.InterestRateQuote.ToPercentage
member InterestRateQuote.ToBasisPoints : unit -> float<bp>

Full name: Snippet.InterestRateQuote.ToBasisPoints
type FuturesContract = Date

Full name: Snippet.FuturesContract

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val contract : string -> System.DateTime

Full name: Snippet.contract
type QuoteType =
  | Overnight
  | TomorrowNext
  | TomorrowTomorrowNext
  | Cash of Tenor
  | Futures of FuturesContract
  | Swap of Tenor

Full name: Snippet.QuoteType

  type: QuoteType
  implements: System.IEquatable<QuoteType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<QuoteType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case QuoteType.Overnight: QuoteType
union case QuoteType.TomorrowNext: QuoteType
union case QuoteType.TomorrowTomorrowNext: QuoteType
union case QuoteType.Cash: Tenor -> QuoteType
union case QuoteType.Futures: FuturesContract -> QuoteType
union case QuoteType.Swap: Tenor -> QuoteType
val bootstrap : (Period -> float) -> (Date * float) list -> (Date * float) list -> (Date * float) list

Full name: Snippet.bootstrap
val quotes : (Date * float) list

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val discountCurve : (Date * float) list

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val quote : Date * float
val tail : (Date * float) list

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val newDf : Date * float
Multiple items
module List

from Microsoft.FSharp.Collections

--------------------

type List<'T> =
  | ( [] )
  | ( :: ) of 'T * 'T list
  with
    interface System.Collections.IEnumerable
    interface System.Collections.Generic.IEnumerable<'T>
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    member Tail : 'T list
    static member Cons : head:'T * tail:'T list -> 'T list
    static member Empty : 'T list
  end

Full name: Microsoft.FSharp.Collections.List<_>

  type: List<'T>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<'T>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<'T>
  implements: System.Collections.IEnumerable
val head : 'T list -> 'T

Full name: Microsoft.FSharp.Collections.List.head
val bootstrapCash : (Period -> float) -> Date -> (Date * float) list -> (Date * double) list -> (Date * double) list

Full name: Snippet.bootstrapCash
val spotDf : Date * double
val bootstrapFutures : (Period -> float) -> Date option -> seq<Date * float> -> (Date * double) list -> (Date * float) list

Full name: Snippet.bootstrapFutures
val futuresStartDate : Date option

  type: Date option
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Option<Date>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val quotes : seq<Date * float>

  type: seq<Date * float>
  inherits: System.Collections.IEnumerable
union case Option.Some: 'T -> Option<'T>
val d : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
module Seq

from Microsoft.FSharp.Collections
val toList : seq<'T> -> 'T list

Full name: Microsoft.FSharp.Collections.Seq.toList
union case Option.None: Option<'T>
val bootstrapSwaps : (Period -> double) -> Date -> Calendar -> (Date * double) list -> (Date * double) list -> (Date * double) list

Full name: Snippet.bootstrapSwaps
val swapQuotes : (Date * double) list

  type: (Date * double) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * double>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * double>
  implements: System.Collections.IEnumerable
val swapDates : seq<Date>

  type: seq<Date>
  inherits: System.Collections.IEnumerable
val rolledSwapDates : seq<Date>

  type: seq<Date>
  inherits: System.Collections.IEnumerable
val map : ('T -> 'U) -> seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
val swapPeriods : Period list

  type: Period list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Period>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Period>
  implements: System.Collections.IEnumerable
val s : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val e : Date

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val pairwise : seq<'T> -> seq<'T * 'T>

Full name: Microsoft.FSharp.Collections.Seq.pairwise
val accuracy : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val spotFactor : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val f : (double -> double)
val newDf : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val USD : Calendar

Full name: Snippet.USD

  type: Calendar
  implements: System.IEquatable<Calendar>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Calendar>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
field System.DayOfWeek.Saturday = 6
field System.DayOfWeek.Sunday = 0
val curveDate : System.DateTime

Full name: Snippet.curveDate

  type: System.DateTime
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val spotDate : Date

Full name: Snippet.spotDate

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val quotes : (QuoteType * float) list

Full name: Snippet.quotes

  type: (QuoteType * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<QuoteType * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<QuoteType * float>
  implements: System.Collections.IEnumerable
val spotPoints : (Date * float) list

Full name: Snippet.spotPoints

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val choose : ('T -> 'U option) -> 'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.choose
val t : QuoteType

  type: QuoteType
  implements: System.IEquatable<QuoteType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<QuoteType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val q : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val sortBy : ('T -> 'Key) -> 'T list -> 'T list (requires comparison)

Full name: Microsoft.FSharp.Collections.List.sortBy
val cashPoints : (Date * float) list

Full name: Snippet.cashPoints

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val c : Tenor

  type: Tenor
  implements: System.IEquatable<Tenor>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Tenor>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val futuresQuotes : (FuturesContract * float) list

Full name: Snippet.futuresQuotes

  type: (FuturesContract * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<FuturesContract * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<FuturesContract * float>
  implements: System.Collections.IEnumerable
val f : FuturesContract

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val c : FuturesContract

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val sc : FuturesContract

Full name: Snippet.sc

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val ec : FuturesContract

Full name: Snippet.ec

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
property List.Length: int
val futuresStartDate : Date

Full name: Snippet.futuresStartDate

  type: Date
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
field System.DayOfWeek.Wednesday = 3
val futuresEndDate : System.DateTime

Full name: Snippet.futuresEndDate

  type: System.DateTime
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val endContract : System.DateTime * float

Full name: Snippet.endContract
val futuresPoints : (Date * float) list

Full name: Snippet.futuresPoints

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val append : seq<'T> -> seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.append
val q1 : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val c2 : FuturesContract

  type: FuturesContract
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.ISerializable
  implements: System.IComparable<System.DateTime>
  implements: System.IEquatable<System.DateTime>
  inherits: System.ValueType
val swapPoints : (Date * float) list

Full name: Snippet.swapPoints

  type: (Date * float) list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<Date * float>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<Date * float>
  implements: System.Collections.IEnumerable
val s : Tenor

  type: Tenor
  implements: System.IEquatable<Tenor>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<Tenor>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val discountFactors : seq<Date * double>

Full name: Snippet.discountFactors

  type: seq<Date * double>
  inherits: System.Collections.IEnumerable
val sortBy : ('T -> 'Key) -> seq<'T> -> seq<'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Seq.sortBy
val printfn : Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
val iter : ('T -> unit) -> seq<'T> -> unit

Full name: Microsoft.FSharp.Collections.Seq.iter
val v : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val zeroCouponRates : seq<Date * float>

Full name: Snippet.zeroCouponRates

  type: seq<Date * float>
  inherits: System.Collections.IEnumerable
val f : double

  type: double
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val log : 'T -> 'T (requires member Log)

Full name: Microsoft.FSharp.Core.Operators.log
val v : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType

More information

Link: http://fssnip.net/5I
Posted: 3 years ago
Author: Wayne Bradney (website)
Tags: finance