Dynamic correlation model for equity

It is a well-known fact that the dynamics of correlation between equities is related to the dynamics of their spots. For example, the correlation rapidly increases during the periods of the market crash, i.e. when the spots rapidly decrease. On the other hand, the correlation decreases in a calm market. One can see from the charts of historical correlations between various equities and the index (the average of all assets) that the correlation dynamics are quite similar to each other (e.g. they jump high, when the market falls).

Figure "Historical spot and correlation dynamics" shows this effect in the period of time from Feb 2020 to Apr 2020, where the correlation increased almost to 1.

The standard approach to deal with this problem in pricing products is to use conservative estimation of the correlation. This leads to wider bid-ask spread in pricing and is probably more important in hedging. For a short position in a product PL the contribution from realized correlation and a model correlation is proportional to the correlation difference weighted by cross gamma and volatilities.

\((\rho_{model} - \rho_{realized} ) \sigma_i \sigma_j \Gamma_{ij}\)

Therefore, when the correlation significantly increases, we will get loss, if the correlation estimation is not conservative enough (not sufficiently accurate??). However, pricing with high correlation (which can be close to 1 in the case of the market crash) can lead to not competitive prices. Using the dynamic correlation model allows to deal with this problem in a consistent way.

Calibration of the model parameters is based on historical time series of equity prices and takes into account joint dynamics of time series. Chart "Model generated spot and correlation dynamics" shows a sample path of a spot and the correlation generated by the dynamic correlation model.

Impact on pricing

Let us compare impact on pricing (????) of an autocallable instrument in case of model with constant correlation and dynamic correlation. The correlation in the constant correlation model is taken as the average of the dynamic correlation model, so that both models have the same average correlation.

{ AssetNames = [|"AAPLUS"; "GOOGLUS"|]
  CouponDates =
   [|29/06/2019 12:00:00 am; 29/09/2019 12:00:00 am; 29/12/2019 12:00:00 am;
     29/03/2020 12:00:00 am; 29/06/2020 12:00:00 am; 29/09/2020 12:00:00 am;
     29/12/2020 12:00:00 am; 29/03/2021 12:00:00 am; 29/06/2021 12:00:00 am;
     29/09/2021 12:00:00 am; 29/12/2021 12:00:00 am; 29/03/2022 12:00:00 am;
     29/06/2022 12:00:00 am; 29/09/2022 12:00:00 am; 29/12/2022 12:00:00 am;
     29/03/2023 12:00:00 am; 29/06/2023 12:00:00 am; 29/09/2023 12:00:00 am;
     29/12/2023 12:00:00 am; 29/03/2024 12:00:00 am|]
  CouponPayDates =
   [|29/06/2019 12:00:00 am; 29/09/2019 12:00:00 am; 29/12/2019 12:00:00 am;
     29/03/2020 12:00:00 am; 29/06/2020 12:00:00 am; 29/09/2020 12:00:00 am;
     29/12/2020 12:00:00 am; 29/03/2021 12:00:00 am; 29/06/2021 12:00:00 am;
     29/09/2021 12:00:00 am; 29/12/2021 12:00:00 am; 29/03/2022 12:00:00 am;
     29/06/2022 12:00:00 am; 29/09/2022 12:00:00 am; 29/12/2022 12:00:00 am;
     29/03/2023 12:00:00 am; 29/06/2023 12:00:00 am; 29/09/2023 12:00:00 am;
     29/12/2023 12:00:00 am; 29/03/2024 12:00:00 am|]
  FundingDates =
   [|29/03/2019 12:00:00 am; 29/06/2019 12:00:00 am; 29/09/2019 12:00:00 am;
     29/12/2019 12:00:00 am; 29/03/2020 12:00:00 am; 29/06/2020 12:00:00 am;
     29/09/2020 12:00:00 am; 29/12/2020 12:00:00 am; 29/03/2021 12:00:00 am;
     29/06/2021 12:00:00 am; 29/09/2021 12:00:00 am; 29/12/2021 12:00:00 am;
     29/03/2022 12:00:00 am; 29/06/2022 12:00:00 am; 29/09/2022 12:00:00 am;
     29/12/2022 12:00:00 am; 29/03/2023 12:00:00 am; 29/06/2023 12:00:00 am;
     29/09/2023 12:00:00 am; 29/12/2023 12:00:00 am|]
  FundingPayDates =
   [|29/06/2019 12:00:00 am; 29/09/2019 12:00:00 am; 29/12/2019 12:00:00 am;
     29/03/2020 12:00:00 am; 29/06/2020 12:00:00 am; 29/09/2020 12:00:00 am;
     29/12/2020 12:00:00 am; 29/03/2021 12:00:00 am; 29/06/2021 12:00:00 am;
     29/09/2021 12:00:00 am; 29/12/2021 12:00:00 am; 29/03/2022 12:00:00 am;
     29/06/2022 12:00:00 am; 29/09/2022 12:00:00 am; 29/12/2022 12:00:00 am;
     29/03/2023 12:00:00 am; 29/06/2023 12:00:00 am; 29/09/2023 12:00:00 am;
     29/12/2023 12:00:00 am; 29/03/2024 12:00:00 am|]
  InitialLevels = [|189.8459463; 1176.245305|]
  CouponTriggerLevel = 0.8
  Coupon = 0.1
  FundingRate = 0.0
  Notional = 1000000.0
  Currency = USD
  PutGearing = 1.25
  Strike = 0.8
  AutocallTriggerLevel = 1.0 }

