## Discount/Zero Curve Construction

A simplistic discount curve bootstrapping process

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) =
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>
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
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
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
val isBusinessDay : Date -> Calendar -> bool

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 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

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