let pvDynamicCorr = Instrument.pv  dynamicCorrelationModel autocall

"3.03%of Notional"

let pvConstCorr = Instrument.pv  constantCorrelationModel autocall

"4.04%of Notional"

Two types of dynamical correlation model

We developed two types of the dynamic correlation model. One of these models is universal and can be applied to local volatility and local stochastic volatility types of models. The other model is more technically advanced and is applicable only to local stochastic volatility model and better reflects real dynamics.

Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

Multiple items
namespace FSharp.Data

--------------------
namespace Microsoft.FSharp.Data

namespace System

namespace Plotly

namespace Plotly.NET

namespace Deedle

namespace QFL

namespace QFL.Volatility

module CSV

val rates : dataPath:string -> currencyNames:'a list -> Map<'a,Series<DateTime,float>> (requires comparison)

val dataPath : string

val currencyNames : 'a list (requires comparison)

Multiple items
module List

from QFL.Misc

--------------------
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface IEnumerable
    interface IEnumerable<'T>
    member GetReverseIndex : rank:int * offset:int -> int
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    static member Cons : head:'T * tail:'T list -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    ...

val map : mapping:('T -> 'U) -> list:'T list -> 'U list

val ccy : 'a (requires comparison)

val readYieldData : path:string -> Series<DateTime,float>

Object.ToString() : string

Multiple items
module Map

from Microsoft.FSharp.Collections

--------------------
type Map<'Key,'Value (requires comparison)> =
  interface IReadOnlyDictionary<'Key,'Value>
  interface IReadOnlyCollection<KeyValuePair<'Key,'Value>>
  interface IEnumerable
  interface IComparable
  interface IEnumerable<KeyValuePair<'Key,'Value>>
  interface ICollection<KeyValuePair<'Key,'Value>>
  interface IDictionary<'Key,'Value>
  new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
  member Add : key:'Key * value:'Value -> Map<'Key,'Value>
  member Change : key:'Key * f:('Value option -> 'Value option) -> Map<'Key,'Value>
  ...

--------------------
new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>

val discreteDividends : dataPath:string -> equityNames:string [] -> Map<string,DividendDiscrete.Data>

val equityNames : string []

type Array =
  interface ICollection
  interface IEnumerable
  interface IList
  interface IStructuralComparable
  interface IStructuralEquatable
  interface ICloneable
  new : unit -> unit
  member Clone : unit -> obj
  member CopyTo : array: Array * index: int -> unit + 1 overload
  member GetEnumerator : unit -> IEnumerator
  ...

val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

val name : string

Multiple items
module Frame

from Deedle

--------------------
type Frame =
  static member ReadCsv : location:string * hasHeaders:Nullable<bool> * inferTypes:Nullable<bool> * inferRows:Nullable<int> * schema:string * separators:string * culture:string * maxRows:Nullable<int> * missingValues:string [] * preferOptions:bool -> Frame<int,string> + 1 overload
  static member ReadReader : reader:IDataReader -> Frame<int,string>
  static member CustomExpanders : Dictionary<Type,Func<obj,seq<string * Type * obj>>>
  static member NonExpandableInterfaces : ResizeArray<Type>
  static member NonExpandableTypes : HashSet<Type>

--------------------
type Frame<'TRowKey,'TColumnKey (requires equality and equality)> =
  interface IDynamicMetaObjectProvider
  interface INotifyCollectionChanged
  interface IFsiFormattable
  interface IFrame
  new : rowIndex:IIndex<'TRowKey> * columnIndex:IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:IIndexBuilder * vectorBuilder:IVectorBuilder -> Frame<'TRowKey,'TColumnKey> + 1 overload
  member AddColumn : column:'TColumnKey * series:seq<'V> -> unit + 3 overloads
  member AggregateRowsBy : groupBy:seq<'TColumnKey> * aggBy:seq<'TColumnKey> * aggFunc:Func<Series<'TRowKey,'a>,'b> -> Frame<int,'TColumnKey>
  member Clone : unit -> Frame<'TRowKey,'TColumnKey>
  member ColumnApply : f:Func<Series<'TRowKey,'T>,ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey> + 1 overload
  member DropColumn : column:'TColumnKey -> unit
  ...

--------------------
new : names:seq<'TColumnKey> * columns:seq<ISeries<'TRowKey>> -> Frame<'TRowKey,'TColumnKey>
new : rowIndex:Indices.IIndex<'TRowKey> * columnIndex:Indices.IIndex<'TColumnKey> * data:IVector<IVector> * indexBuilder:Indices.IIndexBuilder * vectorBuilder:Vectors.IVectorBuilder -> Frame<'TRowKey,'TColumnKey>

static member Frame.ReadCsv : path:string * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] * ?preferOptions:bool -> Frame<int,string>
static member Frame.ReadCsv : stream:IO.Stream * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] * ?preferOptions:bool -> Frame<int,string>
static member Frame.ReadCsv : reader:IO.TextReader * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] * ?preferOptions:bool -> Frame<int,string>
static member Frame.ReadCsv : stream:IO.Stream * hasHeaders:Nullable<bool> * inferTypes:Nullable<bool> * inferRows:Nullable<int> * schema:string * separators:string * culture:string * maxRows:Nullable<int> * missingValues:string [] * preferOptions:Nullable<bool> -> Frame<int,string>
static member Frame.ReadCsv : location:string * hasHeaders:Nullable<bool> * inferTypes:Nullable<bool> * inferRows:Nullable<int> * schema:string * separators:string * culture:string * maxRows:Nullable<int> * missingValues:string [] * preferOptions:bool -> Frame<int,string>
static member Frame.ReadCsv : path:string * indexCol:string * ?hasHeaders:bool * ?inferTypes:bool * ?inferRows:int * ?schema:string * ?separators:string * ?culture:string * ?maxRows:int * ?missingValues:string [] * ?preferOptions:bool -> Frame<'R,string> (requires equality)

Multiple items
[<Struct>]
type DateTime =
  new : year: int * month: int * day: int -> unit + 10 overloads
  member Add : value: TimeSpan -> DateTime
  member AddDays : value: float -> DateTime
  member AddHours : value: float -> DateTime
  member AddMilliseconds : value: float -> DateTime
  member AddMinutes : value: float -> DateTime
  member AddMonths : months: int -> DateTime
  member AddSeconds : value: float -> DateTime
  member AddTicks : value: int64 -> DateTime
  member AddYears : value: int -> DateTime
  ...

--------------------
DateTime ()
   (+0 other overloads)
DateTime(ticks: int64) : DateTime
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)

module DividendDiscrete

from QFL

val fromFrame : dividendsFrame:Frame<DateTime,string> -> DividendDiscrete.Data

val dividendYields : dataPath:string -> equityNames:string [] -> Map<string,Series<DateTime,float>>

val fxVolatility : dataPath:string -> fxNames:string [] -> Map<string,Frame<string,string>>

val fxNames : string []

val ccyPair : string

Multiple items
val string : value:'T -> string

--------------------
type string = String

val eqVolatility : dataPath:string -> equityNames:string [] -> Map<string,Frame<DateTime,float>>

val readVolatilityAsFrameWithWings : path:string -> Frame<DateTime,float>

val correlation : dataPath:string -> Frame<string,string>

val root : string

val marketDataPath : string

namespace System.IO

type Path =
  static member ChangeExtension : path: string * extension: string -> string
  static member Combine : path1: string * path2: string -> string + 3 overloads
  static member EndsInDirectorySeparator : path: ReadOnlySpan<char> -> bool + 1 overload
  static member GetDirectoryName : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
  static member GetExtension : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
  static member GetFileName : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
  static member GetFileNameWithoutExtension : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload
  static member GetFullPath : path: string -> string + 1 overload
  static member GetInvalidFileNameChars : unit -> char []
  static member GetInvalidPathChars : unit -> char []
  ...

IO.Path.Combine([<ParamArray>] paths: string []) : string
IO.Path.Combine(path1: string, path2: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string, path4: string) : string

val conventionsPath : string

val spotConvention : Map<string,SpotConventions>

module Json

from QFL

val readFile : filePath:string -> 'T

type SpotConventions =
  { Calendar: Calendar
    SpotLag: int
    BusinessDayConvention: BusinessDayConvention }
    static member Default : SpotConventions

val fxVolConventions : Map<string,VolatilityFrame.Settings>

module VolatilityFrame

from QFL.Volatility

type Settings =
  { SpotConvention: SpotConventions
    DeltaConventionATM: Map<string,DeltaRule>
    DeltaConvention: Map<string,DeltaRule>
    VolatilityBasis: Basis
    BusinessDayConvention: BusinessDayConvention }
    static member Default : Settings

val today : DateTime

val currencyNames : Currency list

union case Currency.USD: Currency

val fxNames : 'a []

val spots : Series<string,float>

val assetCurrency : Series<string,Currency>

Multiple items
module CSV

from DocDemoDynamicCorrelation

--------------------
module CSV

val readSpotData : path:string -> Series<string,float> * Series<string,Currency>

val ratesData : Map<Currency,Series<DateTime,float>>

val dividendsData : Map<string,DividendDiscrete.Data>

val dividendYieldData : Map<string,Series<DateTime,float>>

val fxVolatilityData : Map<string,Frame<string,string>>

val eqVolatilityData : Map<string,Frame<DateTime,float>>

val corr : Frame<string,string>

module Asset

from QFL

val fxSmileSmoothing : SmoothSpline.Parameters

module SmoothSpline

from QFL

type Parameters =
  { Accuracy: float
    Flatness: float
    Linearity: float
    Smoothness: float }

val fxAssets : FX.Data []

val ccyPair : CcyPair

type CcyPair =
  { Foreign: Currency
    Domestic: Currency }
    member Inverse : unit -> CcyPair
    override ToString : unit -> string
    static member FromString : s:string -> CcyPair
    static member Make : und:Currency * acc:Currency -> CcyPair
    static member tryFromString : s:string -> CcyPair option

static member CcyPair.FromString : s:string -> CcyPair

module FX

from QFL.Asset

type Data =
  { Name: string
    Today: DateTime
    Spot: float
    Rate: Data
    ForeignRate: Data
    VolatilitySmiles: Series<DateTime,Series<float,float>>
    ImpVol: Data
    Currency: Currency
    ForeignCurrency: Currency }
    interface IImpliedVolatility
    interface IDates
    static member build : name:string * today:DateTime * spot:float * currency:Currency * foreignCurrency:Currency * domRateCurve:Data * foreignRateCurve:Data * volatilityFrameByTenors:Frame<string,string> * ?volSettings:Settings * ?spotConvention:SpotConventions * ?smoothingParam:Parameters -> Data

static member FX.Data.build : name:string * today:DateTime * spot:float * currency:Currency * foreignCurrency:Currency * domRateCurve:Yield.Data * foreignRateCurve:Yield.Data * volatilityFrameByTenors:Frame<string,string> * ?volSettings:VolatilityFrame.Settings * ?spotConvention:SpotConventions * ?smoothingParam:SmoothSpline.Parameters -> FX.Data

CcyPair.Domestic: Currency

CcyPair.Foreign: Currency

module Yield

from QFL

union case Yield.Data.Rates: Series<DateTime,float> -> Yield.Data

val rateCurve : Series<DateTime,float>

val eqSmileSmoothing : SmoothSpline.Parameters

val eqAssets : EQ.Data []

Multiple items
module EQ

from QFL.Asset

--------------------
module EQ

from QFL

type Data =
  { Name: string
    Today: DateTime
    Spot: float
    Rate: Data
    DividendYield: Data
    DividendDiscrete: Data
    VolatilitySmiles: Series<DateTime,Series<float,float>>
    ImpVol: Data
    Currency: Currency }
    interface IImpliedVolatility
    interface IDates
    static member build : name:string * today:DateTime * spot:float * currency:Currency * rateCurve:Data * dividendsDiscrete:Data * dividendYield:Data * volatilityFrame:Frame<DateTime,float> * ?spotConvention:SpotConventions * ?smoothingParam:Parameters -> Data

static member EQ.Data.build : name:string * today:DateTime * spot:float * currency:Currency * rateCurve:Yield.Data * dividendsDiscrete:DividendDiscrete.Data * dividendYield:Yield.Data * volatilityFrame:Frame<DateTime,float> * ?spotConvention:SpotConventions * ?smoothingParam:SmoothSpline.Parameters -> EQ.Data

namespace QFL.MonteCarlo

module Instrument

from QFL.MonteCarlo

val step : x:float -> float

val x : float

State.CouponMemory: float

Multiple items
val float : value:'T -> float (requires member op_Explicit)

--------------------
[<Struct>]
type float = Double

--------------------
type float<'Measure> =
float

Multiple items
State.CashFlow: CashFlow
required field

--------------------
type CashFlow = Cash list

type CashFlow = Cash list

State.CouponDateIndex: int

Multiple items
val int : value:'T -> int (requires member op_Explicit)

--------------------
[<Struct>]
type int = int32

--------------------
type int<'Measure> =
int

State.FundingDateIndex: int

State.IsAutocalled: bool

[<Struct>]
type bool = Boolean

State.Probability: float list

type 'T list = List<'T>

val this : State

State.CashFlow: CashFlow
required field

module Enums

from QFL

Multiple items
namespace System.Data

--------------------
namespace Microsoft.FSharp.Data

Data.AssetNames: string []

Data.CouponDates: DateTime []

Data.CouponPayDates: DateTime []

Data.FundingDates: DateTime []

Data.FundingPayDates: DateTime []

Data.InitialLevels: float []

Data.CouponTriggerLevel: float

Data.Coupon: float

Data.FundingRate: float

Data.Notional: float

Multiple items
Data.Currency: Currency

--------------------
type Currency =
  | RUB
  | USD
  | EUR
  | GBP
  | CHF
  | XAU
  | JPY
  | CNH
  | TRY
  | RON
  ...
    override ToString : unit -> string
    static member FromString : s:string -> Currency option

Data.PutGearing: float

Data.Strike: float

Data.AutocallTriggerLevel: float

type IPayoffInstrument<'State,'ProcessState> =
  abstract member evolve : date:DateTime -> 'State -> 'ProcessState -> 'State
  abstract member Dates : DateTime []
  abstract member assetNames : string []
  abstract member initialState : 'State

type State =
  { mutable CouponMemory: float
    mutable CashFlow: CashFlow
    mutable CouponDateIndex: int
    mutable FundingDateIndex: int
    mutable IsAutocalled: bool
    mutable Probability: float list }
    member Clone : State

val x : Data

val concat : arrays:seq<'T []> -> 'T []

val this : Data

val date : DateTime

val state : State

val spot : float []

val contains : value:'T -> array:'T [] -> bool (requires equality)

val isAlive : float

val worst : float

val map2 : mapping:('T1 -> 'T2 -> 'U) -> array1:'T1 [] -> array2:'T2 [] -> 'U []

val y : float

val min : array:'T [] -> 'T (requires comparison)

val currCpTrig : float

val flow : float

val cpn : Cash

val cash : amount:float -> date:DateTime -> currency:Currency -> Cash

Data.Currency: Currency

val isAutocalled : bool

val prob : float

val last : array:'T [] -> 'T

type Math =
  static member Abs : value: decimal -> decimal + 6 overloads
  static member Acos : d: float -> float
  static member Acosh : d: float -> float
  static member Asin : d: float -> float
  static member Asinh : d: float -> float
  static member Atan : d: float -> float
  static member Atan2 : y: float * x: float -> float
  static member Atanh : d: float -> float
  static member BigMul : a: int * b: int -> int64 + 2 overloads
  static member BitDecrement : x: float -> float
  ...

Math.Max(val1: uint64, val2: uint64) : uint64
   (+0 other overloads)
Math.Max(val1: uint32, val2: uint32) : uint32
   (+0 other overloads)
Math.Max(val1: uint16, val2: uint16) : uint16
   (+0 other overloads)
Math.Max(val1: float32, val2: float32) : float32
   (+0 other overloads)
Math.Max(val1: sbyte, val2: sbyte) : sbyte
   (+0 other overloads)
Math.Max(val1: int64, val2: int64) : int64
   (+0 other overloads)
Math.Max(val1: int, val2: int) : int
   (+0 other overloads)
Math.Max(val1: int16, val2: int16) : int16
   (+0 other overloads)
Math.Max(val1: float, val2: float) : float
   (+0 other overloads)
Math.Max(val1: decimal, val2: decimal) : decimal
   (+0 other overloads)

val put : Cash

val funding : float

val cash : Cash

val couponDates : Frame<int,string>

val fundingDatesDates : Frame<int,string>

val autocall : Autocall.Data

module Autocall

from DocDemoDynamicCorrelation
Autocall definition

type Data =
  { AssetNames: string []
    CouponDates: DateTime []
    CouponPayDates: DateTime []
    FundingDates: DateTime []
    FundingPayDates: DateTime []
    InitialLevels: float []
    CouponTriggerLevel: float
    Coupon: float
    FundingRate: float
    Notional: float
    ... }
    interface IPayoffInstrument<State,float []>

member Frame.GetColumn : column:'TColumnKey -> Series<'TRowKey,'R>
member Frame.GetColumn : column:'TColumnKey * lookup:Lookup -> Series<'TRowKey,'R>

Multiple items
module Seq

from Plotly.NET

--------------------
module Seq

from Microsoft.FSharp.Collections

val toArray : source:seq<'T> -> 'T []

val a : EQ.Data

EQ.Data.Spot: float

type Currency =
  | RUB
  | USD
  | EUR
  | GBP
  | CHF
  | XAU
  | JPY
  | CNH
  | TRY
  | RON
  ...
    override ToString : unit -> string
    static member FromString : s:string -> Currency option

val instrumentDates : DateTime []

val getDates : instruments:seq<IPayoffInstrument<'a,'b>> -> DateTime []

val seed : int

val nPaths : int

val ntimes : int

val constantCorrelationModel : Model.MultiFactor<float []>

module Model

from QFL.MonteCarlo

val buildHY : randomGenerator:RandomGenerator -> seed:int -> nPaths:int -> ntimes:int -> allInstrumentDates:DateTime [] -> baseCurrency:Currency -> today:DateTime -> rateCurve:Yield.Data -> fxAssets:FX.Data [] -> eqAssets:EQ.Data [] -> correlation:Frame<string,string> -> Model.MultiFactor<float []>

type RandomGenerator =
  | Sobol
  | Halton
  | MersenneTwister
  | System

union case RandomGenerator.System: RandomGenerator

Multiple items
union case Html.Html: string -> Html

--------------------
type Html = | Html of string

--------------------
type HtmlAttribute =
private | HtmlAttribute of name: string * value: string
static member New : name:string * value:string -> HtmlAttribute

val chartToHTML : chart:GenericChart.GenericChart -> Html

val chart : GenericChart.GenericChart

module GenericChart

from Plotly.NET

val toChartHTML : gChart:GenericChart.GenericChart -> string

val path : string

val readCSV : symbol:string -> ISeries<DateTime>

val symbol : string

type ISeries<'K (requires equality)> =
  abstract member TryGetObject : 'K -> OptionalValue<obj>
  abstract member Index : IIndex<'K>
  abstract member Vector : IVector
  abstract member VectorBuilder : IVectorBuilder

val names : string list

val startDate : DateTime

val endDate : DateTime

val data : Frame<DateTime,string>

val filterRows : f:('R -> ObjectSeries<'C> -> bool) -> frame:Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)

val sortRowsByKey : frame:Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)

val chart : s:Series<'a,float> -> GenericChart.GenericChart (requires equality and 'a :> IConvertible)

val s : Series<'a,float> (requires equality and 'a :> IConvertible)

Multiple items
module Series

from Deedle

--------------------
type Series =
  static member ofNullables : values:seq<Nullable<'a0>> -> Series<int,'a0> (requires default constructor and value type and 'a0 :> ValueType)
  static member ofObservations : observations:seq<'c * 'd> -> Series<'c,'d> (requires equality)
  static member ofOptionalObservations : observations:seq<'K * 'a1 option> -> Series<'K,'a1> (requires equality)
  static member ofValues : values:seq<'a> -> Series<int,'a>

--------------------
type Series<'K,'V (requires equality)> =
  interface IFsiFormattable
  interface ISeries<'K>
  new : index:IIndex<'K> * vector:IVector<'V> * vectorBuilder:IVectorBuilder * indexBuilder:IIndexBuilder -> Series<'K,'V> + 3 overloads
  member After : lowerExclusive:'K -> Series<'K,'V>
  member Aggregate : aggregation:Aggregation<'K> * keySelector:Func<DataSegment<Series<'K,'V>>,'TNewKey> * valueSelector:Func<DataSegment<Series<'K,'V>>,OptionalValue<'R>> -> Series<'TNewKey,'R> (requires equality) + 1 overload
  member AsyncMaterialize : unit -> Async<Series<'K,'V>>
  member Before : upperExclusive:'K -> Series<'K,'V>
  member Between : lowerInclusive:'K * upperInclusive:'K -> Series<'K,'V>
  member Compare : another:Series<'K,'V> -> Series<'K,Diff<'V>>
  member Convert : forward:Func<'V,'R> * backward:Func<'R,'V> -> Series<'K,'R>
  ...

--------------------
new : pairs:seq<Collections.Generic.KeyValuePair<'K,'V>> -> Series<'K,'V>
new : keys:seq<'K> * values:seq<'V> -> Series<'K,'V>
new : keys:'K [] * values:'V [] -> Series<'K,'V>
new : index:Indices.IIndex<'K> * vector:IVector<'V> * vectorBuilder:Vectors.IVectorBuilder * indexBuilder:Indices.IIndexBuilder -> Series<'K,'V>

type Chart =
  static member Area : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Dash:DrawingStyle * ?Width:'a2 -> GenericChart + 1 overload
  static member Bar : keys:seq<#IConvertible> * values:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:'a2 * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart + 1 overload
  static member BoxPlot : ?x:'a0 * ?y:'a1 * ?Name:string * ?Showlegend:bool * ?Color:string * ?Fillcolor:'a2 * ?Opacity:float * ?Whiskerwidth:'a3 * ?Boxpoints:Boxpoints * ?Boxmean:BoxMean * ?Jitter:'a4 * ?Pointpos:'a5 * ?Orientation:Orientation * ?Marker:Marker * ?Line:Line * ?Alignmentgroup:'a6 * ?Offsetgroup:'a7 * ?Notched:bool * ?NotchWidth:float * ?QuartileMethod:QuartileMethod -> GenericChart + 1 overload
  static member Bubble : x:seq<#IConvertible> * y:seq<#IConvertible> * sizes:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:Orientation * ?GroupNorm:GroupNorm * ?UseWebGL:bool -> GenericChart + 1 overload
  static member Candlestick : open:seq<#IConvertible> * high:seq<#IConvertible> * low:seq<#IConvertible> * close:seq<#IConvertible> * x:seq<#IConvertible> * ?Increasing:Line * ?Decreasing:Line * ?WhiskerWidth:float * ?Line:Line * ?XCalendar:Calendar -> GenericChart + 1 overload
  static member ChoroplethMap : locations:seq<string> * z:seq<#IConvertible> * ?Text:seq<#IConvertible> * ?Locationmode:LocationFormat * ?Autocolorscale:bool * ?Colorscale:Colorscale * ?Colorbar:'a2 * ?Marker:Marker * ?Zmin:'a3 * ?Zmax:'a4 -> GenericChart
  static member Column : keys:seq<#IConvertible> * values:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:'a2 * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart + 1 overload
  static member Contour : data:seq<#seq<'a1>> * ?X:seq<#IConvertible> * ?Y:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Opacity:float * ?Colorscale:Colorscale * ?Showscale:'a4 * ?zSmooth:SmoothAlg * ?Colorbar:'a5 -> GenericChart (requires 'a1 :> IConvertible)
  static member Doughnut : values:'a0 * ?Labels:seq<string> * ?Name:string * ?Showlegend:bool * ?Colors:'a1 * ?Hole:float * ?TextPosition:TextPosition * ?TextFont:Font * ?Hoverinfo:string * ?Textinfo:'a2 * ?Opacity:float -> GenericChart + 1 overload
  static member Heatmap : data:seq<#seq<'a1>> * ?ColNames:seq<#IConvertible> * ?RowNames:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Opacity:float * ?Colorscale:Colorscale * ?Showscale:'a4 * ?Xgap:'a5 * ?Ygap:'a6 * ?zSmooth:SmoothAlg * ?Colorbar:'a7 -> GenericChart (requires 'a1 :> IConvertible)
  ...

static member Chart.Line : xy:seq<#IConvertible * #IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:'a2 * ?Width:'a3 * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Line : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:'d * ?Width:'e * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart

property Series.Keys: seq<'a> with get

property Series.Values: seq<float> with get

val chartP : s:Series<'a,float> -> GenericChart.GenericChart (requires equality and 'a :> IConvertible)

static member Chart.Point : xy:seq<#IConvertible * #IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Point : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart

val chartFrame : frame:Frame<DateTime,string> -> GenericChart.GenericChart

val frame : Frame<DateTime,string>

property Frame.ColumnKeys: seq<string> with get

val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

val c : string

static member Chart.withTraceName : ?Name:string * ?Showlegend:bool * ?Legendgroup:string * ?Visible:StyleParam.Visible -> (GenericChart.GenericChart -> GenericChart.GenericChart)

static member Chart.Combine : gCharts:seq<GenericChart.GenericChart> -> GenericChart.GenericChart

val ndata : Frame<DateTime,string>

val mapColValues : f:(ObjectSeries<'R> -> #ISeries<'b>) -> frame:Frame<'R,'C> -> Frame<'b,'C> (requires equality and equality and equality)

val col : ObjectSeries<DateTime>

member ObjectSeries.As : unit -> Series<'K,'R>

val meanIndex : Series<DateTime,float>

val transpose : frame:Frame<'R,'TColumnKey> -> Frame<'TColumnKey,'R> (requires equality and equality)

type Stats =
  static member count : series:Series<'K,'V> -> int (requires equality) + 1 overload
  static member describe : series:Series<'K,'V> -> Series<string,float> (requires equality and equality)
  static member expandingCount : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingKurt : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingMax : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingMean : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingMin : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingSkew : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingStdDev : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  static member expandingSum : series:Series<'K,'V> -> Series<'K,float> (requires equality)
  ...

static member Stats.mean : frame:Frame<'R,'C> -> Series<'C,float> (requires equality and equality)
static member Stats.mean : series:Series<'K,'V> -> float (requires equality)

member Frame.AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> -> unit
member Frame.AddColumn : column:'TColumnKey * series:seq<'V> -> unit
member Frame.AddColumn : column:'TColumnKey * series:ISeries<'TRowKey> * lookup:Lookup -> unit
member Frame.AddColumn : column:'TColumnKey * series:seq<'V> * lookup:Lookup -> unit

val logSpots : Frame<DateTime,string>

static member Frame.Log : frame:Frame<'TRowKey,'TColumnKey> -> Frame<'TRowKey,'TColumnKey>

val spotChart : GenericChart.GenericChart

static member Chart.withSize : width:float * height:float -> (GenericChart.GenericChart -> GenericChart.GenericChart)

val logRet : Frame<DateTime,string>

val diff : offset:int -> frame:Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)

val halfPeriod : float

val corrM : Series<DateTime,Frame<string,string>>

namespace Deedle.Math

type Finance =
  static member ewmCorr : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,Frame<'C,'C>> (requires equality and equality)
  static member ewmCorrMatrix : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,Matrix<float>> (requires equality and equality)
  static member ewmCov : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,Frame<'C,'C>> (requires equality and equality)
  static member ewmCovMatrix : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,Matrix<float>> (requires equality and equality)
  static member ewmVar : x:Series<'R,float> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,float> (requires equality) + 1 overload
  static member ewmVol : x:Series<'R,float> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,float> (requires equality) + 1 overload

static member Math.Finance.ewmCorr : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,Frame<'C,'C>> (requires equality and equality)

val corrS : name1:string -> name2:string -> Series<DateTime,float>

val name1 : string

val name2 : string

val mapValues : f:('T -> 'R) -> series:Series<'K,'T> -> Series<'K,'R> (requires equality)

val rho : Frame<string,string>

val corrChart : name1:string -> name2:string -> GenericChart.GenericChart

val scatter : s12:Series<'a,(#IConvertible * #IConvertible)> -> GenericChart.GenericChart (requires equality)

val s12 : Series<'a,(#IConvertible * #IConvertible)> (requires equality)

static member Chart.Scatter : xy:seq<#IConvertible * #IConvertible> * mode:StyleParam.Mode * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:StyleParam.DrawingStyle * ?Width:float * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart
static member Chart.Scatter : x:seq<#IConvertible> * y:seq<#IConvertible> * mode:StyleParam.Mode * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:StyleParam.Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<string> * ?TextPosition:StyleParam.TextPosition * ?TextFont:Font * ?Dash:StyleParam.DrawingStyle * ?Width:float * ?StackGroup:string * ?Orientation:StyleParam.Orientation * ?GroupNorm:StyleParam.GroupNorm * ?UseWebGL:bool -> GenericChart.GenericChart

property Series.Values: seq<'b * 'c> with get

module StyleParam

from Plotly.NET

union case StyleParam.Mode.Markers: StyleParam.Mode

val scatter2 : s1:Series<'a,#IConvertible> * s2:Series<'a,#IConvertible> -> GenericChart.GenericChart (requires equality)

val s1 : Series<'a,#IConvertible> (requires equality)

val s2 : Series<'a,#IConvertible> (requires equality)

val zipInner : series1:Series<'K,'V1> -> series2:Series<'K,'V2> -> Series<'K,('V1 * 'V2)> (requires equality)

module Colors

from Plotly.NET

module Table

from Plotly.NET.Colors

module Office

from Plotly.NET.Colors.Table

val colList : string list

val darkBlue : Colors.Color

val blue : Colors.Color

val green : Colors.Color

val orange : Colors.Color

val red : Colors.Color

val darkYellow : Colors.Color

val yellow : Colors.Color

val toWebColor : c:Colors.Color -> string

val getColor : i:int -> string

val i : int

property List.Length: int with get

val indexName : string

val ewmMeanIndex : Series<DateTime,float>

type Stats =
  static member corr : df:Frame<'R,'C> * ?method:CorrelationMethod -> Frame<'C,'C> (requires equality and equality) + 1 overload
  static member corr2Cov : sigmaSeries:Series<'C,float> * corrFrame:Frame<'C,'C> -> Frame<'C,'C> (requires equality)
  static member corrMatrix : df:Frame<'R,'C> * ?method:CorrelationMethod -> Matrix<float> (requires equality and equality)
  static member cov : df:Frame<'R,'C> -> Frame<'C,'C> (requires equality and equality)
  static member cov2Corr : covFrame:Frame<'C,'C> -> Series<'C,float> * Frame<'C,'C> (requires equality)
  static member covMatrix : df:Frame<'R,'C> -> Matrix<float> (requires equality and equality)
  static member ewmMean : x:Series<'R,float> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,float> (requires equality) + 1 overload
  static member median : series:Series<'R,'V> -> float (requires equality and member op_Explicit) + 1 overload
  static member movingCovarianceParallel : window:int -> df:Frame<'R,'C> -> Series<'R,Matrix<float>> (requires equality and equality)
  static member movingStdDevParallel : window:int -> df:Frame<'R,'C> -> Frame<'R,'C> (requires equality and equality)
  ...

static member Math.Stats.ewmMean : df:Frame<'R,'C> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Frame<'R,'C> (requires equality and equality)
static member Math.Stats.ewmMean : x:Series<'R,float> * ?com:float * ?span:float * ?halfLife:float * ?alpha:float -> Series<'R,float> (requires equality)

val corrChartAndIndex : GenericChart.GenericChart

static member Chart.withTitle : title:string * ?Titlefont:Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)

val corrChartAndIndexHtml : Html

val chartSample : GenericChart.GenericChart

val skip : count:int -> series:Series<'K,'T> -> Series<'K,'T> (requires equality)

val meanRho : float []

val slope : float []

val rhoFromReturn : scale:float -> shift:float -> beta:float -> rhoMin:float -> logReturn:float -> float

val scale : float

val shift : float

val beta : float

val rhoMin : float

val logReturn : float

Math.Sqrt(d: float) : float

Math.Pow(x: float, y: float) : float

val rhoMeanFunc : meanRho:'a -> slope:'b -> factor:float -> float

val meanRho : 'a

val slope : 'b

val factor : float

Math.Min(val1: uint64, val2: uint64) : uint64
   (+0 other overloads)
Math.Min(val1: uint32, val2: uint32) : uint32
   (+0 other overloads)
Math.Min(val1: uint16, val2: uint16) : uint16
   (+0 other overloads)
Math.Min(val1: float32, val2: float32) : float32
   (+0 other overloads)
Math.Min(val1: sbyte, val2: sbyte) : sbyte
   (+0 other overloads)
Math.Min(val1: int64, val2: int64) : int64
   (+0 other overloads)
Math.Min(val1: int, val2: int) : int
   (+0 other overloads)
Math.Min(val1: int16, val2: int16) : int16
   (+0 other overloads)
Math.Min(val1: float, val2: float) : float
   (+0 other overloads)
Math.Min(val1: decimal, val2: decimal) : decimal
   (+0 other overloads)

val rhoMeanFunctions : (float -> float) []

val kFactor : int

property Array.Length: int with get

val halfLife : float

val meanFactor : (float [] -> float [] [] -> float [] [])

val ewmMeanLogReturn : halfLife:float -> timesArray:float [] -> factor:float [] [] -> float [] []

val dynamicCorrelationModel : Model.MultiFactor<float []>

val rhoPaths2 : float [] [] []

val hVol : float [] []

val buildHYRho2 : randomGenerator:RandomGenerator -> seed:int -> nPaths:int -> ntimes:int -> allInstrumentDates:DateTime [] -> baseCurrency:Currency -> today:DateTime -> rateCurve:Yield.Data -> fxAssets:FX.Data [] -> eqAssets:EQ.Data [] -> correlation:Frame<string,string> -> rhoFactorBuilder:(float [] -> float [] [] -> float [] []) -> rhoFunctions:(float -> float) [] -> Model.MultiFactor<float []> * float [] [] [] * float [] []

val getPath : m:Model.MultiFactor<float []> -> iFact:int -> iPath:int -> seq<float * float>

val m : Model.MultiFactor<float []>

type MultiFactor<'ProcessState> =
  { NPaths: int
    NTimes: int
    FactorNames: string []
    Paths: 'ProcessState [] []
    FxIndex: Map<Currency,int>
    TimeDates: Series<float,DateTime>
    IndexOrdinallyDates: Series<int,DateTime>
    DiscountsByDates: Series<DateTime,float>
    Discounts: float option []
    Currency: Currency
    ... }

val iFact : int

val iPath : int

Model.MultiFactor.Paths: float [] [] []

val p : float []

val toSeq : array:'T [] -> seq<'T>

val zip : source1:seq<'T1> -> source2:seq<'T2> -> seq<'T1 * 'T2>

Model.MultiFactor.TimeDates: Series<float,DateTime>

property Series.Keys: seq<float> with get

val getCorrPath : rhoPaths:float [] [] [] -> iFact:int -> iPath:int -> Series<float,float>

val rhoPaths : float [] [] []

val skip : count:int -> source:seq<'T> -> seq<'T>

val series : observations:seq<'a * 'b> -> Series<'a,'b> (requires equality)

val getLogSeries : m:Model.MultiFactor<float []> -> iF:int -> ipath:int -> Series<float,float>

val iF : int

val ipath : int

static member Series.Log : series:Series<'K,float> -> Series<'K,float>

val ls : m:Model.MultiFactor<float []> -> iF:int -> ipath:int -> Series<float,float>

val diff : offset:int -> series:Series<'K,'T> -> Series<'K,'T> (requires equality and member ( - ))

val getLogRet : m:Model.MultiFactor<float []> -> ipath:int -> Frame<float,string>

val main : Series<float,float>

val second : Series<float,float>

val chartModelPaths : GenericChart.GenericChart

member Series.GetAt : index:int -> 'V

val chartModelPathsHtml : Html

val pvDynamicCorr : float

val pv : mcData:Model.MultiFactor<float []> -> instrument:IPayoffInstrument<'a,float []> -> float (requires member get_CashFlow and member get_Clone)

val pvDynamicCorrOfNotional : string

Multiple items
module Format

from QFL

--------------------
type Format<'Printer,'State,'Residue,'Result> = PrintfFormat<'Printer,'State,'Residue,'Result>

--------------------
type Format<'Printer,'State,'Residue,'Result,'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple>

val toPercentString : format:Printf.StringFormat<(float -> string)> -> x:float -> string

Autocall.Data.Notional: float

val pvConstCorr : float

val pvConstCorrOfNotional : string

QFL: Quant F#in Lib

Dynamic correlation model for equity

Impact on pricing

Two types of dynamical correlation model

QFL: Quant F^#_in Lib