hasquant 0.7.0.0 → 0.8.0.0

raw patch · 111 files changed

+28386/−11110 lines, 111 filesdep ~timedep ~vectorPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: time, vector

API changes (from Hackage documentation)

Files

• CHANGELOG.md +28/−0
• QuantLib/CashFlow.chs +213/−55
• QuantLib/Commodity.chs +22/−13
• QuantLib/Context.chs +38/−1
• QuantLib/Credit.chs +2/−2
• QuantLib/Currency.chs +5/−1
• QuantLib/Index.chs +46/−32
• QuantLib/Index/Equity.chs +0/−1
• QuantLib/Index/Inflation.chs +5/−6
• QuantLib/Index/InterestRate.chs +0/−2
• QuantLib/Instrument.chs +5/−8
• QuantLib/Instrument/Bond.chs +9/−13
• QuantLib/Instrument/CapFloor.chs +0/−1
• QuantLib/Instrument/Credit.chs +1/−3
• QuantLib/Instrument/Energy.chs +19/−19
• QuantLib/Instrument/Forward.chs +0/−1
• QuantLib/Instrument/InflationCapFloor.chs +1/−2
• QuantLib/Instrument/Option.chs +1/−3
• QuantLib/Instrument/Swap.chs +289/−78
• QuantLib/InterestRate.chs +22/−0
• QuantLib/Internal.hs +116/−68
• QuantLib/Internal/CalendarEnum.chs +1/−0
• QuantLib/Internal/Callback.chs +73/−0
• QuantLib/Internal/Common.chs +101/−99
• QuantLib/Internal/Type.hs +301/−292
• QuantLib/Math.chs +8/−8
• QuantLib/Method.chs +138/−64
• QuantLib/Model.chs +127/−53
• QuantLib/PricingEngine.chs +312/−122
• QuantLib/Process.chs +18/−19
• QuantLib/Quote.chs +7/−9
• QuantLib/TermStructure.chs +5/−6
• QuantLib/TermStructure/Commodity.chs +6/−3
• QuantLib/TermStructure/Credit.chs +61/−19
• QuantLib/TermStructure/Inflation.chs +136/−19
• QuantLib/TermStructure/InflationVolatility.chs +13/−13
• QuantLib/TermStructure/Volatility.chs +304/−34
• QuantLib/TermStructure/Yield.chs +538/−120
• QuantLib/Time/Calendar.chs +3/−1
• QuantLib/Time/Date.chs +7/−4
• QuantLib/Time/Schedule.chs +1/−1
• README.md +94/−31
• WINDOWS.md +3/−1
• app/SofrXva/Pricing.hs +1/−1
• cbits/ql.h +1/−0
• cbits/qlCallback.cpp +87/−0
• cbits/qlCallback.h +44/−0
• cbits/qlCallback.hpp +84/−0
• cbits/qlCheckedFdEngine.h +19/−0
• cbits/qlEnumC2HS.h +3/−5
• cbits/qlEnumObjects.h +2/−0
• cbits/qlExactMeanH1HwEngine.h +134/−0
• cbits/qlInstrument.cpp +2930/−2298
• cbits/qlInstrument.h +1000/−983
• cbits/qlMisc.cpp +292/−235
• cbits/qlMisc.h +211/−217
• cbits/qlPricingEngine.cpp +2202/−1886
• cbits/qlPricingEngine.h +482/−448
• cbits/qlPricingEngineAux.cpp +37/−42
• cbits/qlPricingEngineAux.h +2/−1
• cbits/qlStdCompat.h +31/−0
• cbits/qlTermStructure.cpp +2997/−2600
• cbits/qlTermStructure.h +469/−396
• cbits/qlTermStructureAux.cpp +152/−54
• cbits/qlTermStructureAux.h +138/−4
• cbits/qlTypesC2HS.h +13/−0
• cbits/qlaux.h +123/−15
• hasquant.cabal +32/−13
• test/example/QuantLib/Example/Bond.hs +12/−11
• test/example/QuantLib/Example/CDS.hs +1/−1
• test/example/QuantLib/Example/CVAIRS.hs +3/−3
• test/example/QuantLib/Example/CustomSDE.hs +2/−11
• test/example/QuantLib/Example/Fdm.hs +27/−6
• test/example/QuantLib/Example/Gaussian1dModels.hs +3/−5
• test/example/QuantLib/Example/HaskellLSM.hs +3/−9
• test/example/QuantLib/Example/InflationCurve.hs +6/−6
• test/example/QuantLib/Example/InflationInstruments.hs +10/−14
• test/example/QuantLib/Example/IsdaCds.hs +3/−3
• test/example/QuantLib/Example/MulticurveBootstrapping.hs +8/−14
• test/example/QuantLib/Example/OvernightIndexedSwap.hs +2/−2
• test/example/QuantLib/Example/QuickStart.hs +1/−1
• test/example/QuantLib/Example/Repo.hs +1/−1
• test/example/QuantLib/Example/Swap.hs +3/−3
• test/example/QuantLib/Example/TARF.hs +7/−4
• test/hspec/QuantLib/Spec/Calendars.hs +10/−0
• test/hspec/QuantLib/Spec/CashFlow/FxReset.hs +151/−0
• test/hspec/QuantLib/Spec/Context.hs +1/−1
• test/hspec/QuantLib/Spec/Credit.hs +23/−5
• test/hspec/QuantLib/Spec/DatesAndSchedule.hs +16/−0
• test/hspec/QuantLib/Spec/Examples.hs +9/−9
• test/hspec/QuantLib/Spec/Helpers.hs +17/−4
• test/hspec/QuantLib/Spec/Index/Commodity.hs +9/−7
• test/hspec/QuantLib/Spec/Instrument.hs +1/−13
• test/hspec/QuantLib/Spec/Instrument/Credit.hs +38/−2
• test/hspec/QuantLib/Spec/Instrument/InflationCapFloor.hs +9/−18
• test/hspec/QuantLib/Spec/Instrument/MtmCrossCurrency.hs +204/−0
• test/hspec/QuantLib/Spec/Instrument/Option.hs +22/−20
• test/hspec/QuantLib/Spec/Instrument/Swap.hs +79/−7
• test/hspec/QuantLib/Spec/InterestRateAndCashFlow.hs +204/−17
• test/hspec/QuantLib/Spec/Method.hs +45/−0
• test/hspec/QuantLib/Spec/Model.hs +318/−31
• test/hspec/QuantLib/Spec/Model/RoughHeston.hs +135/−0
• test/hspec/QuantLib/Spec/PricingEngine.hs +143/−18
• test/hspec/QuantLib/Spec/Process.hs +263/−23
• test/hspec/QuantLib/Spec/TermStructure.hs +662/−125
• test/hspec/QuantLib/Spec/TermStructure/Inflation.hs +184/−0
• test/hspec/QuantLib/Spec/TermStructure/InflationVolatility.hs +8/−22
• test/main/QuantLib/MainTest.hs +10/−0
• tools/ql-methods-1.43.txt +269/−269
• tools/ql-methods-1.44.txt +10793/−0
• tools/quantlib-1.44-audit.md +106/−0

@@ -1,3 +1,31 @@+## 0.8.0.0 (2026)++- Added value-based Settings snapshots with checked restoration, preserving floating dates+  and observer settings, and native fixing-history name normalization for context owners.++- Added QuantLib 1.44 support, while retaining compatibility with 1.43. New bindings include+  Rough Heston pricing, mark-to-market cross-currency basis swaps, FX reset cash flows, and+  Gaussian1d (GSR) swaptions on overnight-indexed swaps. Calls requiring 1.44, and non-default+  values of arguments added in 1.44, report `UnsupportedQuantLibVersion` on 1.43.+- Deprecated the `ItalyExchange` calendar, following QuantLib 1.44; it will be removed when+  hasquant adopts QuantLib 1.45. Use `TARGET` instead.+- `OvernightIndexedSwap` is now a `FixedVsFloatingSwap`; its fair-rate and fixed-leg inspectors+  come from the generic `FixedVsFloatingSwap` instances.+- Expanded term-structure and bootstrap-helper support, including dated helper constructors and+  implied-quote calculations on caller-supplied curves. Several existing constructor signatures+  changed to expose additional configuration.+- Extended model and engine support, including an exact-mean option for Heston–Hull–White pricing+  that avoids numerical failures in the upstream approximation. `analyticH1HwEngine` now requires+  an `H1HwMean` argument and rejects a negative equity/rate correlation with either integration control.+- Split Longstaff-Schwartz regression into `lsmFit` (basis coefficients) and `lsmEvaluate`, which+  reproduce `lsmRegress`/`lsmRegressMulti` bit for bit within one build; `lsmEvaluatorIdentity`+  names that build so stored coefficients can be refused elsewhere.+- Improved simulation and fixing inspection: `pathGeneratorSequence` exposes the random variates+  actually consumed, and inflation fixing dependencies now follow the dates and interpolation+  rules QuantLib uses.+- Improved callback validation, exception safety, and object ownership across the FFI, including+  a fix for a MultiCurve ownership cycle.+ ## 0.7.0.0 (2026)  The final broad API-coverage batch adds Haskell callbacks for payoffs, optimization, regression and

@@ -1,6 +1,4 @@-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE TemplateHaskell, FlexibleInstances #-} module QuantLib.CashFlow   (     -- * Types@@ -17,6 +15,8 @@   , IndexedCashFlow   , FixedRateCoupon   , IborCoupon+  , FxResetCoupon+  , FxResetNotionalExchange   , AverageBMACoupon   , StrippedCappedFlooredCoupon   , CmsCoupon@@ -44,8 +44,11 @@   , CPICouponPricer   , YoYInflationCouponPricer   , EquityCashFlowPricer+  , FxResetPricer      -- ** Configuration+  , FxReset(..)+  , FxResetConvention(..)   , DurationType(..)   , RateAveragingType(..)   , TimingAdjustment(..)@@ -71,7 +74,13 @@   , MultipleResetsLegOpts(..)   , defaultMultipleResetsLegOpts +  , StubIndexSelection(..)+     -- * Constructors+  , stubIborCoupon+  , fxResetCoupon+  , fxResetNotionalExchange+  , discountingFxResetPricer     -- ** Hierarchy conversion   , asLeg   , asCashFlow@@ -161,6 +170,8 @@   , equityQuantoCashFlowPricer      -- * Mutators+  , HasFxResetPricer(..)+  , setFxResetLegPricer   , setCpiCouponPricer   , setFloatingRateCouponPricer   , setYoyInflationCouponPricer@@ -170,8 +181,12 @@   , setEquityLegPricer      -- * Inspectors+  , fxResetObservation+  , fxResetValueDate+  , fxResetRate     -- ** Coupon fixings   , HasFixingDates(..)+  , fixingDependencies   , HasIndexFixings(..)   , baseFixing   , indexFixing@@ -216,6 +231,7 @@     -- ** Coupon rates and prices   , coupons   , couponAccrualStartDates+  , couponNominal   , couponAccruedAmount   , rate   , price@@ -243,7 +259,12 @@   , putOptionRate   , priceWithoutOptionality   ) where+import Language.Haskell.TH(mkName, varT) import QuantLib.Internal+import Foreign.C.Types(CInt)+import Foreign.Ptr(Ptr)+import Foreign.Marshal.Alloc(alloca)+import Foreign.Storable(peek) {#import QuantLib.InterestRate#}(Compounding, VolatilityType) {#import QuantLib.Time.Schedule#}(Frequency) import QuantLib.Time.Calendar(calendar, CalendarConstructor(..))@@ -258,10 +279,12 @@ #include "qlEnumObjects.h"  #include "ql.h"+{#pointer *QlStubIndexSelection nocode#}  {#pointer *QlDigitalCoupon as DigitalCoupon foreign -> CDigitalCoupon' nocode#} {#pointer *QlRangeAccrualFloatersCoupon as RangeAccrualFloatersCoupon foreign -> CRangeAccrualFloatersCoupon' nocode#} {#pointer *QlYoYInflationCoupon as YoYInflationCoupon foreign -> CYoYInflationCoupon' nocode#}+{#pointer *Currency foreign -> CCurrency nocode#} {#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *CouponLeg foreign -> CCouponLeg' nocode#}@@ -292,6 +315,9 @@ {#pointer *QlFloatingRateCoupon as FloatingRateCoupon foreign -> CFloatingRateCoupon' nocode#} {#pointer *QlStrippedCappedFlooredCoupon as StrippedCappedFlooredCoupon foreign -> CStrippedCappedFlooredCoupon' nocode#} {#pointer *QlDigitalReplication as DigitalReplication foreign -> CDigitalReplication nocode#}+{#pointer *QlFxResetCoupon as FxResetCoupon foreign -> CFxResetCoupon' nocode#}+{#pointer *QlFxResetNotionalExchange as FxResetNotionalExchange foreign -> CFxResetNotionalExchange' nocode#}+{#pointer *QlFxResetPricer as FxResetPricer foreign -> CFxResetPricer nocode#} {#pointer *QlIborCoupon as IborCoupon foreign -> CIborCoupon' nocode#} {#pointer *QlOvernightIndexedCoupon as OvernightIndexedCoupon foreign -> COvernightIndexedCoupon' nocode#} {#pointer *QlAverageBMACoupon as AverageBMACoupon foreign -> CAverageBMACoupon' nocode#}@@ -299,10 +325,20 @@ {#pointer *QlCPICoupon as CPICoupon foreign -> CCPICoupon' nocode#} {#pointer *QlCPICouponPricer as CPICouponPricer foreign -> CCPICouponPricer nocode#} {#pointer *QlCPIVolatilitySurface as CPIVolatilitySurface foreign -> CCPIVolatilitySurface' nocode#}+{#pointer *QlCmsCouponPricer as CmsCouponPricer foreign -> CCmsCouponPricer' nocode#}+{#pointer *QlCmsCoupon as CmsCoupon foreign -> CCmsCoupon' nocode#}+{#pointer *QlSwapSpreadIndex as SwapSpreadIndex foreign -> CSwapSpreadIndex' nocode#}+{#pointer *QlDigitalCmsCoupon as DigitalCmsCoupon foreign -> CDigitalCmsCoupon' nocode#}+{#pointer *QlDigitalCmsSpreadCoupon as DigitalCmsSpreadCoupon foreign -> CDigitalCmsSpreadCoupon' nocode#}+{#pointer *QlSmileSection as SmileSection foreign -> CSmileSection nocode#}+{#pointer *QlYoYOptionletVolatilitySurface as YoYOptionletVolatilitySurface foreign -> CYoYOptionletVolatilitySurface' nocode#}+{#pointer *QlYoYInflationCouponPricer as YoYInflationCouponPricer foreign -> CYoYInflationCouponPricer nocode#}  {#enum DurationType{} deriving(Show, Eq, Read)#} {#enum RateAveragingType{} add prefix="Averaging" deriving(Show, Eq, Read)#} {#enum TimingAdjustment{} deriving(Show, Eq, Read)#}+{#enum YieldCurveModel{} deriving(Show, Eq, Read)#}+{#enum ReplicationType{} deriving(Show, Eq, Read)#}  -- IborLegOpts/CmsLegOpts bundle every IborLeg/CmsLeg builder-method param beyond -- iborLeg/cmsLeg's original 12-arg shape, pre-populated with upstream's own defaults via@@ -317,7 +353,7 @@ -- {#fun#} hook appears, and a top-level TH splice anywhere in between would otherwise -- split the file into declaration groups that can't see each other, breaking every -- earlier {#fun#} wrapper's reference to its own (always-last) foreign-import stub.-$(deriveOptionsRecord "IborLegOpts" []+$(deriveOptionsRecord "IborLegOpts" ["ibor2"]   [ ("ilgPaymentLag", [t|Int|], [|0|])   , ("ilgPaymentCalendar", [t|Maybe Calendar|], [|Nothing|])   , ("ilgExCouponPeriod", [t|(Int, TimeUnit)|], [|(0, Days)|])@@ -326,11 +362,10 @@   , ("ilgExCouponEndOfMonth", [t|Bool|], [|False|])   , ("ilgFixingConvention", [t|BusinessDayConvention|], [|Preceding|])   , ("ilgUseIndexedCoupons", [t|Maybe Bool|], [|Nothing|])+  , ("ilgStubIndexSelection", [t|Maybe (StubIndexSelection $(varT (mkName "ibor2")))|], [|Nothing|])   ]) --- Same shape as IborLegOpts, minus the fields CmsLeg's builder doesn't have--- (withPaymentLag/withPaymentCalendar/withIndexedCoupons -- confirmed absent from--- ql/cashflows/cmscoupon.hpp's CmsLeg). Same splice-placement constraint as above.+-- CmsLegOpts omits the IborLegOpts fields that QuantLib's CmsLeg builder lacks. $(deriveOptionsRecord "CmsLegOpts" []   [ ("cmslExCouponPeriod", [t|(Int, TimeUnit)|], [|(0, Days)|])   , ("cmslExCouponCalendar", [t|Maybe Calendar|], [|Nothing|])@@ -489,10 +524,10 @@   ,preErrorCheck-`String'errorCheck*-}->`AverageBMACoupon'peekAverageBMACoupon*#}  -- |The fixing dates of the individual BMA rates being averaged over this coupon's accrual period.-{#fun qlAverageBMACouponFixingDates as averageBmaCouponFixingDatesRaw{withAverageBMACoupon*`AverageBMACoupon',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlAverageBMACouponFixingDates as averageBmaCouponFixingDatesRaw{withAverageBMACoupon*`AverageBMACoupon',preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The individual BMA fixings being averaged, in the same order as 'fixingDates'.-{#fun qlAverageBMACouponIndexFixings as averageBmaCouponIndexFixingsRaw{withAverageBMACoupon*`AverageBMACoupon',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlAverageBMACouponIndexFixings as averageBmaCouponIndexFixingsRaw{withAverageBMACoupon*`AverageBMACoupon',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Wrap a floating-rate coupon with optional cap and floor rates. {#fun qlCappedFlooredCoupon as cappedFlooredCoupon{withFloatingRateCoupon*`GenFloatingRateCoupon frc' -- ^underlying@@ -599,7 +634,7 @@   ,preErrorCheck-`String'errorCheck*-}->`MultipleResetsCoupon'peekMultipleResetsCoupon*#}  -- |Fixing dates for the rates being compounded over this coupon's reset schedule.-{#fun qlMultipleResetsCouponFixingDates as multipleResetsCouponFixingDatesRaw{withMultipleResetsCoupon*`MultipleResetsCoupon',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlMultipleResetsCouponFixingDates as multipleResetsCouponFixingDatesRaw{withMultipleResetsCoupon*`MultipleResetsCoupon',preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |A range-accrual coupon.  Attach the existing range-accrual pricer before -- asking for its rate; 'priceWithoutOptionality'@@ -609,7 +644,7 @@  -- |A year-on-year inflation coupon.  As for 'yoyInflationLeg', attach a -- YoY inflation coupon pricer before evaluating the coupon rate.-{#fun qlYoYInflationCoupon as yoyInflationCoupon{withDay*`Day',`Double',withDay*`Day',withDay*`Day',fromIntegral`Word',withYoYInflationIndex*`YoYInflationIndex',fromEnumQuantity`(Int,TimeUnit)'&,fromEnumC`CPIInterpolationType',withDayCounter*`DayCounter',`Double',`Double',withMaybeDay*`Maybe Day',withMaybeDay*`Maybe Day',preErrorCheck-`String'errorCheck*-}->`YoYInflationCoupon'peekYoYInflationCoupon*#}+{#fun qlYoYInflationCoupon as yoyInflationCoupon{withDay*`Day',`Double',withDay*`Day',withDay*`Day',fromIntegral`Word',withYoYInflationIndex*`GenYoYInflationIndex yidx',fromEnumQuantity`(Int,TimeUnit)'&,fromEnumC`CPIInterpolationType',withDayCounter*`DayCounter',`Double',`Double',withMaybeDay*`Maybe Day',withMaybeDay*`Maybe Day',preErrorCheck-`String'errorCheck*-}->`YoYInflationCoupon'peekYoYInflationCoupon*#} {#fun qlYoYInflationCouponAdjustedFixing as adjustedFixing{withYoYInflationCoupon*`YoYInflationCoupon',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Pricer that arithmetically averages multiple Ibor resets.@@ -643,13 +678,13 @@  -- |The dates on which the coupon observes the overnight index, one per accrual sub-period. {#fun qlOvernightIndexedCouponFixingDates as overnightIndexedCouponFixingDatesRaw{withOvernightIndexedCoupon*`OvernightIndexedCoupon'-  ,preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The index fixing observed at each of 'fixingDates', in the same order. -- Requires the underlying overnight index to already have those fixings available (historical or -- forecast via a projection curve). {#fun qlOvernightIndexedCouponIndexFixings as overnightIndexedCouponIndexFixingsRaw{withOvernightIndexedCoupon*`OvernightIndexedCoupon'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Capped/floored overnight-index coupon. {#fun qlCappedFlooredOvernightIndexedCoupon as cappedFlooredOvernightIndexedCoupon{withOvernightIndexedCoupon*`OvernightIndexedCoupon' -- ^underlying@@ -660,7 +695,7 @@   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCoupon'peekFloatingRateCoupon*#}  -- |Compounding overnight-index coupon pricer.-{#fun qlCompoundingOvernightIndexedCouponPricer as compoundingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe OptionletVolatilityStructure' -- ^capletVolatility+{#fun qlCompoundingOvernightIndexedCouponPricer as compoundingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe (GenOptionletVolatilityStructure ov)' -- ^capletVolatility   ,`Bool' -- ^byApprox   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#} @@ -668,17 +703,17 @@ {#fun qlArithmeticAveragedOvernightIndexedCouponPricer as arithmeticAveragedOvernightIndexedCouponPricer{`Double' -- ^meanReversion   ,`Double' -- ^volatility   ,`Bool' -- ^byApprox-  ,withMaybeOptionletVolatilityStructure*`Maybe OptionletVolatilityStructure' -- ^capletVolatility+  ,withMaybeOptionletVolatilityStructure*`Maybe (GenOptionletVolatilityStructure ov)' -- ^capletVolatility   ,`Bool' -- ^effective   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#}  -- |Black-formula compounding overnight-index coupon pricer.-{#fun qlBlackCompoundingOvernightIndexedCouponPricer as blackCompoundingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe OptionletVolatilityStructure' -- ^capletVolatility+{#fun qlBlackCompoundingOvernightIndexedCouponPricer as blackCompoundingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe (GenOptionletVolatilityStructure ov)' -- ^capletVolatility   ,`Bool' -- ^effective   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#}  -- |Black-formula arithmetic-average overnight-index coupon pricer.-{#fun qlBlackAveragingOvernightIndexedCouponPricer as blackAveragingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe OptionletVolatilityStructure' -- ^capletVolatility+{#fun qlBlackAveragingOvernightIndexedCouponPricer as blackAveragingOvernightIndexedCouponPricer{withMaybeOptionletVolatilityStructure*`Maybe (GenOptionletVolatilityStructure ov)' -- ^capletVolatility   ,`Bool' -- ^effective   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#} @@ -732,12 +767,12 @@   ,preErrorCheck-`String'errorCheck*-}->`CPICoupon'peekCPICoupon*#}  -- |CPI coupon pricer using an optional nominal yield curve.-{#fun qlCPICouponPricer as cpiCouponPricer{withMaybeYieldTermStructure*`Maybe YieldTermStructure' -- ^nominalTermStructure+{#fun qlCPICouponPricer as cpiCouponPricer{withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^nominalTermStructure   ,preErrorCheck-`String'errorCheck*-}->`CPICouponPricer'peekCPICouponPricer*#}  -- |CPI coupon pricer using a CPI volatility surface and optional nominal yield curve. {#fun qlCPICouponPricerWithVol as cpiCouponPricerWithVol{withGenVolatilityTermStructure*`CPIVolatilitySurface' -- ^volatilitySurface-  ,withMaybeYieldTermStructure*`Maybe YieldTermStructure' -- ^nominalTermStructure+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^nominalTermStructure   ,preErrorCheck-`String'errorCheck*-}->`CPICouponPricer'peekCPICouponPricer*#}  -- |Attach a CPI coupon pricer to a CPI coupon.@@ -783,7 +818,7 @@ -- |Raw binding for 'cashFlows': dates, amounts, and whether each has occurred as of /settlementDate/. {#fun qlLegCashFlows{withLeg*`GenLeg l',fromMaybeBool`Maybe Bool' -- ^includeSettlementDateFlows   ,withMaybeDay*`Maybe Day' -- ^settlementDate-  ,preArray-`[Double]'&peekDoubleArray*,preArray-`[Day]'&peekDayArray*,preArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preIntArray-`[Day]'&peekDayArray*,preIntArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |return cash flows together with an indicator whether they occurred as of /settlementDate/ cashFlows :: GenLeg l@@ -1010,7 +1045,7 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |start of the accrual periods for a coupon leg-{#fun qlCouponAccrualStartDates as couponAccrualStartDates{withGenLeg*`CouponLeg',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlCouponAccrualStartDates as couponAccrualStartDates{withGenLeg*`CouponLeg',preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Predetermined cash flow paying a fixed /amount/ at /date/. {#fun qlFixedDividend as fixedDividend{`Double' -- ^amount@@ -1057,18 +1092,18 @@   iborLeg_ schedule idx notionals dc adj fixingDays gearings spreads caps floors inArrears zp     (ilgPaymentLag defaultIborLegOpts) cal (ilgExCouponPeriod defaultIborLegOpts) cal     (ilgExCouponConvention defaultIborLegOpts) (ilgExCouponEndOfMonth defaultIborLegOpts)-    (ilgFixingConvention defaultIborLegOpts) (ilgUseIndexedCoupons defaultIborLegOpts)+    (ilgFixingConvention defaultIborLegOpts) (ilgUseIndexedCoupons defaultIborLegOpts) Nothing  -- |'iborLeg' widened to every 'IborLeg' builder-method param via 'IborLegOpts'. iborLegWithOptions :: Schedule -> GenIborIndex ibor -> NonEmpty Double -> DayCounter -> BusinessDayConvention-  -> [Word] -> [Double] -> [Double] -> [Double] -> [Double] -> Bool -> Bool -> IborLegOpts+  -> [Word] -> [Double] -> [Double] -> [Double] -> [Double] -> Bool -> Bool -> IborLegOpts ibor2   -> IO Leg iborLegWithOptions schedule idx notionals dc adj fixingDays gearings spreads caps floors inArrears zp opts = do   cal <- calendar Null   iborLeg_ schedule idx notionals dc adj fixingDays gearings spreads caps floors inArrears zp     (ilgPaymentLag opts) (fromMaybe cal (ilgPaymentCalendar opts)) (ilgExCouponPeriod opts)     (fromMaybe cal (ilgExCouponCalendar opts)) (ilgExCouponConvention opts)-    (ilgExCouponEndOfMonth opts) (ilgFixingConvention opts) (ilgUseIndexedCoupons opts)+    (ilgExCouponEndOfMonth opts) (ilgFixingConvention opts) (ilgUseIndexedCoupons opts) (ilgStubIndexSelection opts)  -- |Raw binding for 'iborLeg'\/'iborLegWithOptions': builds a leg of capped\/floored Ibor-rate coupons. {#fun qlIborLeg as iborLeg_{withSchedule*`Schedule',withIborIndex*`GenIborIndex ibor',withNonEmptyDoubleArray*`NonEmpty Double'& -- ^notionals@@ -1088,6 +1123,7 @@   ,`Bool' -- ^exCouponEndOfMonth   ,fromEnumC`BusinessDayConvention' -- ^fixingConvention   ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor2)' -- ^stubIndexSelection (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |CMS leg builder (analog of 'iborLeg'), 12-arg core shape -- same defaults-hardcoding@@ -1144,10 +1180,9 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^observationTenor   ,fromEnumC`BusinessDayConvention',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#} --- |Fixed-rate coupons scaled by the ratio of a 'ZeroInflationIndex' fixing to /baseCPI/--- (a 'CPICoupon' leg -- no capped\/floored variant, unlike 'yoyInflationLeg': QL 1.43 has no--- @CappedFlooredCPICoupon@ class to build one from, see README.md's TODO).-{#fun qlCPILeg as cpiLeg{withSchedule*`Schedule',withZeroInflationIndex*`ZeroInflationIndex'+-- |Fixed-rate coupons scaled by the ratio of a 'ZeroInflationIndex' fixing to /baseCPI/.+-- QuantLib 1.43 has no capped or floored CPI coupon variant.+{#fun qlCPILeg as cpiLeg{withSchedule*`Schedule',withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,`Double' -- ^baseCPI   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,withNonEmptyDoubleArray*`NonEmpty Double'& -- ^notionals@@ -1159,16 +1194,11 @@   ,`Bool' -- ^subtractInflationNominal   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#} --- |Year-on-year inflation-linked coupons (a 'YoYInflationCoupon' leg). Non-empty /caps/\//floors/--- build 'CappedFlooredYoYInflationCoupon's instead of plain ones -- but /any/ resulting coupon--- (capped or not) still needs a pricer set via 'setYoyInflationCouponPricer' before its--- 'QuantLib.CashFlow.npvWithZSpread\/'amount' can be computed: upstream's @InflationCoupon::rate()@--- requires @pricer_@ unconditionally, not just for the capped\/floored case (confirmed by reading--- @inflationcoupon.cpp@). CPI-leg ('cpiLeg') caps\/floors have no equivalent in QL 1.43 (no--- @CappedFlooredCPICoupon@ class exists upstream, see README.md's TODO) -- this is a--- QuantLib-version limitation, not an unbound feature.+-- |Year-on-year inflation-linked coupons. Non-empty /caps/\//floors/ build+-- 'CappedFlooredYoYInflationCoupon's. All coupons need 'setYoyInflationCouponPricer' before+-- calculating amounts. QuantLib 1.43 has no capped or floored CPI coupon counterpart. {#fun qlYoYInflationLeg as yoyInflationLeg{withSchedule*`Schedule',withCalendar*`Calendar'-  ,withYoYInflationIndex*`YoYInflationIndex'+  ,withYoYInflationIndex*`GenYoYInflationIndex yidx'   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,fromEnumC`CPIInterpolationType' -- ^interpolation   ,withNonEmptyDoubleArray*`NonEmpty Double'& -- ^notionals@@ -1180,15 +1210,12 @@   ,withDoubleArray*`[Double]'& -- ^caps   ,withDoubleArray*`[Double]'& -- ^floors   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}-{#pointer *QlZeroInflationCashFlow as ZeroInflationCashFlow foreign -> CZeroInflationCashFlow' nocode#}-{#pointer *QlCPICashFlow as CPICashFlow foreign -> CCPICashFlow' nocode#}-{#pointer *QlEquityCashFlow as EquityCashFlow foreign -> CEquityCashFlow' nocode#} {#pointer *QlEquityCashFlowPricer as EquityCashFlowPricer foreign -> CEquityCashFlowPricer nocode#}  -- |Cash flow dependent on a 'ZeroInflationIndex' ratio (not a coupon -- no accruals). -- The ratio is taken between fixings observed at /startDate/ and /endDate/ minus /observationLag/. {#fun qlZeroInflationCashFlow as zeroInflationCashFlow{`Double' -- ^notional-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,withDay*`Day' -- ^startDate   ,withDay*`Day' -- ^endDate@@ -1200,7 +1227,7 @@ -- |CPI-linked cash flow (not a coupon -- no accruals), with an optional explicit /baseFixing/ -- (pass 'Nothing' to derive it from /baseDate/ instead). {#fun qlCPICashFlow as cpiCashFlow{`Double' -- ^notional-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,withMaybeDay*`Maybe Day' -- ^baseDate   ,fromMaybeDouble`Maybe Double' -- ^baseFixing   ,withDay*`Day' -- ^observationDate@@ -1245,19 +1272,7 @@ -- |The individual coupons of a coupon leg, e.g. to ask each one its own 'rate' or -- 'couponAccruedAmount'.  Pair with 'toCouponLeg' to get here from a 'Leg'. {#fun qlCouponLegCoupons as coupons{withGenLeg*`CouponLeg' -- ^leg-  ,preArray-`[Coupon]'&peekCouponArray*,preErrorCheck-`String'errorCheck*-}->`()'#}--{#enum YieldCurveModel{} deriving(Show, Eq, Read)#}--{#pointer *QlCmsCouponPricer as CmsCouponPricer foreign -> CCmsCouponPricer' nocode#}-{#pointer *QlCmsCoupon as CmsCoupon foreign -> CCmsCoupon' nocode#}-{#pointer *QlSwapSpreadIndex as SwapSpreadIndex foreign -> CSwapSpreadIndex' nocode#}-{#pointer *QlDigitalCmsCoupon as DigitalCmsCoupon foreign -> CDigitalCmsCoupon' nocode#}-{#pointer *QlDigitalCmsSpreadCoupon as DigitalCmsSpreadCoupon foreign -> CDigitalCmsSpreadCoupon' nocode#}-{#pointer *QlSmileSection as SmileSection foreign -> CSmileSection nocode#}-{#pointer *QlYoYOptionletVolatilitySurface as YoYOptionletVolatilitySurface foreign -> CYoYOptionletVolatilitySurface' nocode#}-{#pointer *QlYoYInflationCouponPricer as YoYInflationCouponPricer foreign -> CYoYInflationCouponPricer nocode#}-{#enum ReplicationType{} deriving(Show, Eq, Read)#}+  ,preCouponArray-`[Coupon]'&peekCouponArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Black-formula pricer for capped/floored Ibor coupons {#fun qlBlackIborCouponPricer as blackIborCouponPricer{withOptionletVolatilityStructure*`GenOptionletVolatilityStructure ov'@@ -1648,6 +1663,28 @@   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#}  -- |Coupon types that expose the dates of their component index fixings.+-- |Every fixing the cash flows of this leg need, as @(index name, fixing date)@ pairs in leg+-- order.  QuantLib has no @requiredFixings@ query, so this walks the leg itself, unwrapping+-- decorating coupons (capped\/floored, stripped, digital) and asking each coupon for its own+-- fixing dates: one for an Ibor, CMS or CMS-spread coupon, one per averaged date for an+-- overnight, BMA or multiple-resets coupon, and the fixing and base dates for an index-linked+-- payment.  An inflation flow reports the dates QuantLib\'s CPI store is read at, which are+-- period starts (@ZeroInflationIndex::pastFixing@): for a CPI coupon, CPI cash flow or+-- zero-inflation cash flow, the start of the index period holding each observed date less the+-- observation lag, and under linear interpolation the next period\'s start too, unless the+-- observed date is itself a period start (@CPI::laggedFixing@); a base only when no base CPI is+-- given.  A year-on-year coupon reports its own index\'s period starts, or, for a ratio index, its+-- underlying zero index a year apart.  A CMS-spread coupon reports its two underlying swap+-- indexes rather than the spread index, because that is where the fixings are stored.  Names+-- are 'QuantLib.Index.name', the key QuantLib\'s process-global fixing store uses.  A cash flow+-- that needs no fixing -- a redemption, a fixed-rate coupon -- contributes nothing.  Duplicates+-- are not removed: two coupons may fix the same index on the same date.+fixingDependencies :: GenLeg l -> IO [(String, Day)]+fixingDependencies l = uncurry zip <$> qlLegFixingDependencies l+{#fun qlLegFixingDependencies{withLeg*`GenLeg l'+  ,preCStringArray-`[String]'&peekCStringArray*,preIntArray-`[Day]'&peekDayArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}+ class HasFixingDates coupon where   fixingDates :: coupon -> IO [Day] @@ -1666,5 +1703,126 @@   indexFixings = averageBmaCouponIndexFixingsRaw instance HasIndexFixings OvernightIndexedCoupon where   indexFixings = overnightIndexedCouponIndexFixingsRaw++-- |FX observation as fixing date and associated settlement/value date.+data FxReset = FxReset { fxResetFixingDate :: Day, fxResetSettlementDate :: Day } deriving (Eq, Show, Read)+-- |FX observation convention: business-day fixing lag and optional calendar.+-- Nothing uses an empty calendar; it is valid only with zero fixing days.+data FxResetConvention = FxResetConvention Word (Maybe Calendar)+withFxReset :: FxReset -> ((CInt, CInt) -> IO r) -> IO r+withFxReset (FxReset fixing value) f = do+  fixingSerial <- toSerial fixing+  valueSerial <- toSerial value+  f (fixingSerial, valueSerial)+withMaybeFxReset :: Maybe FxReset -> ((CInt, CInt) -> IO r) -> IO r+withMaybeFxReset reset f = maybe (f (0, 0)) (`withFxReset` f) reset++-- |Native FX observation calculation.+{#fun qlFxResetConventionReset as fxResetObservationRaw{fromIntegral`Word' -- ^fixingDays+  ,withMaybeCalendar*`Maybe Calendar' -- ^fixingCalendar+  ,withDay*`Day' -- ^valueDate+  ,alloca-`Day'peekResetDay* -- ^fixing+  ,alloca-`Day'peekResetDay* -- ^value+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Native FX value-date calculation.+{#fun qlFxResetConventionValueDate as fxResetValueDateRaw{fromIntegral`Word' -- ^fixingDays+  ,withMaybeCalendar*`Maybe Calendar' -- ^fixingCalendar+  ,withDay*`Day' -- ^fixingDate+  ,preErrorCheck-`String'errorCheck*-}->`Day'toDay#}++-- |Derive an FX observation from its value date (1.44). Nonzero lag needs a nonempty calendar.+fxResetObservation :: FxResetConvention -- ^Business-day fixing lag and optional calendar+  -> Day -- ^FX value date+  -> IO FxReset+fxResetObservation (FxResetConvention days cal) observationDate = do+  (fixing, valueDate) <- fxResetObservationRaw days cal observationDate+  pure (FxReset fixing valueDate)+-- |Derive the spot value date of a fixing date using business days (1.44).+fxResetValueDate :: FxResetConvention -- ^Business-day fixing lag and optional calendar+  -> Day -- ^FX fixing date+  -> IO Day+fxResetValueDate (FxResetConvention days cal) = fxResetValueDateRaw days cal++-- |FX reset projection from spot and two discount curves (1.44).+-- Returns resettable currency per constant currency; past observations use ExchangeRateManager.+{#fun qlDiscountingFxResetPricer as discountingFxResetPricer{withCurrency*`Currency' -- ^constantLegCurrency+  ,withCurrency*`Currency' -- ^resettableLegCurrency+  ,withYieldTermStructure*`GenYieldTermStructure y1' -- ^constantLegCurve+  ,withYieldTermStructure*`GenYieldTermStructure y2' -- ^resettableLegCurve+  ,withQuote*`GenQuote q' -- ^spotFx+  ,`Bool' -- ^spotIsResettablePerConstant+  ,withMaybeDay*`Maybe Day' -- ^spotFxSettleDate+  ,preErrorCheck-`String'errorCheck*-}->`FxResetPricer'peekStandalone*#}++-- |Observed or projected resettable-currency units per constant-currency unit (1.44).+{#fun qlFxResetRate as fxResetRate{withStandalone*`FxResetPricer' -- ^pricer+  ,withFxReset*`FxReset'& -- ^reset+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Coupon with FX-reset notional (1.44). Attach an FX reset pricer before querying amount or nominal.+-- Rate and accrued amount preserve the underlying coupon calculation, including overnight compounding.+{#fun qlFxResetCoupon as fxResetCoupon{withFloatingRateCoupon*`GenFloatingRateCoupon frc' -- ^underlying+  ,`Double' -- ^constantLegNotional+  ,withFxReset*`FxReset'& -- ^reset+  ,preErrorCheck-`String'errorCheck*-}->`FxResetCoupon'peekFxResetCoupon*#}++-- |Netted FX-reset principal exchange (1.44). Missing previous/current resets select inception/final exchanges.+-- Attach an FX reset pricer before querying amount; native validation rejects two absent resets.+{#fun qlFxResetNotionalExchange as fxResetNotionalExchange{withDay*`Day' -- ^paymentDate+  ,`Double' -- ^constantLegNotional+  ,withMaybeFxReset*`Maybe FxReset'& -- ^previousReset+  ,withMaybeFxReset*`Maybe FxReset'& -- ^currentReset+  ,preErrorCheck-`String'errorCheck*-}->`FxResetNotionalExchange'peekFxResetNotionalExchange*#}++-- |Attach retained FX reset pricing.+{#fun qlFxResetCouponSetFxResetPricer as setFxResetCouponPricerRaw{withFxResetCoupon*`FxResetCoupon' -- ^cashFlow+  ,withStandalone*`FxResetPricer' -- ^pricer+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Attach retained FX reset pricing.+{#fun qlFxResetNotionalExchangeSetFxResetPricer as setFxResetNotionalExchangePricerRaw{withFxResetNotionalExchange*`FxResetNotionalExchange' -- ^cashFlow+  ,withStandalone*`FxResetPricer' -- ^pricer+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Cash flows supporting FX reset pricer wiring.+class HasFxResetPricer cf where+  -- |Assign a retained FX reset pricer (1.44).+  setFxResetPricer :: cf -> FxResetPricer -> IO ()+instance HasFxResetPricer FxResetCoupon where+  setFxResetPricer = setFxResetCouponPricerRaw+instance HasFxResetPricer FxResetNotionalExchange where+  setFxResetPricer = setFxResetNotionalExchangePricerRaw++-- |Assign an FX reset pricer to every reset cash flow in a leg (1.44). Other cash flows are unchanged.+{#fun qlSetFxResetLegPricer as setFxResetLegPricer{withLeg*`GenLeg l' -- ^leg+  ,withStandalone*`FxResetPricer' -- ^pricer+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Broken-period IBOR coupon selecting or interpolating component indexes (1.44).+-- A nonempty stub selection is required; Nothing passes the native empty selection and fails validation.+{#fun qlStubIborCoupon as stubIborCoupon{withDay*`Day' -- ^paymentDate+  ,`Double' -- ^nominal+  ,withDay*`Day' -- ^startDate+  ,withDay*`Day' -- ^endDate+  ,fromIntegral`Word' -- ^fixingDays+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor)' -- ^stubIndexSelection+  ,`Double' -- ^gearing+  ,`Double' -- ^spread+  ,withMaybeDay*`Maybe Day' -- ^refPeriodStart+  ,withMaybeDay*`Maybe Day' -- ^refPeriodEnd+  ,withMaybeDayCounter*`Maybe DayCounter' -- ^dayCounter+  ,`Bool' -- ^isInArrears+  ,withMaybeDay*`Maybe Day' -- ^exCouponDate+  ,fromEnumC`BusinessDayConvention' -- ^fixingConvention+  ,preErrorCheck-`String'errorCheck*-}->`IborCoupon'peekIborCoupon*#}+++peekResetDay :: Ptr CInt -> IO Day+peekResetDay p = toDay <$> peek p++-- |Current coupon notional. FX reset coupons compute it from the assigned FX reset pricer.+{#fun qlCouponNominal as couponNominal{withCoupon*`GenCoupon c' -- ^coupon+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -84,6 +84,8 @@   , commoditySettingsCurrency   , commoditySettingsUnitOfMeasure   ) where+import Control.Exception (mask_)+import System.IO.Unsafe (unsafePerformIO) import QuantLib.Internal import QuantLib.Internal.Type import QuantLib.Internal.Common@@ -116,10 +118,14 @@ {#fun qlNullCommodityType as nullCommodityType{preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}  -- |The commodity code, e.g. \"HO\".-{#fun pure qlCommodityTypeCode as commodityTypeCode{withCommodityType*`CommodityType'}->`String'peekDynString*#}+commodityTypeCode :: CommodityType -> String+commodityTypeCode x = unsafePerformIO $ mask_ (commodityTypeCodeRaw x)+{#fun qlCommodityTypeCode as commodityTypeCodeRaw{withCommodityType*`CommodityType'}->`String'peekDynString*#}  -- |The descriptive name, e.g. \"Heating Oil\".-{#fun pure qlCommodityTypeName as commodityTypeName{withCommodityType*`CommodityType'}->`String'peekDynString*#}+commodityTypeName :: CommodityType -> String+commodityTypeName x = unsafePerformIO $ mask_ (commodityTypeNameRaw x)+{#fun qlCommodityTypeName as commodityTypeNameRaw{withCommodityType*`CommodityType'}->`String'peekDynString*#}  -- |Whether this is a usable instance (as opposed to one built via a default constructor). {#fun pure qlCommodityTypeEmpty as commodityTypeEmpty{withCommodityType*`CommodityType'}->`Bool'#}@@ -132,10 +138,14 @@   ,preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}  -- |The descriptive name, e.g. \"Barrels\".-{#fun pure qlUnitOfMeasureName as unitOfMeasureName{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}+unitOfMeasureName :: UnitOfMeasure -> String+unitOfMeasureName x = unsafePerformIO $ mask_ (unitOfMeasureNameRaw x)+{#fun qlUnitOfMeasureName as unitOfMeasureNameRaw{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}  -- |The code, e.g. \"BBL\", \"MT\".-{#fun pure qlUnitOfMeasureCode as unitOfMeasureCode{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}+unitOfMeasureCode :: UnitOfMeasure -> String+unitOfMeasureCode x = unsafePerformIO $ mask_ (unitOfMeasureCodeRaw x)+{#fun qlUnitOfMeasureCode as unitOfMeasureCodeRaw{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}  -- |The unit's type (mass/volume/energy/quantity). {#fun pure qlUnitOfMeasureUnitType as unitOfMeasureType{withUnitOfMeasure*`UnitOfMeasure'}->`UnitOfMeasureType'toEnumC#}@@ -176,7 +186,9 @@   ,preErrorCheck-`String'errorCheck*-}->`PaymentTerm'peekPaymentTerm*#}  -- |The payment term's name, e.g. \"Pricing end + 5 days\".-{#fun pure qlPaymentTermName as paymentTermName{withPaymentTerm*`PaymentTerm'}->`String'peekDynString*#}+paymentTermName :: PaymentTerm -> String+paymentTermName x = unsafePerformIO $ mask_ (paymentTermNameRaw x)+{#fun qlPaymentTermName as paymentTermNameRaw{withPaymentTerm*`PaymentTerm'}->`String'peekDynString*#}  -- |Whether the offset is measured from the trade date or the pricing date. {#fun pure qlPaymentTermEventType_ as paymentTermEventType{withPaymentTerm*`PaymentTerm'}->`PaymentTermEventType'toEnumC#}@@ -195,13 +207,8 @@ {#fun qlPaymentTermGetPaymentDate as paymentTermGetPaymentDate   {withPaymentTerm*`PaymentTerm',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Day'toDay#} --- |An amount of a commodity: a 'CommodityType', a 'UnitOfMeasure', and a plain amount. Marshalled--- as a flat triple rather than a wrapper type (per the @Money@-as-tuple convention) -- and, unlike--- 'CommodityUnitCost' below, its three inspectors are just tuple projections, so they need no--- binding at all. c2hs's @&@ tuple-splitter only ever consumes two C arguments (confirmed against--- its source, not just by trial), so every function below that takes or returns a 'Quantity'--- marshals it as three flat 'CommodityType'\/'UnitOfMeasure'\/'Double' arguments instead of one--- combined tuple.+-- |A commodity type, unit of measure, and amount. Its FFI arguments are flat because c2hs's+-- @&@ tuple-splitter supports only pairs. type Quantity = (CommodityType, UnitOfMeasure, Double)  {#fun pure qlQuantityRoundedAmount as quantityRoundedAmount{withUnitOfMeasure*`UnitOfMeasure',`Double'}->`Double'#}@@ -303,7 +310,9 @@ {#fun pure qlUnitOfMeasureConversionFactor as unitOfMeasureConversionFactor{withUnitOfMeasureConversion*`UnitOfMeasureConversion'}->`Double'#}  -- |A code identifying the conversion, e.g. \"Heating OilMTBBL\".-{#fun pure qlUnitOfMeasureConversionCode as unitOfMeasureConversionCode{withUnitOfMeasureConversion*`UnitOfMeasureConversion'}->`String'peekDynString*#}+unitOfMeasureConversionCode :: UnitOfMeasureConversion -> String+unitOfMeasureConversionCode x = unsafePerformIO $ mask_ (unitOfMeasureConversionCodeRaw x)+{#fun qlUnitOfMeasureConversionCode as unitOfMeasureConversionCodeRaw{withUnitOfMeasureConversion*`UnitOfMeasureConversion'}->`String'peekDynString*#}  {#fun qlUnitOfMeasureConversionConvert as qlUnitOfMeasureConversionConvert_   {withUnitOfMeasureConversion*`UnitOfMeasureConversion'

@@ -4,8 +4,10 @@   (     -- * Types     Error(..)+  , SettingsSnapshot(..)      -- * Mutators+  , restoreSettings   , setEvaluationDate   , setEnforceTodaysHistoricFixings   , setIncludeTodaysCashFlows@@ -18,6 +20,7 @@   , setExtendedPrecision      -- * Inspectors+  , captureSettings   , evaluationDate   , enforceTodaysHistoricFixings   , includeTodaysCashFlows@@ -32,7 +35,8 @@ import Foreign.C.String(CString, peekCString) import System.IO.Unsafe(unsafePerformIO) import System.Mem(performGC)-import Control.Exception(bracket)+import Control.Exception(bracket, SomeException, try, throwIO)+import Control.Monad (forM)  import QuantLib.Time.Date import QuantLib.Internal@@ -92,6 +96,39 @@  -- |Whether observer notifications are currently disabled with deferred delivery enabled. {#fun qlObservableSettingsUpdatesDeferred as updatesDeferred{}->`Bool'#}++-- |A value snapshot of pricing and observer settings. A 'Nothing' date retains the+-- floating evaluation-date mode; it is not replaced with today's date.+data SettingsSnapshot = SettingsSnapshot+  { snapshotEvaluationDate :: Maybe Day+  , snapshotEnforceTodaysHistoricFixings :: Bool+  , snapshotIncludeTodaysCashFlows :: Maybe Bool+  , snapshotIncludeReferenceDateEvents :: Bool+  , snapshotUpdatesEnabled :: Bool+  , snapshotUpdatesDeferred :: Bool+  } deriving (Eq, Show)++-- |Copies all settings preserved by 'keepingSettings', including the raw date mode.+captureSettings :: IO SettingsSnapshot+captureSettings = SettingsSnapshot <$> rawEvaluationDate <*> enforceTodaysHistoricFixings+  <*> includeTodaysCashFlows <*> includeReferenceDateEvents <*> updatesEnabled <*> updatesDeferred++{#fun qlSettingsRawEvaluationDate as rawEvaluationDate{}->`Maybe Day'toMaybeDay#}++-- |Restores a snapshot and reports errors rather than suppressing them as the native+-- SavedSettings destructor does. Every field is attempted even if an observer throws.+restoreSettings :: SettingsSnapshot -> IO ()+restoreSettings s = do+  results <- forM+    [ setEnforceTodaysHistoricFixings (snapshotEnforceTodaysHistoricFixings s)+    , setIncludeTodaysCashFlows (snapshotIncludeTodaysCashFlows s)+    , setIncludeReferenceDateEvents (snapshotIncludeReferenceDateEvents s)+    , setEvaluationDate (snapshotEvaluationDate s)+    , if snapshotUpdatesEnabled s then enableUpdates else disableUpdates (snapshotUpdatesDeferred s)+    ] (try :: IO () -> IO (Either SomeException ()))+  case [e | Left e <- results] of+    e : _ -> throwIO e+    [] -> pure ()  -- |brackets to restore settings once action has completed or raised an exception keepingSettings :: IO b -> IO b

@@ -84,11 +84,11 @@   ,preErrorCheck-`String'errorCheck*-}->`DefaultProbKey'peekDefaultProbKey*#}  -- |An issuer's default-probability term structures, keyed by contract terms.-issuer :: NonEmpty (DefaultProbKey, DefaultProbabilityTermStructure) -> IO Issuer+issuer :: NonEmpty (DefaultProbKey, GenDefaultProbabilityTermStructure d) -> IO Issuer issuer probs = qlIssuer keys curves   where (keys, curves) = unzip (toList probs) {#fun qlIssuer{withDefaultProbKeyArray*`[DefaultProbKey]'&-  ,withDefaultProbabilityTermStructureArrayRaw*`[DefaultProbabilityTermStructure]'+  ,withDefaultProbabilityTermStructureArrayRaw*`[GenDefaultProbabilityTermStructure d]'   ,preErrorCheck-`String'errorCheck*-}->`Issuer'peekIssuer*#}  -- |A named collection of issuers and their default-probability keys.

@@ -40,6 +40,8 @@   , moneyConversionType   , moneyBaseCurrency   ) where+import Control.Exception (mask_)+import System.IO.Unsafe (unsafePerformIO) import QuantLib.Internal import QuantLib.Internal.Type import QuantLib.Internal.Common@@ -63,7 +65,9 @@ {#fun qlCurrency as currency{`Ccy',preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}  -- |The currency's ISO 4217 three-letter code, e.g. \"USD\".-{#fun pure qlCurrencyCode as code{withCurrency*`Currency'}->`String'peekDynString*#}+code :: Currency -> String+code x = unsafePerformIO $ mask_ (codeRaw x)+{#fun qlCurrencyCode as codeRaw{withCurrency*`Currency'}->`String'peekDynString*#}  -- |The number of fractional units (e.g. cents) in one unit of the currency. {#fun pure qlCurrencyFractionsPerUnit as fractionsPerUnit{withCurrency*`Currency'}->`Int'#}

@@ -17,12 +17,14 @@      -- * Inspectors     -- ** Index fixings+  , name   , fixingCalendar   , fixing   , hasHistoricalFixing   , isValidFixingDate   , fixingHistory   , fixingHistoryNames+  , fixingHistoryNameKey     -- ** Historical return analysis   , skipped   , mean@@ -51,6 +53,7 @@   , covariance   , correlation   ) where+import Control.Exception (mask_) import QuantLib.Internal import QuantLib.Internal.Common import QuantLib.Internal.Type@@ -63,12 +66,20 @@  {#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *QlIndex as Index foreign -> CIndex' nocode#}+{#pointer *QlHistoricalIndexAnalysis as HistoricalIndexAnalysis foreign -> CHistoricalIndexAnalysis nocode#}  -- |stores the historical fixing at the given date; the date must be the actual calendar date of the fixing, not a settlement date {#fun qlIndexAddFixing as addFixing{withIndex*`GenIndex idx',withDay*`Day',`Double' -- ^fixing   ,`Bool' -- ^forceOverwrite   ,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |The index's own name, as QuantLib builds it -- for an interest-rate index the family name,+-- tenor and day counter, e.g. @\"Euribor6M Actual\/360\"@.  This is the key QuantLib's+-- process-global fixing store uses, so it is the name a stored fixing is filed under.+name :: GenIndex idx -> IO String+name x = mask_ (nameRaw x)+{#fun qlIndexName as nameRaw{withIndex*`GenIndex idx'}->`String'peekDynString*#}+ -- |returns the calendar defining valid fixing dates {#fun qlIndexFixingCalendar as fixingCalendar{withIndex*`GenIndex idx',preErrorCheck-`String'errorCheck*-}->`Calendar'peekCalendar*#} @@ -99,19 +110,22 @@   (ds, vs) <- qlIndexFixingHistory i   return $ zip ds vs {#fun qlIndexFixingHistory{withIndex*`GenIndex idx'-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Returns the names with an entry in QuantLib's process-global fixing store.  Names are -- case-insensitive in that store and can be shared by separate index instances.-{#fun qlIndexManagerHistories as fixingHistoryNames{preArray-`[String]'&peekCStringArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlIndexManagerHistories as fixingHistoryNames{preCStringArray-`[String]'&peekCStringArray*,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |Normalizes a native history name with IndexManager's bytewise case-insensitive+-- comparison. Use this key for ownership registries; Unicode case folding differs.+{#fun qlIndexHistoryNameKey as fixingHistoryNameKey{`String' -- ^nativeName+  ,preErrorCheck-`String'errorCheck*-}->`String'peekDynString*#}+ -- |Clears every native fixing history in QuantLib's process-global store, for all index names. -- This affects other index instances and is intended for explicit session or test cleanup. {#fun qlIndexManagerClearHistories as clearAllFixingHistories{preErrorCheck-`String'errorCheck*-}->`()'#} -{#pointer *QlHistoricalIndexAnalysis as HistoricalIndexAnalysis foreign -> CHistoricalIndexAnalysis nocode#}- -- |Computes 'SequenceStatistics' (mean\/standard deviation\/skewness\/kurtosis\/min\/max\/semi- -- and downside-variance and -deviation\/percentiles\/value-at-risk\/expected shortfall, -- empirical and gaussian-assumption\/covariance\/correlation) over historical fixings of the@@ -122,7 +136,7 @@ {#fun qlHistoricalIndexAnalysis as historicalIndexAnalysis{withDay*`Day' -- ^startDate   ,withDay*`Day' -- ^endDate   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^step-  ,withIndexArray*`[Index]'&+  ,withIndexArray*`[GenIndex idx]'&   ,preErrorCheck-`String'errorCheck*-}->`HistoricalIndexAnalysis'peekHistoricalIndexAnalysis*#}  -- |Skipped fixing dates paired with the reason no complete fixing vector was available.@@ -131,108 +145,108 @@   dates <- qlHistoricalIndexAnalysisSkippedDates analysis   messages <- qlHistoricalIndexAnalysisSkippedMessages analysis   pure (zip dates messages)-{#fun qlHistoricalIndexAnalysisSkippedDates as qlHistoricalIndexAnalysisSkippedDates{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}-{#fun qlHistoricalIndexAnalysisSkippedDatesErrorMessage as qlHistoricalIndexAnalysisSkippedMessages{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[String]'&peekCStringArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisSkippedDates as qlHistoricalIndexAnalysisSkippedDates{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisSkippedDatesErrorMessage as qlHistoricalIndexAnalysisSkippedMessages{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preCStringArray-`[String]'&peekCStringArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index mean of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisMean as mean{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisMean as mean{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index standard deviation of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisStandardDeviation as standardDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisStandardDeviation as standardDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index skewness of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisSkewness as skewness{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisSkewness as skewness{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index (excess) kurtosis of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisKurtosis as kurtosis{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisKurtosis as kurtosis{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index minimum of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisMin as minimumReturn{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisMin as minimumReturn{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index maximum of the historical relative returns actually sampled.-{#fun qlHistoricalIndexAnalysisMax as maximumReturn{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisMax as maximumReturn{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index variance of the historical relative returns falling below the mean.-{#fun qlHistoricalIndexAnalysisSemiVariance as semiVariance{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisSemiVariance as semiVariance{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index square root of 'semiVariance'.-{#fun qlHistoricalIndexAnalysisSemiDeviation as semiDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisSemiDeviation as semiDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index variance of the historical relative returns falling below zero.-{#fun qlHistoricalIndexAnalysisDownsideVariance as downsideVariance{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisDownsideVariance as downsideVariance{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index square root of 'downsideVariance'.-{#fun qlHistoricalIndexAnalysisDownsideDeviation as downsideDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHistoricalIndexAnalysisDownsideDeviation as downsideDeviation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical @y@-th percentile of the historical relative returns actually sampled; -- @y@ must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisPercentile as percentile{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^y-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index @y@-th percentile assuming the historical relative returns are gaussian; @y@ must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisGaussianPercentile as gaussianPercentile{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^y-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical value-at-risk at the given @centile@, which must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisValueAtRisk as valueAtRisk{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index value-at-risk at the given @centile@ assuming the historical relative returns are gaussian; @centile@ must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisGaussianValueAtRisk as gaussianValueAtRisk{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical expected shortfall at the given @centile@, which must lie in @[0.9, 1.0)@. -- Throws if no sampled return falls below the value-at-risk threshold. {#fun qlHistoricalIndexAnalysisExpectedShortfall as expectedShortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index expected shortfall at the given @centile@ assuming the historical relative returns -- are gaussian; @centile@ must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisGaussianExpectedShortfall as gaussianExpectedShortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical potential upside at the given @centile@, which must lie in @[0.9, 1.0)@ -- -- the upside counterpart of 'valueAtRisk'. {#fun qlHistoricalIndexAnalysisPotentialUpside as potentialUpside{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index potential upside at the given @centile@ assuming the historical relative returns -- are gaussian; @centile@ must lie in @[0.9, 1.0)@. {#fun qlHistoricalIndexAnalysisGaussianPotentialUpside as gaussianPotentialUpside{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^centile-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index regret at the given @target@: expected loss below target, conditional on being below it. {#fun qlHistoricalIndexAnalysisRegret as regret{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^target-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical probability of falling below @target@. {#fun qlHistoricalIndexAnalysisShortfall as shortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^target-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index probability of falling below @target@ assuming the historical relative returns are gaussian. {#fun qlHistoricalIndexAnalysisGaussianShortfall as gaussianShortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^target-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index empirical average shortfall (expected loss below @target@, unconditional) at the given @target@. {#fun qlHistoricalIndexAnalysisAverageShortfall as averageShortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^target-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Per-index average shortfall at the given @target@ assuming the historical relative returns are gaussian. {#fun qlHistoricalIndexAnalysisGaussianAverageShortfall as gaussianAverageShortfall{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'   ,`Double' -- ^target-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  toMatrixDouble :: (Word, Word, [Double]) -> Matrix Double toMatrixDouble (r, c, d) = Matrix r c d@@ -241,14 +255,14 @@ covariance :: HistoricalIndexAnalysis -> IO (Matrix Double) covariance hra = toMatrixDouble <$> qlHistoricalIndexAnalysisCovariance hra {#fun qlHistoricalIndexAnalysisCovariance{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Correlation matrix of the historical relative returns across indexes. correlation :: HistoricalIndexAnalysis -> IO (Matrix Double) correlation hra = toMatrixDouble <$> qlHistoricalIndexAnalysisCorrelation hra {#fun qlHistoricalIndexAnalysisCorrelation{withHistoricalIndexAnalysis*`HistoricalIndexAnalysis'-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -17,7 +17,6 @@  {#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *Currency foreign -> CCurrency nocode#}-{#pointer *QlIndex as Index foreign -> CIndex' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlQuote as Quote foreign -> CQuote' nocode#} {#pointer *QlEquityIndex as EquityIndex foreign -> CEquityIndex' nocode#}

@@ -45,7 +45,6 @@  #include "ql.h" -{#pointer *QlInflationIndex as InflationIndex foreign -> CInflationIndex' nocode#} {#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#} {#pointer *QlYoYInflationIndex as YoYInflationIndex foreign -> CYoYInflationIndex' nocode#} {#pointer *Currency foreign -> CCurrency nocode#}@@ -97,27 +96,27 @@  -- |A year-on-year index defined as the ratio of an existing 'ZeroInflationIndex'\'s fixings; -- stores no fixings of its own.-{#fun qlYoYInflationIndexFromZero as yoyInflationIndexFromZero{withZeroInflationIndex*`ZeroInflationIndex'+{#fun qlYoYInflationIndexFromZero as yoyInflationIndexFromZero{withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,withMaybeYoYInflationTermStructure*`Maybe YoYInflationTermStructure'   ,preErrorCheck-`String'errorCheck*-}->`YoYInflationIndex'peekYoYInflationIndex*#}  -- |The (possibly forecast) fixing at the given date; for a date with no linked term -- structure this returns the stored historical fixing added via 'QuantLib.Index.addFixing'.-{#fun qlZeroInflationIndexFixing as fixing{withZeroInflationIndex*`ZeroInflationIndex',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlZeroInflationIndexFixing as fixing{withZeroInflationIndex*`GenZeroInflationIndex zidx',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The (possibly forecast) year-on-year fixing at the given date; for a date with no linked -- term structure this returns the stored historical fixing added via 'QuantLib.Index.addFixing'.-{#fun qlYoYInflationIndexFixing as yoyFixing{withYoYInflationIndex*`YoYInflationIndex',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlYoYInflationIndexFixing as yoyFixing{withYoYInflationIndex*`GenYoYInflationIndex yidx',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Whether 'fixing' at the given date would have to be forecast rather than served from a stored -- historical fixing -- true once the date falls after the latest period a fixing could plausibly -- already be published for, given the index's publication lag. -- /Warning/ It raises an exception if the index was built with a frequency outside -- @Annual@..@Monthly@, which the inflation-period calculation does not handle.-{#fun qlZeroInflationIndexNeedsForecast as needsForecast{withZeroInflationIndex*`ZeroInflationIndex',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Bool'#}+{#fun qlZeroInflationIndexNeedsForecast as needsForecast{withZeroInflationIndex*`GenZeroInflationIndex zidx',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Bool'#}  -- |The year-on-year counterpart of 'needsForecast', for 'yoyFixing'. -- /Warning/ It raises an exception on an unhandled frequency, as 'needsForecast' does.-{#fun qlYoYInflationIndexNeedsForecast as yoyNeedsForecast{withYoYInflationIndex*`YoYInflationIndex',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Bool'#}+{#fun qlYoYInflationIndexNeedsForecast as yoyNeedsForecast{withYoYInflationIndex*`GenYoYInflationIndex yidx',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Bool'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -109,9 +109,7 @@ {#pointer *Schedule foreign -> CSchedule nocode#} {#pointer *QlInterestRateIndex as InterestRateIndex foreign -> CInterestRateIndex' nocode#} {#pointer *QlBMAIndex as BMAIndex foreign -> CBMAIndex' nocode#}-{#pointer *QlOvernightIndex as OvernightIndex foreign -> COvernightIndex' nocode#} {#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}-{#pointer *QlIndex as Index foreign -> CIndex' nocode#} {#pointer *QlSwapIndex as SwapIndex foreign -> CSwapIndex' nocode#} {#pointer *QlSwapSpreadIndex as SwapSpreadIndex foreign -> CSwapSpreadIndex' nocode#} {#pointer *QlOvernightIndex as OvernightIborIndex foreign -> COvernightIndex' nocode#}

@@ -53,10 +53,11 @@  #include "ql.h" -{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine nocode#}+{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine' nocode#} {#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#} {#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *DayCounter foreign -> CDayCounter nocode#}+{#pointer *QlAdditionalResult as RawResultPtr nocode#}  {#enum SettlementType{} deriving(Show, Eq, Read)#} {#enum SettlementMethod{} deriving(Show, Eq, Read)#}@@ -95,18 +96,14 @@ -- |returns the date the net present value refers to. {#fun qlInstrumentValuationDate as valuationDate{withInstrument*`GenInstrument i',preErrorCheck-`String'errorCheck*-}->`Day'toDay#} --- Re-registers QlAdditionalResult with c2hs's (per-file) pointer table as RawResultPtr,--- so the {#fun#} below infers the right out-parameter type instead of an opaque Ptr (Ptr ()).-{#pointer *QlAdditionalResult as RawResultPtr nocode#}- -- |Returns QuantLib's `additionalResults()` map for the given Instrument, as an association list -- keyed by the C++ result name. The map's values are populated by the pricing engine; -- `additionalResults()` calls `calculate()` internally, so this is safe and idempotent after -- pricing.-{#fun qlInstrumentAdditionalResults as additionalResults{withInstrument*`GenInstrument i',preArray-`[(String, AdditionalResultVal)]'&peekAdditionalResults*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlInstrumentAdditionalResults as additionalResults{withInstrument*`GenInstrument i',preAdditionalResults-`[(String, AdditionalResultVal)]'&peekAdditionalResults*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Builds a composite instrument whose NPV is the sum of the given instruments' NPVs, each scaled by its paired multiplier.-composite :: [(Instrument, Double)] -> IO Instrument+composite :: [(GenInstrument i, Double)] -> IO Instrument composite = (uncurry qlCompositeInstrument) . unzip  {#fun qlCompositeInstrument{withInstrumentArray*`[GenInstrument i]'& -- ^instruments@@ -114,6 +111,6 @@   ,preErrorCheck-`String'errorCheck*-}->`Instrument'peekInstrument*#}  -- |Sets the pricing engine used to compute the instrument's results.-{#fun qlInstrumentSetPricingEngine as setPricingEngine{withInstrument*`GenInstrument i',withPricingEngine*`PricingEngine',preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlInstrumentSetPricingEngine as setPricingEngine{withInstrument*`GenInstrument i',withPricingEngine*`GenPricingEngine pe',preErrorCheck-`String'errorCheck*-}->`()'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -138,11 +138,7 @@ {#pointer *QlCallability foreign -> CQlCallability nocode#} {#pointer *InterestRate foreign -> CInterestRate nocode#} {#pointer *QlBond as Bond foreign -> CBond' nocode#}-{#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#} {#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#}-{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}-{#pointer *QlSwapIndex as SwapIndex foreign -> CSwapIndex' nocode#} {#pointer *QlFixedRateBond as FixedRateBond foreign -> CFixedRateBond' nocode#} {#pointer *QlBTP as BTP foreign -> CBTP' nocode#} {#pointer *QlRendistatoBasket as RendistatoBasket foreign -> CRendistatoBasket nocode#}@@ -261,7 +257,7 @@   ,`Frequency'   ,`Double' -- ^couponRate   ,`Double' -- ^initialNotional-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |An inflation-linked bond whose redemption and coupons scale with a 'ZeroInflationIndex'@@ -270,7 +266,7 @@   ,`Double' -- ^faceAmount   ,`Double' -- ^baseCPI   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,withSchedule*`Schedule'   ,withNonEmptyDoubleArray*`NonEmpty Double'& -- ^coupons@@ -438,7 +434,7 @@ {#fun qlBondIsTradable as isTradable{withBond*`GenBond b',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Bool'#}  -- |notionals for each period of the bond's amortization schedule-{#fun qlBondNotionals as notionals{withBond*`GenBond b',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlBondNotionals as notionals{withBond*`GenBond b',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |returns all the cashflows, including the redemptions. {#fun qlBondCashflows as cashFlows{withBond*`GenBond b',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}@@ -648,28 +644,28 @@  -- |per-bond yields, in basket order. {#fun qlRendistatoCalculatorYields as rendistatoYields{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |per-bond (modified) durations, in basket order. {#fun qlRendistatoCalculatorDurations as rendistatoDurations{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the fixed 1..15Y comparison-swap ladder's lengths, in years -- pairs positionally with -- 'rendistatoSwapRates'\/'rendistatoSwapYields'\/'rendistatoSwapDurations'. {#fun qlRendistatoCalculatorSwapLengths as rendistatoSwapLengths{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |each ladder swap's fair (par) rate. {#fun qlRendistatoCalculatorSwapRates as rendistatoSwapRates{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |each ladder swap's fixed leg, repriced as a par bond and re-expressed as a BTP-convention yield. {#fun qlRendistatoCalculatorSwapYields as rendistatoSwapYields{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |each ladder swap's fixed leg (modified) duration, on the same par-bond proxy. {#fun qlRendistatoCalculatorSwapDurations as rendistatoSwapDurations{withRendistatoCalculator*`RendistatoCalculator'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the ladder swap whose duration is closest to (without exceeding) the basket's own duration. {#fun qlRendistatoCalculatorEquivalentSwap as rendistatoEquivalentSwap{withRendistatoCalculator*`RendistatoCalculator',preErrorCheck-`String'errorCheck*-}->`VanillaSwap'peekVanillaSwap*#}

@@ -29,7 +29,6 @@ {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *QlCapFloor as CapFloor foreign -> CCapFloor' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#}  -- |constructs a cap: pays the excess of the floating leg's rate over each exercise rate, if positive {#fun qlCap as cap{withLeg*`GenLeg l' -- ^floatingLeg

@@ -62,8 +62,6 @@ {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlDefaultProbabilityTermStructure as DefaultProbabilityTermStructure foreign -> CDefaultProbabilityTermStructure' nocode#} {#pointer *QlCdsOption as CdsOption foreign -> CCdsOption' nocode#}-{#pointer *QlBond as Bond foreign -> CBond' nocode#}-{#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#} {#pointer *DayCounter foreign -> CDayCounter nocode#} {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *Schedule foreign -> CSchedule nocode#}@@ -113,7 +111,7 @@  -- |Volatility that reproduces a given option price under the pricing engine's volatility model. {#fun qlCdsOptionImpliedVolatility as impliedVolatility{withCdsOption*`CdsOption',`Double' -- ^price-  ,withYieldTermStructure*`GenYieldTermStructure y',withGenTermStructure*`DefaultProbabilityTermStructure'+  ,withYieldTermStructure*`GenYieldTermStructure y',withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d'   ,`Double' -- ^recoveryRate   ,`Double' -- ^accuracy   ,fromIntegral`Word' -- ^maxEvaluations

@@ -151,9 +151,9 @@  {#fun qlCommoditySecondaryCostAmounts as qlCommoditySecondaryCostAmounts_   {withCommodity*`GenCommodity c'-  ,preArray-`[String]'&peekCStringArray*-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Currency]'&peekCurrencyArray*+  ,preCStringArray-`[String]'&peekCStringArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preCurrencyArray-`[Currency]'&peekCurrencyArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The currency-resolved secondary costs computed during the most recent pricing@@ -166,9 +166,9 @@  {#fun qlCommodityPricingErrors as qlCommodityPricingErrors_   {withCommodity*`GenCommodity c'-  ,preArray-`[PricingErrorLevel]'&peekPricingErrorLevelArray*-  ,preArray-`[String]'&peekCStringArray*-  ,preArray-`[String]'&peekCStringArray*+  ,preIntArray-`[PricingErrorLevel]'&peekPricingErrorLevelArray*+  ,preCStringArray-`[String]'&peekCStringArray*+  ,preCStringArray-`[String]'&peekCStringArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Every pricing diagnostic recorded so far (via upstream's own internal calls, or via@@ -224,12 +224,12 @@  {#fun qlEnergySwapDailyPositions as qlEnergySwapDailyPositions_   {withEnergySwap*`GenEnergySwap s'-  ,preArray-`[Day]'&peekDayArray*-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Bool]'&peekBoolArray*+  ,preIntArray-`[Day]'&peekDayArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Bool]'&peekBoolArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The per-day pricing breakdown computed during this 'EnergySwap' leaf's most recent@@ -243,7 +243,7 @@ -- recent @performCalculations()@ -- populated only after pricing. {#fun qlEnergySwapPaymentCashFlows as paymentCashFlows   {withEnergySwap*`GenEnergySwap s'-  ,preArray-`[CommodityCashFlow]'&peekCommodityCashFlowArray*+  ,preCommodityCashFlowArray-`[CommodityCashFlow]'&peekCommodityCashFlowArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Split a 'SecondaryCosts' list into the five parallel arrays every energy-instrument@@ -389,12 +389,12 @@   ,fromEnumC`DeliverySchedule'   ,fromEnumC`QuantityPeriodicity'   ,withPaymentTerm*`PaymentTerm'-  ,preArray-`[Day]'&peekDayArray*-  ,preArray-`[Day]'&peekDayArray*-  ,preArray-`[Day]'&peekDayArray*-  ,preArray-`[CommodityType]'&peekCommodityTypeArray*-  ,preArray-`[UnitOfMeasure]'&peekUnitOfMeasureArray*-  ,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*+  ,preIntArray-`[Day]'&peekDayArray*+  ,preIntArray-`[Day]'&peekDayArray*+  ,preCommodityTypeArray-`[CommodityType]'&peekCommodityTypeArray*+  ,preUnitOfMeasureArray-`[UnitOfMeasure]'&peekUnitOfMeasureArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Split @[startDate, endDate)@ into 'PricingPeriod's of the given quantity, per a

@@ -45,7 +45,6 @@ {#pointer *QlForward as Forward foreign -> CForward' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}-{#pointer *QlFixedRateBond as FixedRateBond foreign -> CFixedRateBond' nocode#} {#pointer *QlForwardRateAgreement as ForwardRateAgreement foreign -> CForwardRateAgreement' nocode#} {#pointer *QlBondForward as BondForward foreign -> CBondForward' nocode#} {#pointer *QlFxForward as FxForward foreign -> CFxForward' nocode#}

@@ -29,7 +29,6 @@ {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *QlYoYInflationCapFloor as YoYInflationCapFloor foreign -> CYoYInflationCapFloor' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#} {#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#} {#pointer *QlCPICapFloor as CPICapFloor foreign -> CCPICapFloor' nocode#} @@ -80,7 +79,7 @@   ,withCalendar*`Calendar' -- ^payCalendar   ,fromEnumC`BusinessDayConvention' -- ^payConvention   ,`Double' -- ^strike-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,preErrorCheck-`String'errorCheck*-}->`CPICapFloor'peekCPICapFloor*#}

@@ -124,8 +124,6 @@ import QuantLib.Internal.Common import Data.List.NonEmpty(NonEmpty, toList) -{#pointer *QlOption as Option foreign -> COption' nocode#}-{#pointer *QlCdsOption as CdsOption foreign -> CCdsOption' nocode#} {#pointer *QlInstrument as Instrument foreign -> CInstrument' nocode#} {#pointer *QlBarrierOption as BarrierOption foreign -> CBarrierOption' nocode#} {#pointer *QlDoubleBarrierOption as DoubleBarrierOption foreign -> CDoubleBarrierOption' nocode#}@@ -457,7 +455,7 @@ -- /Warning/ currently, this method returns the Black-Scholes implied volatility using analytic formulas for European options and a finite-difference method for American and Bermudan options. It will give unconsistent results if the pricing was performed with any other methods (such as jump-diffusion models.)Warningoptions with a gamma that changes sign (e.g., binary options) have values that are not monotonic in the volatility. In these cases, the calculation can fail and the result (if any) is almost meaningless. Another possible source of failure is to have a target value that is not attainable with any volatility, e.g., a target value lower than the intrinsic value in the case of American options.   impliedVolatility :: a     -> Double -- ^price-    -> GeneralizedBlackScholesProcess -- ^process+    -> GenGeneralizedBlackScholesProcess gbs -- ^process     -> [Dividend] -- ^dividends     -> Double -- ^accuracy     -> Word -- ^maxEvaluations

@@ -8,11 +8,11 @@   , GenFixedVsFloatingSwap   , FixedVsFloatingSwap   , VanillaSwap+  , OvernightIndexedSwap   , NonstandardSwap   , IrregularSwap   , FloatFloatSwap   , AssetSwap-  , OvernightIndexedSwap   , BMASwap   , ZeroCouponInflationSwap   , YearOnYearInflationSwap@@ -23,6 +23,7 @@   , GenConstNotionalCrossCurrencySwap   , ConstNotionalCrossCurrencySwap   , ConstNotionalCrossCurrencyBasisSwap+  , MtMCrossCurrencyBasisSwap   , ConstNotionalCrossCurrencyFixedVsFloatingSwap      -- ** Swaptions and variance options@@ -43,10 +44,15 @@   , FloatFloatSwapVaryingOpts(..)   , defaultFloatFloatSwapVaryingOpts   , ConstNotionalCrossCurrencyBasisSwapOpts(..)+  , MtmCrossCurrencySwapType(..)+  , MtMCrossCurrencyBasisSwapOpts(..)+  , defaultMtmCrossCurrencyBasisSwapOpts   , defaultConstNotionalCrossCurrencyBasisSwapOpts   , OvernightObservation(..)   , defaultOvernightObservation +  , StubIndexSelection(..)+     -- * Constructors     -- ** Hierarchy conversion   , asSwap@@ -77,6 +83,8 @@   , constNotionalCrossCurrencySwap   , constNotionalCrossCurrencySwapFromLegs   , constNotionalCrossCurrencyBasisSwap+  , mtmCrossCurrencyBasisSwap+  , mtmCrossCurrencyBasisSwapWithOptions   , constNotionalCrossCurrencyFixedVsFloatingSwap      -- ** Overnight-indexed and asset swaps@@ -93,6 +101,12 @@   , floatFloatSwaption      -- * Inspectors+  , HasCrossCurrencyResults(..)+  , HasFairLegSpreads(..)+  , fairFxBaseSpread+  , fairFxQuoteSpread+  , fxResetRates+  , fxResetNotionals     -- ** Common swap inspectors   , HasFixedLeg(..)   , HasFloatingLeg(..)@@ -102,6 +116,7 @@   , impliedVolatility   , endDiscounts   , leg+  , numberOfLegs   , legBps   , legNpv   , maturityDate@@ -111,12 +126,6 @@   , nonstandardSwapFixedRate      -- ** Cross-currency swaps-  , legCurrency-  , inCcyLegBps-  , inCcyLegNpv-  , npvDateDiscounts-  , fairPaySpread-  , fairRecSpread      -- ** BMA swaps   , bmaLeg@@ -160,6 +169,7 @@   , overnightLegNpv    ) where+import Language.Haskell.TH(mkName, varT) import Data.Maybe(fromMaybe) import QuantLib.Internal.Syntax(deriveOptionsRecord) import QuantLib.Internal@@ -177,33 +187,18 @@ import QuantLib.Index(fixingCalendar) import QuantLib.Index.InterestRate(tenor, dayCounter, businessDayConvention) -{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#} {#pointer *QlBMAIndex as BMAIndex foreign -> CBMAIndex' nocode#} {#pointer *QlOvernightIndex as OvernightIborIndex foreign -> COvernightIndex' nocode#}-{#pointer *QlOption as Option foreign -> COption' nocode#} {#pointer *QlBond as Bond foreign -> CBond' nocode#} {#pointer *QlCreditDefaultSwap as CreditDefaultSwap foreign -> CCreditDefaultSwap' nocode#}--- CdsOption is constructed in QuantLib.Instrument.Credit; aliased here only so its--- HasInstrumentUnderlying instance stays non-orphan, as CreditDefaultSwap's HasFairSpread does. {#pointer *QlCdsOption as CdsOption foreign -> CCdsOption' nocode#} {#pointer *Schedule as Schedule foreign -> CSchedule nocode#} {#pointer *DayCounter foreign -> CDayCounter nocode#} {#pointer *QlExercise nocode#} {#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#} {#pointer *QlYoYInflationIndex as YoYInflationIndex foreign -> CYoYInflationIndex' nocode#}--#include "qlTypesC2HS.h"-#include "qlEnumC2HS.h"-#include "qlEnumObjects.h"--#include "ql.h"--{#enum SwapType{} deriving(Show, Eq, Read)#}-{#enum SwaptionPriceType{} add prefix="Swaption" deriving(Show, Eq, Read)#}-{#enum IrregularSettlementType{} deriving(Show, Eq, Read)#}- {#pointer *Leg foreign -> CLeg' nocode#}+{#pointer *QlMtMCrossCurrencyBasisSwap as MtMCrossCurrencyBasisSwap foreign -> CMtMCrossCurrencyBasisSwap' nocode#} {#pointer *QlSwaption as Swaption foreign -> CSwaption' nocode#} {#pointer *QlIrregularSwaption as IrregularSwaption foreign -> CIrregularSwaption' nocode#} {#pointer *QlSwap as Swap foreign -> CSwap' nocode#}@@ -213,8 +208,6 @@ {#pointer *QlNonstandardSwap as NonstandardSwap foreign -> CNonstandardSwap' nocode#} {#pointer *QlNonstandardSwaption as NonstandardSwaption foreign -> CNonstandardSwaption' nocode#} {#pointer *QlBlackCalibrationHelper as BlackCalibrationHelper foreign -> CBlackCalibrationHelper' nocode#}-{#pointer *QlSwapIndex as SwapIndex foreign -> CSwapIndex' nocode#}-{#pointer *QlSwaptionVolatilityStructure as SwaptionVolatilityStructure foreign -> CSwaptionVolatilityStructure' nocode#} {#pointer *QlAssetSwap as AssetSwap foreign -> CAssetSwap' nocode#} {#pointer *QlBMASwap as BMASwap foreign -> CBMASwap' nocode#} {#pointer *QlOvernightIndexedSwap as OvernightIndexedSwap foreign -> COvernightIndexedSwap' nocode#}@@ -226,12 +219,22 @@ {#pointer *QlEquityIndex as EquityIndex foreign -> CEquityIndex' nocode#} {#pointer *QlFloatFloatSwap as FloatFloatSwap foreign -> CFloatFloatSwap' nocode#} {#pointer *QlFloatFloatSwaption as FloatFloatSwaption foreign -> CFloatFloatSwaption' nocode#}-{#pointer *QlInterestRateIndex as InterestRateIndex foreign -> CInterestRateIndex' nocode#} {#pointer *QlConstNotionalCrossCurrencySwap as ConstNotionalCrossCurrencySwap foreign -> CConstNotionalCrossCurrencySwap' nocode#} {#pointer *QlConstNotionalCrossCurrencyBasisSwap as ConstNotionalCrossCurrencyBasisSwap foreign -> CConstNotionalCrossCurrencyBasisSwap' nocode#} {#pointer *QlConstNotionalCrossCurrencyFixedVsFloatingSwap as ConstNotionalCrossCurrencyFixedVsFloatingSwap foreign -> CConstNotionalCrossCurrencyFixedVsFloatingSwap' nocode#} {#pointer *Currency foreign -> CCurrency nocode#} +#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"+{#pointer *QlStubIndexSelection nocode#}++{#enum SwapType{} deriving(Show, Eq, Read)#}+{#enum SwaptionPriceType{} add prefix="Swaption" deriving(Show, Eq, Read)#}+{#enum IrregularSettlementType{} deriving(Show, Eq, Read)#}+ -- FloatFloatSwapOpts/FloatFloatSwapVaryingOpts bundle every trailing param of FloatFloatSwap's -- two constructors (floatfloatswap.hpp) -- 12 trailing defaulted params each, past the -- options-record threshold (see the add-quantlib-options-record skill). Two separate records@@ -242,6 +245,28 @@ -- the physical end of the generated module regardless of where in the .chs a {#fun#} hook -- appears, so a top-level TH splice in between would split the file into declaration groups -- that can't see each other).+-- |Direction of the FX-base currency leg, independent of the resettable-leg choice.+data MtmCrossCurrencySwapType = PayFxBaseCurrency | ReceiveFxBaseCurrency deriving (Eq, Show, Read)++$(deriveOptionsRecord "MtMCrossCurrencyBasisSwapOpts" ["ibor3", "ibor4"]+  [ ("mtmFxResetFixingDays", [t|Word|], [|0|])+  , ("mtmFxResetFixingCalendar", [t|Maybe Calendar|], [|Nothing|])+  , ("mtmFxBasePaymentLag", [t|Int|], [|0|])+  , ("mtmFxQuotePaymentLag", [t|Int|], [|0|])+  , ("mtmFxBasePaymentConvention", [t|BusinessDayConvention|], [|Following|])+  , ("mtmFxQuotePaymentConvention", [t|BusinessDayConvention|], [|Following|])+  , ("mtmFxBaseCompoundSpread", [t|Bool|], [|False|])+  , ("mtmFxBaseObservation", [t|OvernightObservation|], [|defaultOvernightObservation|])+  , ("mtmFxBaseAveragingMethod", [t|RateAveragingType|], [|AveragingCompound|])+  , ("mtmFxQuoteCompoundSpread", [t|Bool|], [|False|])+  , ("mtmFxQuoteObservation", [t|OvernightObservation|], [|defaultOvernightObservation|])+  , ("mtmFxQuoteAveragingMethod", [t|RateAveragingType|], [|AveragingCompound|])+  , ("mtmTelescopicValueDates", [t|Bool|], [|False|])+  , ("mtmUseIndexedCoupons", [t|Maybe Bool|], [|Nothing|])+  , ("mtmFxBaseStubIndexSelection", [t|Maybe (StubIndexSelection $(varT (mkName "ibor3")))|], [|Nothing|])+  , ("mtmFxQuoteStubIndexSelection", [t|Maybe (StubIndexSelection $(varT (mkName "ibor4")))|], [|Nothing|])+  ])+ $(deriveOptionsRecord "FloatFloatSwapOpts" []   [ ("ffsIntermediateCapitalExchange", [t|Bool|], [|False|])   , ("ffsFinalCapitalExchange", [t|Bool|], [|False|])@@ -278,7 +303,7 @@ -- textually before every {#fun#} in this file. ConstNotionalCrossCurrencyFixedVsFloatingSwap's -- constructor has only 4 trailing defaults (under the threshold), so it's widened in place -- instead -- see 'constNotionalCrossCurrencyFixedVsFloatingSwap' below.-$(deriveOptionsRecord "ConstNotionalCrossCurrencyBasisSwapOpts" []+$(deriveOptionsRecord "ConstNotionalCrossCurrencyBasisSwapOpts" ["ibor3", "ibor4"]   [ ("cccbsPayPaymentLag", [t|Int|], [|0|])   , ("cccbsRecPaymentLag", [t|Int|], [|0|])   , ("cccbsPayCompoundSpread", [t|Bool|], [|False|])@@ -288,6 +313,10 @@   , ("cccbsRecObservation", [t|OvernightObservation|], [|defaultOvernightObservation|])   , ("cccbsRecAveragingMethod", [t|RateAveragingType|], [|AveragingCompound|])   , ("cccbsTelescopicValueDates", [t|Bool|], [|False|])+  , ("cccbsUseIndexedCoupons", [t|Maybe Bool|], [|Nothing|])+  , ("cccbsPaymentLagOnNotionalExchanges", [t|Bool|], [|False|])+  , ("cccbsPayStubIndexSelection", [t|Maybe (StubIndexSelection $(varT (mkName "ibor3")))|], [|Nothing|])+  , ("cccbsRecStubIndexSelection", [t|Maybe (StubIndexSelection $(varT (mkName "ibor4")))|], [|Nothing|])   ])  -- |implied volatility@@ -303,10 +332,10 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Multi leg constructor.-swapFromLegs :: [(Leg, Bool)] -- ^(legs, payer)+swapFromLegs :: [(GenLeg l, Bool)] -- ^(legs, payer)   -> IO Swap swapFromLegs = (uncurry qlSwap1) . unzip-{#fun qlSwap1{withLegArray*`[Leg]'&,withBoolArray*`[Bool]'&,preErrorCheck-`String'errorCheck*-}->`Swap'peekSwap*#}+{#fun qlSwap1{withLegArray*`[GenLeg l]'&,withBoolArray*`[Bool]'&,preErrorCheck-`String'errorCheck*-}->`Swap'peekSwap*#}  -- |Swap paying Libor against BMA coupons {#fun qlBMASwap as bmaSwap{`SwapType',`Double' -- ^nominal@@ -333,12 +362,15 @@  -- |Converts an existing 'FixedVsFloatingSwap' (e.g. a 'VanillaSwap') into a 'NonstandardSwap' -- (upstream's own conversion constructor, @NonstandardSwap(const FixedVsFloatingSwap&)@).+-- An 'OvernightIndexedSwap' keeps its compounded coupons, payment lag and observation+-- conventions; converting one requires QuantLib 1.44. {#fun qlNonstandardSwap1 as nonstandardSwapFromVanilla{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f'   ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwap'peekNonstandardSwap*#}  -- |'VanillaSwap' generalized to per-period fixed/floating nominals and fixed rates, plus -- optional intermediate\/final notional exchange -- a single 'Double' gearing\/spread shared -- across all floating periods. See 'nonstandardSwapFromGearingsAndSpreads' for per-period gearing\/spread.+-- QuantLib 1.44 builds compounded coupons for an overnight index; 1.43 builds Ibor coupons. {#fun qlNonstandardSwap as nonstandardSwap{`SwapType'   ,withDoubleArray*`[Double]'& -- ^fixedNominal   ,withDoubleArray*`[Double]'& -- ^floatingNominal@@ -353,6 +385,8 @@   ,`Bool' -- ^intermediateCapitalExchange   ,`Bool' -- ^finalCapitalExchange   ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention+  ,fromIntegral`Int' -- ^paymentLag (1.44; QuantLib 1.43 requires 0)+  ,withMaybeCalendar*`Maybe Calendar' -- ^paymentCalendar, 'Nothing' for each leg's schedule calendar (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwap'peekNonstandardSwap*#}  -- |As 'nonstandardSwap', but with a per-period gearing and spread instead of one shared value.@@ -370,13 +404,15 @@   ,`Bool' -- ^intermediateCapitalExchange   ,`Bool' -- ^finalCapitalExchange   ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention+  ,fromIntegral`Int' -- ^paymentLag (1.44; QuantLib 1.43 requires 0)+  ,withMaybeCalendar*`Maybe Calendar' -- ^paymentCalendar, 'Nothing' for each leg's schedule calendar (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwap'peekNonstandardSwap*#}  -- |Per-period fixed rate, one entry per fixed-leg accrual period. For a swap built via -- 'nonstandardSwap'\/'nonstandardSwapFromGearingsAndSpreads', this simply echoes the constructor's @fixedRate@; for -- one built via 'nonstandardSwapFromVanilla' it is derived from the underlying vanilla swap's -- fixed leg coupons.-{#fun qlNonstandardSwapFixedRate as nonstandardSwapFixedRate{withNonstandardSwap*`NonstandardSwap',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlNonstandardSwapFixedRate as nonstandardSwapFixedRate{withNonstandardSwap*`NonstandardSwap',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Swap exchanging capped\/floored Libor or CMS coupons with a single flat nominal on each leg. -- 'FloatFloatSwapOpts' bundles every trailing param the C++ constructor defaults (gearing\/@@ -592,6 +628,9 @@ -- |Discount factor at leg j's end date. {#fun qlSwapEndDiscounts as endDiscounts{withSwap*`GenSwap s',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#} +-- |How many legs this swap has; leg indexes run from 0 to one less than this.+{#fun qlSwapNumberOfLegs as numberOfLegs{withSwap*`GenSwap s',preErrorCheck-`String'errorCheck*-}->`Word'fromIntegral#}+ -- |The j-th leg's cash flows. {#fun qlSwapLeg as leg{withSwap*`GenSwap s',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#} @@ -612,34 +651,34 @@   ,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencySwap'peekConstNotionalCrossCurrencySwap*#}  -- |Multi-leg constructor.-constNotionalCrossCurrencySwapFromLegs :: [(Leg, Bool)] -- ^(legs, payer)+constNotionalCrossCurrencySwapFromLegs :: [(GenLeg l, Bool)] -- ^(legs, payer)   -> [Currency] -> IO ConstNotionalCrossCurrencySwap constNotionalCrossCurrencySwapFromLegs legsPayer = qlConstNotionalCrossCurrencySwap1 legs payer   where (legs, payer) = unzip legsPayer-{#fun qlConstNotionalCrossCurrencySwap1{withLegArray*`[Leg]'&,withBoolArray*`[Bool]'&,withCurrencyArray*`[Currency]'&,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencySwap'peekConstNotionalCrossCurrencySwap*#}+{#fun qlConstNotionalCrossCurrencySwap1{withLegArray*`[GenLeg l]'&,withBoolArray*`[Bool]'&,withCurrencyArray*`[Currency]'&,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencySwap'peekConstNotionalCrossCurrencySwap*#}  -- |Leg j's currency.-{#fun qlConstNotionalCrossCurrencySwapLegCurrency as legCurrency{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}+{#fun qlConstNotionalCrossCurrencySwapLegCurrency as constNotionalLegCurrency{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}  -- |Basis-point sensitivity of leg j, expressed in the leg's own currency (contrast 'legBps', in the swap's NPV currency).-{#fun qlConstNotionalCrossCurrencySwapInCcyLegBPS as inCcyLegBps{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlConstNotionalCrossCurrencySwapInCcyLegBPS as constNotionalInCcyLegBPS{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |NPV of leg j, expressed in the leg's own currency (contrast 'legNpv', in the swap's NPV currency).-{#fun qlConstNotionalCrossCurrencySwapInCcyLegNPV as inCcyLegNpv{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlConstNotionalCrossCurrencySwapInCcyLegNPV as constNotionalInCcyLegNPV{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Discount factor at the instrument's NPV date, for leg j.-{#fun qlConstNotionalCrossCurrencySwapNpvDateDiscounts as npvDateDiscounts{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlConstNotionalCrossCurrencySwapNpvDateDiscounts as constNotionalNpvDateDiscounts{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Cross-currency basis swap: pay-currency cashflows on leg 0, receive-currency on leg 1. -- 'ConstNotionalCrossCurrencyBasisSwapOpts' bundles every trailing param the C++ constructor--- defaults (all OIS-only -- payment lag, compound-spread, lookback, observation shift, lockout,+-- defaults (OIS payment lag, compound-spread, lookback, observation shift, lockout, -- averaging method per leg, plus a shared telescopic-value-dates flag; ignored for a plain Ibor--- 'payIndex'\/'recIndex', since upstream itself only consults them when the index is an overnight--- index); override only what's needed via record-update syntax on+-- 'payIndex'\/'recIndex'). Indexed coupons, lagged notional exchanges and stub selections are+-- available on QuantLib 1.44; 1.43 accepts only their defaults. Override only what's needed on -- 'defaultConstNotionalCrossCurrencyBasisSwapOpts'. constNotionalCrossCurrencyBasisSwap :: Double -> Currency -> Schedule -> GenIborIndex ibor1 -> Double -> Double   -> Double -> Currency -> Schedule -> GenIborIndex ibor2 -> Double -> Double-  -> ConstNotionalCrossCurrencyBasisSwapOpts -> IO ConstNotionalCrossCurrencyBasisSwap+  -> ConstNotionalCrossCurrencyBasisSwapOpts ibor3 ibor4 -> IO ConstNotionalCrossCurrencyBasisSwap constNotionalCrossCurrencyBasisSwap payNominal payCurrency paySchedule payIndex paySpread payGearing     recNominal recCurrency recSchedule recIndex recSpread recGearing opts =   constNotionalCrossCurrencyBasisSwap_ payNominal payCurrency paySchedule payIndex paySpread payGearing@@ -650,6 +689,8 @@     (cccbsRecCompoundSpread opts) (lookbackDays recObs) (applyObservationShift recObs)     (lockoutDays recObs) (cccbsRecAveragingMethod opts)     (cccbsTelescopicValueDates opts)+    (cccbsUseIndexedCoupons opts) (cccbsPaymentLagOnNotionalExchanges opts)+    (cccbsPayStubIndexSelection opts) (cccbsRecStubIndexSelection opts)   where payObs = cccbsPayObservation opts         recObs = cccbsRecObservation opts @@ -678,13 +719,17 @@   ,fromIntegral`Word' -- ^recLockoutDays   ,`RateAveragingType' -- ^recAveragingMethod   ,`Bool' -- ^telescopicValueDates+  ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons (1.44; QuantLib 1.43 requires 'Nothing')+  ,`Bool' -- ^paymentLagOnNotionalExchanges (1.44; QuantLib 1.43 requires 'False')+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor3)' -- ^payStub (1.44; QuantLib 1.43 requires 'Nothing')+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor4)' -- ^recStub (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencyBasisSwap'peekConstNotionalCrossCurrencyBasisSwap*#}  -- |The pay-leg spread that would make the swap's NPV zero.-{#fun qlConstNotionalCrossCurrencyBasisSwapFairPaySpread as fairPaySpread{withConstNotionalCrossCurrencyBasisSwap*`ConstNotionalCrossCurrencyBasisSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlConstNotionalCrossCurrencyBasisSwapFairPaySpread as constNotionalFairPaySpread{withConstNotionalCrossCurrencyBasisSwap*`ConstNotionalCrossCurrencyBasisSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The receive-leg spread that would make the swap's NPV zero.-{#fun qlConstNotionalCrossCurrencyBasisSwapFairRecSpread as fairRecSpread{withConstNotionalCrossCurrencyBasisSwap*`ConstNotionalCrossCurrencyBasisSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlConstNotionalCrossCurrencyBasisSwapFairRecSpread as constNotionalFairRecSpread{withConstNotionalCrossCurrencyBasisSwap*`ConstNotionalCrossCurrencyBasisSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Cross-currency fixed-vs-floating swap: 'Payer' pays the fixed leg (leg 0) and receives the -- floating leg (leg 1); 'Receiver' the reverse. Every trailing defaulted param of the upstream@@ -717,12 +762,14 @@   -> Bool -- ^floatCompoundSpread   -> OvernightObservation -- ^floatObservation   -> RateAveragingType -- ^floatAveragingMethod+  -> Maybe Bool -- ^useIndexedCoupons (1.44; QuantLib 1.43 requires 'Nothing')+  -> Maybe (StubIndexSelection ibor2) -- ^floatStubIndexSelection (1.44; QuantLib 1.43 requires 'Nothing')   -> IO ConstNotionalCrossCurrencyFixedVsFloatingSwap constNotionalCrossCurrencyFixedVsFloatingSwap t fxN fxC fxS fxR fxDc fxBdc fxLag fxCal-  flN flC flS flIdx flSprd flBdc flLag flCal telescopic compound obs avg =+  flN flC flS flIdx flSprd flBdc flLag flCal telescopic compound obs avg indexed stub =   constNotionalCrossCurrencyFixedVsFloatingSwapRaw t fxN fxC fxS fxR fxDc fxBdc fxLag fxCal     flN flC flS flIdx flSprd flBdc flLag flCal telescopic compound-    (lookbackDays obs) (applyObservationShift obs) (lockoutDays obs) avg+    (lookbackDays obs) (applyObservationShift obs) (lockoutDays obs) avg indexed stub  {#fun qlConstNotionalCrossCurrencyFixedVsFloatingSwap as constNotionalCrossCurrencyFixedVsFloatingSwapRaw{`SwapType'   ,`Double' -- ^fixedNominal@@ -747,6 +794,8 @@   ,`Bool' -- ^floatObservationShift   ,fromIntegral`Word' -- ^floatLockoutDays   ,`RateAveragingType' -- ^floatAveragingMethod+  ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons (1.44; QuantLib 1.43 requires 'Nothing')+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor2)' -- ^floatStub (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencyFixedVsFloatingSwap'peekConstNotionalCrossCurrencyFixedVsFloatingSwap*#}  -- |The fixed rate that would make the swap's NPV zero.@@ -758,7 +807,9 @@   fairSpread = qlConstNotionalCrossCurrencyFixedVsFloatingSwapFairSpread {#fun qlConstNotionalCrossCurrencyFixedVsFloatingSwapFairSpread{withConstNotionalCrossCurrencyFixedVsFloatingSwap*`ConstNotionalCrossCurrencyFixedVsFloatingSwap',preErrorCheck-`String'errorCheck*-}->`Double'#} --- |An option on a 'VanillaSwap'.+-- |An option on a 'VanillaSwap' or an 'OvernightIndexedSwap'; the latter requires QuantLib 1.44.+-- The Gaussian1d swaption engines then compound overnight coupons exactly, approximate lookback+-- without observation shift and lockout, and do not support arithmetic averaging. {#fun qlSwaption as swaption{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',withExercise*`Exercise',`SettlementType',`SettlementMethod',preErrorCheck-`String'errorCheck*-}->`Swaption'peekSwaption*#}  -- |A priceable option on an 'IrregularSwap'.  Use 'haganIrregularSwaptionEngine'@@ -784,7 +835,7 @@   ,withSwapIndex*`GenSwapIndex sidx' -- ^standardSwapBase   ,withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv' -- ^swaptionVolatility   ,fromEnumC`CalibrationBasketType'-  ,preArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*+  ,preBlackCalibrationHelperArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |An option on a 'FloatFloatSwap'.@@ -795,12 +846,12 @@   ,withSwapIndex*`GenSwapIndex sidx' -- ^standardSwapBase   ,withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv' -- ^swaptionVolatility   ,fromEnumC`CalibrationBasketType'-  ,preArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*+  ,preBlackCalibrationHelperArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Bullet bond vs Libor swap (par or market asset swap, per /parAssetSwap/). {#fun qlAssetSwap as assetSwap{`Bool' -- ^payBondCoupon-  ,withBond*`Bond',`Double' -- ^bondCleanPrice+  ,withBond*`GenBond b',`Double' -- ^bondCleanPrice   ,withIborIndex*`GenIborIndex ibor',`Double' -- spread   ,withSchedule*`Schedule' -- ^floatSchedule   ,withDayCounter*`DayCounter' -- ^floatingDayCount@@ -824,10 +875,11 @@   -> Bool -- ^telescopicValueDates   -> RateAveragingType -- ^averagingMethod   -> OvernightObservation+  -> Maybe Int -- ^roundingPrecision (1.44; QuantLib 1.43 requires 'Nothing')   -> IO OvernightIndexedSwap-overnightIndexedSwap t n sch r dc idx sprd lag adj cal telescopic avg obs =+overnightIndexedSwap t n sch r dc idx sprd lag adj cal telescopic avg obs precision =   overnightIndexedSwapRaw t n sch r dc idx sprd lag adj cal telescopic avg-    (lookbackDays obs) (lockoutDays obs) (applyObservationShift obs)+    (lookbackDays obs) (lockoutDays obs) (applyObservationShift obs) precision  {#fun qlOvernightIndexedSwap as overnightIndexedSwapRaw{`SwapType',`Double' -- ^nominal   ,withSchedule*`Schedule',`Double'  -- ^fixedRate@@ -841,6 +893,7 @@   ,fromMaybeInt`Maybe Word' -- ^lookbackDays   ,fromIntegral`Word' -- ^lockoutDays   ,`Bool' -- ^applyObservationShift+  ,fromMaybeInt`Maybe Int' -- ^roundingPrecision (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`OvernightIndexedSwap'peekOvernightIndexedSwap*#}  -- |As 'overnightIndexedSwap', but with a per-period nominal schedule instead of a single flat nominal.@@ -857,10 +910,11 @@   -> Bool -- ^telescopicValueDates   -> RateAveragingType -- ^averagingMethod   -> OvernightObservation+  -> Maybe Int -- ^roundingPrecision (1.44; QuantLib 1.43 requires 'Nothing')   -> IO OvernightIndexedSwap-overnightIndexedSwapFromNominals t ns sch r dc idx sprd lag adj cal telescopic avg obs =+overnightIndexedSwapFromNominals t ns sch r dc idx sprd lag adj cal telescopic avg obs precision =   overnightIndexedSwapFromNominalsRaw t ns sch r dc idx sprd lag adj cal telescopic avg-    (lookbackDays obs) (lockoutDays obs) (applyObservationShift obs)+    (lookbackDays obs) (lockoutDays obs) (applyObservationShift obs) precision  {#fun qlOvernightIndexedSwap1 as overnightIndexedSwapFromNominalsRaw{`SwapType',withDoubleArray*`[Double]'& -- ^nominals   ,withSchedule*`Schedule' -- ^schedule@@ -875,6 +929,7 @@   ,fromMaybeInt`Maybe Word' -- ^lookbackDays   ,fromIntegral`Word' -- ^lockoutDays   ,`Bool' -- ^applyObservationShift+  ,fromMaybeInt`Maybe Int' -- ^roundingPrecision (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`OvernightIndexedSwap'peekOvernightIndexedSwap*#}  -- |The swap's maturity date, or 'Nothing' if the swap has no legs.@@ -953,7 +1008,7 @@   ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'   ,`Double' -- ^fixedRate-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,`Bool' -- ^adjustInfObsDates@@ -971,7 +1026,7 @@   ,`Double' -- ^fixedRate   ,withDayCounter*`DayCounter' -- ^fixedDayCount   ,withSchedule*`Schedule' -- ^yoySchedule-  ,withYoYInflationIndex*`YoYInflationIndex'+  ,withYoYInflationIndex*`GenYoYInflationIndex yidx'   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,fromEnumC`CPIInterpolationType' -- ^interpolation   ,`Double' -- ^spread@@ -1004,7 +1059,7 @@   ,withSchedule*`Schedule' -- ^fixedSchedule   ,fromEnumC`BusinessDayConvention' -- ^fixedRoll   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag-  ,withZeroInflationIndex*`ZeroInflationIndex' -- ^fixedIndex+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx' -- ^fixedIndex   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,fromMaybeDouble`Maybe Double' -- ^inflationNominal   ,preErrorCheck-`String'errorCheck*-}->`CPISwap'peekCPISwap*#}@@ -1084,10 +1139,6 @@   fixedLeg :: a -> IO Leg   fixedLegBps :: a -> IO Double   fixedLegNpv :: a -> IO Double-instance HasFixedLeg OvernightIndexedSwap where-  fixedLeg = qlOvernightIndexedSwapFixedLeg-  fixedLegBps = qlOvernightIndexedSwapFixedLegBPS-  fixedLegNpv = qlOvernightIndexedSwapFixedLegNPV instance HasFixedLeg (GenFixedVsFloatingSwap f) where   fixedLeg = qlFixedVsFloatingSwapFixedLeg   fixedLegBps = qlFixedVsFloatingSwapFixedLegBPS@@ -1095,8 +1146,6 @@  class HasFairRate a where   fairRate :: a -> IO Double-instance HasFairRate OvernightIndexedSwap where-  fairRate = qlOvernightIndexedSwapFairRate instance HasFairRate (GenFixedVsFloatingSwap f) where   fairRate = qlFixedVsFloatingSwapFairRate instance HasFairRate IrregularSwap where@@ -1112,8 +1161,6 @@   fairSpread :: a -> IO Double instance HasFairSpread (GenFixedVsFloatingSwap f) where   fairSpread = qlFixedVsFloatingSwapFairSpread-instance HasFairSpread OvernightIndexedSwap where-  fairSpread = qlOvernightIndexedSwapFairSpread instance HasFairSpread AssetSwap where   fairSpread = qlAssetSwapFairSpread instance HasFairSpread CreditDefaultSwap where@@ -1183,21 +1230,6 @@ -- |NPV of the fixed leg. {#fun qlFixedVsFloatingSwapFixedLegNPV{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#} --- |The fixed rate that would make the swap's NPV zero.-{#fun qlOvernightIndexedSwapFairRate{withOvernightIndexedSwap*`OvernightIndexedSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}---- |The fixed leg's cash flows.-{#fun qlOvernightIndexedSwapFixedLeg{withOvernightIndexedSwap*`OvernightIndexedSwap',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}---- |Basis-point sensitivity of the fixed leg.-{#fun qlOvernightIndexedSwapFixedLegBPS{withOvernightIndexedSwap*`OvernightIndexedSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}---- |NPV of the fixed leg.-{#fun qlOvernightIndexedSwapFixedLegNPV{withOvernightIndexedSwap*`OvernightIndexedSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}---- |The spread that would make the swap's NPV zero.-{#fun qlOvernightIndexedSwapFairSpread{withOvernightIndexedSwap*`OvernightIndexedSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}- -- |Returns the running spread that, given the quoted recovery rate, will make the running-only CDS have an NPV of 0.This calculation does not take any upfront into account, even if one was given. {#fun qlCreditDefaultSwapFairSpread{withGenInstrument*`CreditDefaultSwap',preErrorCheck-`String'errorCheck*-}->`Double'#} @@ -1242,5 +1274,184 @@   ,withDay*`Day' -- ^startDate   ,withDay*`Day' -- ^maturityDate   ,preErrorCheck-`String'errorCheck*-}->`VarianceOption'peekVarianceOption*#}++-- |Native MTM product construction.+{#fun qlMtMCrossCurrencyBasisSwap as mtmCrossCurrencyBasisSwapRaw{`Int' -- ^type+  ,`Double' -- ^fxBaseNominal+  ,withCurrency*`Currency' -- ^fxBaseCurrency+  ,withSchedule*`Schedule' -- ^fxBaseSchedule+  ,withIborIndex*`GenIborIndex ibor1' -- ^fxBaseIndex+  ,`Double' -- ^fxBaseSpread+  ,`Double' -- ^fxBaseGearing+  ,`Double' -- ^fxQuoteNominal+  ,withCurrency*`Currency' -- ^fxQuoteCurrency+  ,withSchedule*`Schedule' -- ^fxQuoteSchedule+  ,withIborIndex*`GenIborIndex ibor2' -- ^fxQuoteIndex+  ,`Double' -- ^fxQuoteSpread+  ,`Double' -- ^fxQuoteGearing+  ,`Bool' -- ^isFxBaseCurrencyLegResettable+  ,fromIntegral`Word' -- ^fxResetFixingDays+  ,withMaybeCalendar*`Maybe Calendar' -- ^fxResetFixingCalendar+  ,`Int' -- ^fxBasePaymentLag+  ,`Int' -- ^fxQuotePaymentLag+  ,fromEnumC`BusinessDayConvention' -- ^fxBasePaymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^fxQuotePaymentConvention+  ,`Bool' -- ^fxBaseCompoundSpread+  ,fromMaybeInt`Maybe Word' -- ^fxBaseLookbackDays+  ,`Bool' -- ^fxBaseObservationShift+  ,fromIntegral`Word' -- ^fxBaseLockoutDays+  ,`RateAveragingType' -- ^fxBaseAveragingMethod+  ,`Bool' -- ^fxQuoteCompoundSpread+  ,fromMaybeInt`Maybe Word' -- ^fxQuoteLookbackDays+  ,`Bool' -- ^fxQuoteObservationShift+  ,fromIntegral`Word' -- ^fxQuoteLockoutDays+  ,`RateAveragingType' -- ^fxQuoteAveragingMethod+  ,`Bool' -- ^telescopicValueDates+  ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor3)' -- ^fxBaseStubIndexSelection+  ,withStubIndexSelection*`Maybe (StubIndexSelection ibor4)' -- ^fxQuoteStubIndexSelection+  ,preErrorCheck-`String'errorCheck*-}->`MtMCrossCurrencyBasisSwap'peekMtMCrossCurrencyBasisSwap*#}++-- |Resetting-notional cross-currency basis swap with upstream defaults (1.44).+-- Base is leg 0 and quote is leg 1. The Bool chooses whether base resets.+mtmCrossCurrencyBasisSwap :: MtmCrossCurrencySwapType -- ^Pay/receive FX base currency; base is leg 0, quote leg 1+  -> Double -- ^FX base nominal+  -> Currency -- ^FX base currency+  -> Schedule -- ^FX base schedule+  -> GenIborIndex ibor1 -- ^FX base IBOR or overnight index+  -> Double -- ^FX base spread+  -> Double -- ^FX base gearing+  -> Double -- ^FX quote nominal+  -> Currency -- ^FX quote currency+  -> Schedule -- ^FX quote schedule+  -> GenIborIndex ibor2 -- ^FX quote IBOR or overnight index+  -> Double -- ^FX quote spread+  -> Double -- ^FX quote gearing+  -> Bool -- ^True resets the FX base leg; False resets the FX quote leg+  -> IO MtMCrossCurrencyBasisSwap+mtmCrossCurrencyBasisSwap direction fxBaseNominal fxBaseCurrency fxBaseSchedule fxBaseIndex fxBaseSpread fxBaseGearing fxQuoteNominal fxQuoteCurrency fxQuoteSchedule fxQuoteIndex fxQuoteSpread fxQuoteGearing resetBase =+  mtmCrossCurrencyBasisSwapWithOptions direction fxBaseNominal fxBaseCurrency fxBaseSchedule fxBaseIndex fxBaseSpread fxBaseGearing fxQuoteNominal fxQuoteCurrency fxQuoteSchedule fxQuoteIndex fxQuoteSpread fxQuoteGearing resetBase defaultMtmCrossCurrencyBasisSwapOpts++-- |Full MTM construction (1.44). Payment lags affect coupons, not principal exchanges.+-- Empty FX fixing calendars use the resetting schedule calendar when the fixing lag is nonzero.+mtmCrossCurrencyBasisSwapWithOptions :: MtmCrossCurrencySwapType -- ^Pay/receive FX base currency; base is leg 0, quote leg 1+  -> Double -- ^FX base nominal+  -> Currency -- ^FX base currency+  -> Schedule -- ^FX base schedule+  -> GenIborIndex ibor1 -- ^FX base IBOR or overnight index+  -> Double -- ^FX base spread+  -> Double -- ^FX base gearing+  -> Double -- ^FX quote nominal+  -> Currency -- ^FX quote currency+  -> Schedule -- ^FX quote schedule+  -> GenIborIndex ibor2 -- ^FX quote IBOR or overnight index+  -> Double -- ^FX quote spread+  -> Double -- ^FX quote gearing+  -> Bool -- ^True resets the FX base leg; False resets the FX quote leg+  -> MtMCrossCurrencyBasisSwapOpts ibor3 ibor4 -- ^Payment, reset, overnight and stub options+  -> IO MtMCrossCurrencyBasisSwap+mtmCrossCurrencyBasisSwapWithOptions direction fxBaseNominal fxBaseCurrency fxBaseSchedule fxBaseIndex fxBaseSpread fxBaseGearing fxQuoteNominal fxQuoteCurrency fxQuoteSchedule fxQuoteIndex fxQuoteSpread fxQuoteGearing resetBase opts =+  mtmCrossCurrencyBasisSwapRaw (case direction of PayFxBaseCurrency -> 0; ReceiveFxBaseCurrency -> 1)+    fxBaseNominal fxBaseCurrency fxBaseSchedule fxBaseIndex fxBaseSpread fxBaseGearing fxQuoteNominal fxQuoteCurrency fxQuoteSchedule fxQuoteIndex fxQuoteSpread fxQuoteGearing resetBase+    (mtmFxResetFixingDays opts) (mtmFxResetFixingCalendar opts)+    (mtmFxBasePaymentLag opts) (mtmFxQuotePaymentLag opts)+    (mtmFxBasePaymentConvention opts) (mtmFxQuotePaymentConvention opts)+    (mtmFxBaseCompoundSpread opts) (lookbackDays baseObs) (applyObservationShift baseObs) (lockoutDays baseObs) (mtmFxBaseAveragingMethod opts)+    (mtmFxQuoteCompoundSpread opts) (lookbackDays quoteObs) (applyObservationShift quoteObs) (lockoutDays quoteObs) (mtmFxQuoteAveragingMethod opts)+    (mtmTelescopicValueDates opts) (mtmUseIndexedCoupons opts)+    (mtmFxBaseStubIndexSelection opts) (mtmFxQuoteStubIndexSelection opts)+  where baseObs = mtmFxBaseObservation opts+        quoteObs = mtmFxQuoteObservation opts++-- |Currency-denominated results shared by cross-currency swaps.+class HasCrossCurrencyResults s where+  -- |Currency of a leg, selected by zero-based index.+  legCurrency :: s -> Word -> IO Currency+  -- |Signed basis-point sensitivity in the leg currency.+  inCcyLegBps :: s -> Word -> IO Double+  -- |Signed NPV in the leg currency.+  inCcyLegNpv :: s -> Word -> IO Double+  -- |Discount factor at the NPV date for the selected currency.+  npvDateDiscounts :: s -> Word -> IO Double++instance HasCrossCurrencyResults (GenConstNotionalCrossCurrencySwap x) where+  legCurrency = constNotionalLegCurrency+  inCcyLegBps = constNotionalInCcyLegBPS+  inCcyLegNpv = constNotionalInCcyLegNPV+  npvDateDiscounts = constNotionalNpvDateDiscounts++instance HasCrossCurrencyResults MtMCrossCurrencyBasisSwap where+  legCurrency = mtmLegCurrency+  inCcyLegBps = mtmInCcyLegBPS+  inCcyLegNpv = mtmInCcyLegNPV+  npvDateDiscounts = mtmNpvDateDiscounts++-- |MTM legCurrency (1.44).+{#fun qlMtMLegCurrency as mtmLegCurrency{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,fromIntegral`Word' -- ^legIndex+  ,preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}++-- |MTM inCcyLegBPS (1.44).+{#fun qlMtMInCcyLegBPS as mtmInCcyLegBPS{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,fromIntegral`Word' -- ^legIndex+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |MTM inCcyLegNPV (1.44).+{#fun qlMtMInCcyLegNPV as mtmInCcyLegNPV{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,fromIntegral`Word' -- ^legIndex+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |MTM npvDateDiscounts (1.44).+{#fun qlMtMNpvDateDiscounts as mtmNpvDateDiscounts{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,fromIntegral`Word' -- ^legIndex+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native NPV/BPS par spread (1.44).+-- Compounded overnight spreads can leave a repricing residual.+{#fun qlMtMFairFxBaseSpread as fairFxBaseSpread{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native NPV/BPS par spread (1.44).+-- Compounded overnight spreads can leave a repricing residual.+{#fun qlMtMFairFxQuoteSpread as fairFxQuoteSpread{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native NPV/BPS par spread (1.44).+-- Compounded overnight spreads can leave a repricing residual.+{#fun qlMtMFairPaySpread as mtmFairPaySpread{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native NPV/BPS par spread (1.44).+-- Compounded overnight spreads can leave a repricing residual.+{#fun qlMtMFairRecSpread as mtmFairRecSpread{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native NPV/BPS par spreads for paid and received legs of basis swaps.+-- Compounded overnight spreads can leave a repricing residual.+class HasFairLegSpreads s where+  -- |Par spread of the paid leg.+  fairPaySpread :: s -> IO Double+  -- |Par spread of the received leg.+  fairRecSpread :: s -> IO Double+instance HasFairLegSpreads ConstNotionalCrossCurrencyBasisSwap where+  fairPaySpread = constNotionalFairPaySpread+  fairRecSpread = constNotionalFairRecSpread+instance HasFairLegSpreads MtMCrossCurrencyBasisSwap where+  fairPaySpread = mtmFairPaySpread+  fairRecSpread = mtmFairRecSpread++-- |Calculated reset rates for non-occurred coupons in leg order (1.44).+{#fun qlMtMFxResetRates as fxResetRates{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^result+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Calculated reset notionals for non-occurred coupons in leg order (1.44).+{#fun qlMtMFxResetNotionals as fxResetNotionals{withMtMCrossCurrencyBasisSwap*`MtMCrossCurrencyBasisSwap' -- ^swap+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^result+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Upstream defaults for MTM cross-currency construction.+defaultMtmCrossCurrencyBasisSwapOpts :: MtMCrossCurrencyBasisSwapOpts ibor3 ibor4+defaultMtmCrossCurrencyBasisSwapOpts = defaultMtMCrossCurrencyBasisSwapOpts  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -13,6 +13,8 @@     -- * Inspectors   , compoundFactor   , discountFactor+  , discountFactorSecondDerivative+  , discountFactorFirstDerivative   , equivalentRate   , impliedRate   , rate@@ -104,24 +106,32 @@ {#fun pure qlInterestRateRate as rate{withInterestRate*`InterestRate'}->`Double'#}  -- |Compound (capitalization) factor implied by the rate over the given period.+-- Both supported QuantLib versions reject 'SimpleThenCompounded' and 'CompoundedThenSimple';+-- use "QuantLib.CashFlow" calculations for these conventions. compoundFactor :: InterestRate -> AccrualPeriod -> IO Double compoundFactor ir period = case period of   AccrualAtTime t -> compoundFactorAtTimeRaw ir t   AccrualBetween d1 d2 rs re -> compoundFactorBetweenRaw ir d1 d2 rs re  -- |Discount factor implied by the rate over the given period.+-- Both supported QuantLib versions reject 'SimpleThenCompounded' and 'CompoundedThenSimple';+-- use "QuantLib.CashFlow" calculations for these conventions. discountFactor :: InterestRate -> AccrualPeriod -> IO Double discountFactor ir period = case period of   AccrualAtTime t -> discountFactorAtTimeRaw ir t   AccrualBetween d1 d2 rs re -> discountFactorBetweenRaw ir d1 d2 rs re  -- |Equivalent rate under a different compounding and frequency over the given period.+-- Both supported QuantLib versions reject mixed source compounding and non-unit factors with+-- mixed result compounding; use "QuantLib.CashFlow" for these conventions. equivalentRate :: InterestRate -> Compounding -> Frequency -> EquivalentPeriod -> IO InterestRate equivalentRate ir comp freq period = case period of   EquivalentAtTime t -> equivalentRateAtTimeRaw ir comp freq t   EquivalentBetween dc d1 d2 rs re -> equivalentRateBetweenRaw ir dc comp freq d1 d2 rs re  -- |Rate implied by a given compound factor over the given period, in the supplied day counter.+-- Both supported QuantLib versions reject mixed result compounding for non-unit compound factors;+-- use "QuantLib.CashFlow" calculations for 'SimpleThenCompounded' and 'CompoundedThenSimple'. impliedRate :: InterestRate -> Double -> DayCounter -> Compounding -> Frequency -> AccrualPeriod   -> IO InterestRate impliedRate ir compound dc comp freq period = case period of@@ -129,3 +139,15 @@   AccrualBetween d1 d2 rs re -> impliedRateBetweenRaw ir compound dc comp freq d1 d2 rs re  -- vim: set ff=unix ts=8 sts=2 sw=2 et:++-- |First derivative of the discount factor with respect to the rate at year fraction @t@.+-- Requires QuantLib 1.44.+{#fun qlInterestRateDiscountFactorFirstDerivative as discountFactorFirstDerivative{withInterestRate*`InterestRate' -- ^rate+  ,`Double' -- ^t+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Second derivative of the discount factor with respect to the rate at year fraction @t@.+-- Requires QuantLib 1.44.+{#fun qlInterestRateDiscountFactorSecondDerivative as discountFactorSecondDerivative{withInterestRate*`InterestRate' -- ^rate+  ,`Double' -- ^t+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}

@@ -17,8 +17,16 @@   , peekEnum   , peekDouble   , preEnum+  , withComplex+  , preComplex+  , peekComplex   , preNum   , preArray+  , preArrayWith+  , preIntArray+  , preDoubleArray+  , preCStringArray+  , prePtrArray   , withEnumArray   , withIntArray   , withBoolArray@@ -83,17 +91,19 @@   ) where +import Data.Complex(Complex((:+))) import Foreign.C.Types(CUInt(..), CInt(..), CDouble(..)) import Foreign.C.String(CString, peekCString, withCString) import Foreign.Ptr(Ptr, nullPtr, castPtr) import Foreign.ForeignPtr(FinalizerPtr, newForeignPtr, newForeignPtr_, castForeignPtr) import Foreign.Marshal.Array(peekArray, withArray) import Foreign.Marshal.Utils(with, toBool, fromBool, withMany)-import Foreign.Storable(peek, Storable)+import Foreign.Storable(peek, poke, peekElemOff, pokeElemOff, Storable) import Foreign.Marshal.Alloc(alloca) -import Control.Exception(Exception, throwIO)-import Control.Monad(when)+import Control.Exception(Exception, SomeException, throwIO, mask, mask_, finally, onException, catch)+import Foreign.StablePtr(StablePtr, castStablePtrToPtr, deRefStablePtr, freeStablePtr)+import Control.Monad(when, (>=>)) import Data.Time.Calendar(Day(ModifiedJulianDay), toModifiedJulianDay, fromGregorian) import Data.List.NonEmpty(NonEmpty, toList) @@ -101,22 +111,51 @@ import qualified Data.Vector.Storable as V  data Error = CPlusPlusException String+             -- |Call name, minimum required version, and linked QuantLib version.+           | UnsupportedQuantLibVersion String String String            | DateConversion Day            | EnumConversion String+             -- |A Haskell callback returned an array of the wrong length: expected, then returned.+           | CallbackResultLength Int Int            deriving (Show, Eq)  instance Exception Error -errorCheck :: Ptr CString -> IO ()-errorCheck p = do-  a <- peek p-  when-    (a /= nullPtr)-    ((peekCString a <* qlFreeString a) >>= throwIO . CPlusPlusException)+foreign import ccall safe "ql.h qlErrorMessage" qlErrorMessage :: Ptr () -> IO CString+foreign import ccall safe "ql.h qlErrorCall" qlErrorCall :: Ptr () -> IO CString+foreign import ccall safe "ql.h qlErrorRequiredVersion" qlErrorRequiredVersion :: Ptr () -> IO CString+foreign import ccall safe "ql.h qlErrorLinkedVersion" qlErrorLinkedVersion :: Ptr () -> IO CString+foreign import ccall safe "ql.h qlTakeErrorException" qlTakeErrorException :: Ptr () -> IO (StablePtr SomeException)+foreign import ccall safe "ql.h qlFreeError" qlFreeError :: Ptr () -> IO () --- like alloca but initializes the allocated pointer with zero+errorCheck :: Ptr (Ptr a) -> IO ()+errorCheck p = mask_ $ do+  errorPtr <- peek p+  when (errorPtr /= nullPtr) $ do+    poke p nullPtr+    let owned = castPtr errorPtr+    flip finally (qlFreeError owned) $ do+      saved <- qlTakeErrorException owned+      if castStablePtrToPtr saved == nullPtr+        then do+          call <- qlErrorCall owned >>= peekCString+          if null call+            then qlErrorMessage owned >>= peekCString >>= throwIO . CPlusPlusException+            else do+              required <- qlErrorRequiredVersion owned >>= peekCString+              linked <- qlErrorLinkedVersion owned >>= peekCString+              throwIO $ UnsupportedQuantLibVersion call required linked+        else (deRefStablePtr saved `finally` freeStablePtr saved) >>= throwIO++-- Keep the native error, including an unconsumed callback exception, scoped to adoption. preErrorCheck :: (Ptr (Ptr a) -> IO b) -> IO b-preErrorCheck = with nullPtr+preErrorCheck f = mask_ $ with nullPtr $ \p ->+  (do+    result <- f p `catch` \ex -> errorCheck p >> throwIO (ex :: SomeException)+    errorCheck p+    pure result) `finally` (do+      pending <- peek p+      when (pending /= nullPtr) (qlFreeError (castPtr pending)))  fromMaybeBool :: Maybe Bool -> CInt fromMaybeBool = maybe (-1) fromBool@@ -145,7 +184,9 @@ toMaybeBool x = if x == -1 then Nothing else Just $ toBool x  peekDynString :: CString -> IO String-peekDynString x = peekCString x <* qlFreeString x+peekDynString x+  | x == nullPtr = pure "" -- The following errorCheck reports a failed C++ call.+  | otherwise = peekCString x `finally` qlFreeString x  peekEnum :: (Enum a) => Ptr CInt -> IO a peekEnum x = toEnum . fromIntegral <$> peek x@@ -254,32 +295,50 @@   \x -> with nullPtr $     \y -> f (x, y) -peekIntArray' :: (CInt -> b) -> Ptr CUInt -> Ptr (Ptr CInt) -> IO [b]-peekIntArray' f pl pp = do-  l <- peek pl+-- Protect every output from the FFI return, including arrays not yet converted by c2hs.+preArrayWith :: (CUInt -> Ptr a -> IO ()) -> ((Ptr CUInt, Ptr (Ptr a)) -> IO b) -> IO b+preArrayWith freeFn f = mask_ $ preArray $ \slots@(pl, pp) ->+  f slots `finally` (do n <- peek pl; p <- peek pp; when (p /= nullPtr) (freeFn n p))++preIntArray :: ((Ptr CUInt, Ptr (Ptr CInt)) -> IO b) -> IO b+preIntArray = preArrayWith (const qlFreeInts)++preDoubleArray :: ((Ptr CUInt, Ptr (Ptr CDouble)) -> IO b) -> IO b+preDoubleArray = preArrayWith (const qlFreeDoubles)++preCStringArray :: ((Ptr CUInt, Ptr (Ptr CString)) -> IO b) -> IO b+preCStringArray = preArrayWith qlFreeStringArray++freePtrArray :: (Ptr a -> IO ()) -> CUInt -> Ptr (Ptr a) -> IO ()+freePtrArray freeOne n p = do+  mapM_ (peekElemOff p >=> \x -> when (x /= nullPtr) (freeOne x)) [0 .. fromIntegral n - 1]+  qlFreePointerArray (castPtr p)++prePtrArray :: (Ptr a -> IO ()) -> ((Ptr CUInt, Ptr (Ptr (Ptr a))) -> IO b) -> IO b+prePtrArray = preArrayWith . freePtrArray++-- Clear the slot while masked before taking responsibility for releasing its allocation.+consumeArray :: (CUInt -> Ptr a -> IO ()) -> Ptr CUInt -> Ptr (Ptr a) -> (CUInt -> Ptr a -> IO b) -> IO b+consumeArray freeFn pl pp convert = mask $ \restore -> do+  n <- peek pl   p <- peek pp-  map f <$> peekArray (fromIntegral l) p <* qlFreeInts p+  poke pp nullPtr+  restore (convert n p) `finally` freeFn n p +peekIntArray' :: (CInt -> b) -> Ptr CUInt -> Ptr (Ptr CInt) -> IO [b]+peekIntArray' f pl pp = consumeArray (const qlFreeInts) pl pp $ \n p ->+  map f <$> peekArray (fromIntegral n) p+ peekUIntArray :: Ptr CUInt -> Ptr (Ptr CUInt) -> IO [Word]-peekUIntArray pl pp = do-  l <- peek pl-  p <- peek pp-  map fromIntegral <$> peekArray (fromIntegral l) p <* qlFreeUInts p+peekUIntArray pl pp = consumeArray (const qlFreeUInts) pl pp $ \n p ->+  map fromIntegral <$> peekArray (fromIntegral n) p  peekIntArray :: Ptr CUInt -> Ptr (Ptr CInt) -> IO [Int] peekIntArray = peekIntArray' fromIntegral --- |An array of freshly heap-allocated (@DUP@'d) C strings -- the output-side counterpart of--- 'withStringArray'. Each element is read via 'peekCString' and the whole array (including every--- individual string) is then released via 'qlFreeStringArray' in one call, mirroring--- 'peekDoubleArray'\/'peekIntArray'\''s read-then-free shape. peekCStringArray :: Ptr CUInt -> Ptr (Ptr CString) -> IO [String]-peekCStringArray pl pp = do-  l <- peek pl-  p <- peek pp-  raws <- peekArray (fromIntegral l) p-  strs <- mapM peekCString raws-  strs <$ qlFreeStringArray l p+peekCStringArray pl pp = consumeArray qlFreeStringArray pl pp $ \n p ->+  peekArray (fromIntegral n) p >>= mapM peekCString  peekBoolArray :: Ptr CUInt -> Ptr (Ptr CInt) -> IO [Bool] peekBoolArray = peekIntArray' toBool@@ -288,57 +347,38 @@ peekDayArray = peekIntArray' fromSerial  peekDoubleArray :: Ptr CUInt -> Ptr (Ptr CDouble) -> IO [Double]-peekDoubleArray pl pp = do-  l <- peek pl-  p <- peek pp-  map realToFrac <$> peekArray (fromIntegral l) p <* qlFreeDoubles p+peekDoubleArray pl pp = consumeArray (const qlFreeDoubles) pl pp $ \n p ->+  map realToFrac <$> peekArray (fromIntegral n) p  -- |Takes ownership of a C++-allocated @double[]@ result without copying it.--- The vector's finalizer is the same @qlFreeDoubles@ path used by--- 'peekDoubleArray'. peekRealVector :: Ptr CUInt -> Ptr (Ptr CDouble) -> IO RealVector-peekRealVector pl pp = do+peekRealVector pl pp = mask_ $ do   n <- fromIntegral <$> peek pl   p <- peek pp-  fp <- castForeignPtr <$> newForeignPtr qlFreeDoublesFin p-  pure (unsafeFromForeignPtr0 fp n)+  poke pp nullPtr+  fp <- newForeignPtr qlFreeDoublesFin p `onException` qlFreeDoubles p+  pure (unsafeFromForeignPtr0 (castForeignPtr fp) n) --- |A non-owning vector view valid only for the continuation that receives the--- C++ callback buffer.  It deliberately has no finalizer.+-- |A non-owning vector view valid only during the C++ callback. borrowRealVector :: Ptr CDouble -> CUInt -> IO RealVector borrowRealVector p n = do   fp <- castForeignPtr <$> newForeignPtr_ p   pure (unsafeFromForeignPtr0 fp (fromIntegral n)) --- |Like 'peekIntArray'\''/'peekDoubleArray', but for an array of a C struct rather than a C--- primitive: reads the length and pointer out-params, walks the array via 'peekArray' (so the--- element type just needs a 'Storable' instance -- e.g. one built from c2hs @{#get#}@/@{#sizeof#}@--- hooks), converts every element via @convert@, /then/ hands the whole array to @freeFn@ to--- release. The conversion must run before the free -- unlike 'peekIntArray'\''/'peekDoubleArray',--- whose elements are self-contained primitives, a struct element read here may itself own--- further heap buffers (e.g. a @char*@/@double*@ field) that @convert@ still needs to dereference--- (via 'peekCString'/'peekArray' etc.); freeing first would leave it reading already-freed--- memory. @freeFn@ takes the element count because some frees need it (e.g.--- 'qlFreeAdditionalResults'); one that doesn't can ignore it.+-- |Convert before freeing: struct fields may borrow buffers owned by the aggregate. peekStructArray :: Storable a => (a -> IO b) -> (CUInt -> Ptr a -> IO ()) -> Ptr CUInt -> Ptr (Ptr a) -> IO [b]-peekStructArray convert freeFn pl pp = do-  l <- peek pl-  p <- peek pp-  raws <- peekArray (fromIntegral l) p-  results <- mapM convert raws-  results <$ freeFn l p+peekStructArray convert freeFn pl pp = consumeArray freeFn pl pp $ \n p ->+  peekArray (fromIntegral n) p >>= mapM convert --- |Like 'peekStructArray' but for a @T**@ array of C++-owned pointers to live objects: peeks the--- length/pointer out-params, converts each raw pointer to a live Haskell value via @peekOne@--- (installing that value's own finalizer over the pointee), then frees only the array spine via--- 'qlFreePointerArray' -- not the pointees, whose lifetime @peekOne@ has now taken over.-peekPtrArray :: (Ptr a -> IO b) -> Ptr CUInt -> Ptr (Ptr (Ptr a)) -> IO [b]-peekPtrArray peekOne pl pp = do-  l <- peek pl-  p <- peek pp-  ptrs <- peekArray (fromIntegral l) p-  xs <- mapM peekOne ptrs-  xs <$ qlFreePointerArray (castPtr p)+-- |The converter owns an element only on success; cleared slots mark completed handoffs.+peekPtrArray :: (Ptr a -> IO ()) -> (Ptr a -> IO b) -> Ptr CUInt -> Ptr (Ptr (Ptr a)) -> IO [b]+peekPtrArray freeOne peekOne pl pp = mask_ $+  consumeArray (freePtrArray freeOne) pl pp $ \n p ->+    mapM (\i -> do+      raw <- peekElemOff p i+      x <- peekOne raw+      pokeElemOff p i nullPtr+      pure x) [0 .. fromIntegral n - 1]  fromEnumQuantity :: (Enum a, Integral b, Integral c) => (b, a) -> (CInt, c) fromEnumQuantity (x, u) = (fromIntegral x, fromIntegral $ fromEnum u)@@ -473,3 +513,11 @@ zipWith6 _ _ _ _ _ _ _ = []  -- vim: set ff=unix ts=8 sts=2 sw=2 et:++-- Scalar components keep the FFI independent of C++ complex layout.+withComplex :: Complex Double -> (CDouble, CDouble)+withComplex (r :+ i) = (realToFrac r, realToFrac i)+preComplex :: ((Ptr CDouble, Ptr CDouble) -> IO a) -> IO a+preComplex f = alloca $ \r -> alloca $ \i -> f (r, i)+peekComplex :: Ptr CDouble -> Ptr CDouble -> IO (Complex Double)+peekComplex r i = (:+) . realToFrac <$> peek r <*> (realToFrac <$> peek i)

@@ -21,6 +21,7 @@ import QuantLib.Time.Date(Weekday)  {#enum JointCalendarRule{} deriving(Show, Eq, Read)#}+-- Keep both supported versions' constructors in the public enum; factories check availability. {#enum CalendarCountry{} add prefix = "Country__" deriving(Show, Eq, Read)#} {#enum AustriaMarket{} add prefix = "Austria__" deriving(Show, Eq, Read)#} {#enum BrazilMarket{} add prefix = "Brazil__" deriving(Show, Eq, Read)#}

@@ -0,0 +1,73 @@+module QuantLib.Internal.Callback+  ( Callback, CallbackArgs(..), withCallback, withCallbackPtr, withScalarCallback ) where++import Control.Exception (SomeException, catch, mask, onException)+import Foreign.C.Types (CDouble)+import Foreign.Ptr (Ptr, FunPtr, nullPtr, freeHaskellFunPtr)+import Foreign.ForeignPtr (ForeignPtr, FinalizerPtr, newForeignPtr, withForeignPtr)+import Foreign.StablePtr (StablePtr, newStablePtr, castStablePtrToPtr)+import Foreign.Storable (poke)+import QuantLib.Internal (preErrorCheck, errorCheck)++#include "qlTypesC2HS.h"+#include "qlCallback.h"++newtype Callback = Callback (ForeignPtr ())+type CallbackFun = Ptr () -> IO (Ptr ())+data CallbackArgs = CallbackArgs+  { callbackInput :: Ptr CDouble+  , callbackOutput :: Ptr CDouble+  , callbackSize :: Int+  , callbackInput2 :: Ptr CDouble+  , callbackSize2 :: Int+  , callbackOutputSize :: Int+  , callbackDirection :: Int+  , callbackScalar :: Double+  , callbackTime1 :: Double+  , callbackTime2 :: Double+  }++foreign import ccall "wrapper" wrapCallback :: CallbackFun -> IO (FunPtr CallbackFun)+foreign import ccall "&hs_free_fun_ptr" releaseFun :: FunPtr (FunPtr CallbackFun -> IO ())+foreign import ccall "&hs_free_stable_ptr" releaseStable :: FunPtr (StablePtr SomeException -> IO ())+foreign import ccall safe "ql.h qlNewCallback" newCallback+  :: FunPtr CallbackFun -> FunPtr (FunPtr CallbackFun -> IO ())+  -> FunPtr (StablePtr SomeException -> IO ()) -> Ptr (Ptr ()) -> IO (Ptr ())+foreign import ccall safe "ql.h qlFreeCallback" freeCallback :: Ptr () -> IO ()++foreign import ccall "&qlFreeCallback" callbackFinalizer :: FinalizerPtr ()++withCallbackPtr :: Callback -> (Ptr () -> IO a) -> IO a+withCallbackPtr (Callback p) = withForeignPtr p++peekArgs :: Ptr () -> IO CallbackArgs+peekArgs p = CallbackArgs+  <$> {#get QlCallbackArgs->input#} p+  <*> {#get QlCallbackArgs->output#} p+  <*> (fromIntegral <$> {#get QlCallbackArgs->size#} p)+  <*> {#get QlCallbackArgs->input2#} p+  <*> (fromIntegral <$> {#get QlCallbackArgs->size2#} p)+  <*> (fromIntegral <$> {#get QlCallbackArgs->outputSize#} p)+  <*> (fromIntegral <$> {#get QlCallbackArgs->direction#} p)+  <*> (realToFrac <$> {#get QlCallbackArgs->s#} p)+  <*> (realToFrac <$> {#get QlCallbackArgs->t1#} p)+  <*> (realToFrac <$> {#get QlCallbackArgs->t2#} p)++withCallback :: (CallbackArgs -> IO ()) -> (Callback -> IO a) -> IO a+withCallback action use = mask $ \restore -> do+  fp <- wrapCallback call+  owner <- (preErrorCheck $ \errorPtr -> do+    result <- newCallback fp releaseFun releaseStable errorPtr+    errorCheck errorPtr+    pure result) `onException` freeHaskellFunPtr fp+  managed <- newForeignPtr callbackFinalizer owner `onException` freeCallback owner+  restore (use (Callback managed))+  where+    call p = mask $ \restore ->+      (restore (peekArgs p >>= action) >> pure nullPtr) `catch` saveException+    saveException :: SomeException -> IO (Ptr ())+    saveException = fmap castStablePtrToPtr . newStablePtr++withScalarCallback :: (CallbackArgs -> IO Double) -> (Callback -> IO a) -> IO a+withScalarCallback action = withCallback $ \args ->+  action args >>= poke (callbackOutput args) . realToFrac

@@ -1,4 +1,4 @@-{-# LANGUAGE TemplateHaskell, StandaloneDeriving #-}+{-# LANGUAGE TemplateHaskell, StandaloneDeriving, ExistentialQuantification #-} -- internal utilities to convert special enums: either complex ones or represented as QuantLib objects that I didn't want to expose so I represented them as ADTs {-# OPTIONS_GHC -Wno-unused-top-binds #-} module QuantLib.Internal.Common@@ -57,6 +57,8 @@    , CPIInterpolationType(..) +  , StubIndexSelection(..)+  , withStubIndexSelection   , OvernightObservation(..)   , defaultOvernightObservation @@ -125,15 +127,15 @@   , RawResultPtr   , RawResult(..)   , convertResult+  , preAdditionalResults   , peekAdditionalResults   ) where-import Foreign.Ptr(Ptr, FunPtr, nullPtr, castPtr)+import Foreign.Ptr(Ptr, nullPtr, castPtr) import Foreign.C.Types(CUInt, CInt, CDouble) import Foreign.C.String(CString, peekCString) import Foreign.Storable(Storable(..)) import Foreign.Marshal.Utils(withMany) import Foreign.Marshal.Array(withArray, peekArray)-import Control.Exception(finally) import Data.List.NonEmpty(NonEmpty, toList)  import QuantLib.Internal@@ -200,21 +202,11 @@ {#enum PricingErrorLevel{} deriving (Show, Eq, Read, Bounded)#} peekPricingErrorLevelArray :: Ptr CUInt -> Ptr (Ptr CInt) -> IO [PricingErrorLevel] peekPricingErrorLevelArray = peekIntArray' toEnumC--- Confirmed clash (a real one, caught by the build, not assumed): 4 of DeliverySchedule's 8 tags--- (Daily/Weekly/Monthly/Quarterly) collide with QuantLib.Time.Schedule's own Frequency enum, whose--- module this file is imported into unqualified. Prefixed Haskell-side only (c2hs's own "add--- prefix", not a cbits/qlEnumC2HS.h rename) -- same targeted-rename convention as--- UnitOfMeasureType's Quantity->QuantityUnit above, not a blanket defensive prefix.+-- Prefix these tags to avoid clashes with QuantLib.Time.Schedule's Frequency constructors. {#enum DeliverySchedule{} add prefix = "Delivery" deriving (Show, Eq, Read, Bounded)#} {#enum QuantityPeriodicity{} deriving (Show, Eq, Read, Bounded)#}--- flat/linear interpolation of a CPI index between its publication dates -- skips the--- deprecated AsIndex upstream case, so cbits/qlEnumObjects.h's values (and thus this--- c2hs-derived enum's fromEnum) start at 1, not 0; see that header's comment for why a--- renumbered-from-0 enum here would silently alias to the wrong upstream case. Declared here--- (not in QuantLib.TermStructure.Inflation, its "natural" home) for the same reason as--- TimeUnit above: needed by several modules whose build order can't all safely {#import#} that--- module (built before it, or -- for QuantLib.TermStructure.Yield -- mutually dependent with--- it already).+-- CPI interpolation skips upstream's deprecated AsIndex value, so the enum starts at 1.+-- Shared users import it from here to avoid a module cycle. {#enum CPIInterpolationType{} deriving (Show, Eq, Read, Bounded)#} {#enum CalibrationBasketType{} deriving (Show, Eq, Read, Bounded)#} @@ -280,7 +272,12 @@ {#pointer *QlLmCorrelationModel foreign -> CLmCorrelationModel nocode#} {#pointer *QlLmVolatilityModel foreign -> CLmVolatilityModel nocode#} {#pointer *Rounding as QlRounding foreign -> CRounding nocode#}+{#pointer *QlAdditionalResult as RawResultPtr nocode#} +-- |Discriminants for `QlAdditionalResult.type`, bound from `enum AdditionalResultType` in+-- `cbits/qlInstrument.h` (read from the header, not hardcoded).+{#enum AdditionalResultType {} deriving (Show, Eq, Read) #}+ -- monotonic flag for CubicInterpolation::Spline/::Parabolic -- tells deriveCrossEnum to give -- these two values a runtime Bool field instead of cross-producting named sub-values (same -- pattern as Actual360Convention etc. in CalendarEnum.chs). Order matters here in a way it@@ -369,6 +366,24 @@         !Calendar -- ^rebatePaymentCalendar         !BusinessDayConvention -- ^rebatePaymentConvention +-- |Candidate indices for broken IBOR periods, selected by nearest maturity or interpolated+-- between bracketing maturities in calendar days. Candidates keep their own curves and histories.+-- Their currency, fixing days/calendar and day counter must match; enable indexed coupons+-- when supplying a selection. Requires QuantLib 1.44.+data StubIndexSelection ibor+  = ClosestStubIndex !(NonEmpty (GenIborIndex ibor))+  | InterpolatedStubIndexes !(NonEmpty (GenIborIndex ibor))++type StubSelectionPtr = Ptr CStubIndexSelection'+{#pointer *QlStubIndexSelection nocode#}+{#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}++withStubIndexSelection :: Maybe (StubIndexSelection ibor) -> (Ptr CStubIndexSelection' -> IO r) -> IO r+withStubIndexSelection Nothing f = f nullPtr+withStubIndexSelection (Just selection) f = case selection of+  ClosestStubIndex indices -> withConstructed (stubIndexSelectionRaw 0 (toList indices)) f+  InterpolatedStubIndexes indices -> withConstructed (stubIndexSelectionRaw 1 (toList indices)) f+ {#fun qlExercise{`ExerciseType',preErrorCheck-`String'errorCheck*-}->`QlExercise'peekPtr*#} {#fun qlAmericanExercise{withDay*`Day',withDay*`Day',`Bool',preErrorCheck-`String'errorCheck*-}->`QlAmericanExercise'peekPtr*#} {#fun qlAmericanExercise1{withDay*`Day',`Bool',preErrorCheck-`String'errorCheck*-}->`QlAmericanExercise'peekPtr*#}@@ -380,24 +395,24 @@ {#fun qlRebatedExercise{`QlExercise',`Double',fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',preErrorCheck-`String'errorCheck*-}->`QlRebatedExercise'peekPtr*#}  withEuropeanExercise :: EuropeanExercise -> (QlEuropeanExercise -> IO a) -> IO a-withEuropeanExercise (EuropeanExercise d) f = qlEuropeanExercise d >>= newCastForeignPtr >>= flip withGenForeignPtr f+withEuropeanExercise (EuropeanExercise d) f = withConstructed (qlEuropeanExercise d) f  withSwingExercise :: SwingExercise -> (QlSwingExercise -> IO a) -> IO a-withSwingExercise (SwingListExercise ds) f = uncurry qlSwingExercise (unzip (toList ds)) >>= newCastForeignPtr >>= flip withGenForeignPtr f-withSwingExercise (SwingIntervalExercise d1 d2 s) f = qlSwingExercise1 d1 d2 s >>= newCastForeignPtr >>= flip withGenForeignPtr f+withSwingExercise (SwingListExercise ds) f = withConstructed (uncurry qlSwingExercise (unzip (toList ds))) f+withSwingExercise (SwingIntervalExercise d1 d2 s) f = withConstructed (qlSwingExercise1 d1 d2 s) f  withBermudanExercise :: BermudanExercise -> (QlBermudanExercise -> IO a) -> IO a-withBermudanExercise (BermudanExercise d p) f = qlBermudanExercise (toList d) p >>= newCastForeignPtr >>= flip withGenForeignPtr f-withBermudanExercise (Swing e) f = withSwingExercise e (\sp -> upcast sp >>= \bp -> f bp `finally` freeUpcast bp)+withBermudanExercise (BermudanExercise d p) f = withConstructed (qlBermudanExercise (toList d) p) f+withBermudanExercise (Swing e) f = withSwingExercise e (\sp -> withUpcast sp f)  withExercise :: Exercise -> (QlExercise -> IO a) -> IO a-withExercise (American Nothing d p) f = qlAmericanExercise1 d p >>= newGenForeignPtr >>= flip withGenForeignPtr f-withExercise (American (Just d0) d p) f = qlAmericanExercise d0 d p >>= newGenForeignPtr >>= flip withGenForeignPtr f-withExercise (Early t p) f = qlEarlyExercise t p >>= newCastForeignPtr >>= flip withGenForeignPtr f-withExercise (Vanilla t) f = qlExercise t >>= newCastForeignPtr >>= flip withGenForeignPtr f-withExercise (European e) f = withEuropeanExercise e (\ep -> upcast ep >>= \xp -> f xp `finally` freeUpcast xp)-withExercise (Bermudan e) f = withBermudanExercise e (\bp -> upcast bp >>= \xp -> f xp `finally` freeUpcast xp)-withExercise (Rebated e rebate days cal bdc) f = withExercise e (\ep -> qlRebatedExercise ep rebate days cal bdc >>= newGenForeignPtr >>= flip withGenForeignPtr f)+withExercise (American Nothing d p) f = withConstructedUpcast (qlAmericanExercise1 d p) f+withExercise (American (Just d0) d p) f = withConstructedUpcast (qlAmericanExercise d0 d p) f+withExercise (Early t p) f = withConstructed (qlEarlyExercise t p) f+withExercise (Vanilla t) f = withConstructed (qlExercise t) f+withExercise (European e) f = withEuropeanExercise e (\ep -> withUpcast ep f)+withExercise (Bermudan e) f = withBermudanExercise e (\bp -> withUpcast bp f)+withExercise (Rebated e rebate days cal bdc) f = withExercise e (\ep -> withConstructedUpcast (qlRebatedExercise ep rebate days cal bdc) f)  -- | use 'percentageStrikePayoff' to construct 'Payoff' data PercentageStrikePayoff = PercentageStrikePayoff@@ -437,23 +452,23 @@       !OptionType -- ^type       !Double -- ^strike       !String -- ^name-      !(FunPtr PayoffFun)+      !Callback  withPercentageStrikePayoff :: PercentageStrikePayoff -> (QlPercentageStrikePayoff -> IO a) -> IO a-withPercentageStrikePayoff (PercentageStrikePayoff t m) f = qlPercentageStrikePayoff t m >>= newCastForeignPtr >>= flip withGenForeignPtr f+withPercentageStrikePayoff (PercentageStrikePayoff t m) f = withConstructed (qlPercentageStrikePayoff t m) f  withPlainVanillaPayoff :: PlainVanillaPayoff -> (QlPlainVanillaPayoff -> IO a) -> IO a-withPlainVanillaPayoff (PlainVanillaPayoff t s) f = qlPlainVanillaPayoff t s >>= newCastForeignPtr >>= flip withGenForeignPtr f+withPlainVanillaPayoff (PlainVanillaPayoff t s) f = withConstructed (qlPlainVanillaPayoff t s) f  withStrikedPayoff :: StrikedPayoff -> (QlStrikedTypePayoff -> IO a) -> IO a-withStrikedPayoff (AssetOrNothing t s) f = qlAssetOrNothingPayoff t s >>= newCastForeignPtr >>= flip withGenForeignPtr f-withStrikedPayoff (CashOrNothing t s c) f = qlCashOrNothingPayoff t s c >>= newCastForeignPtr >>= flip withGenForeignPtr f-withStrikedPayoff (Gap t s ss) f = qlGapPayoff t s ss >>= newCastForeignPtr >>= flip withGenForeignPtr f-withStrikedPayoff (PercentageStrike p) f = withPercentageStrikePayoff p (\pp -> upcast pp >>= \sp -> f sp `finally` freeUpcast sp)-withStrikedPayoff (PlainVanilla p) f = withPlainVanillaPayoff p (\pp -> upcast pp >>= \sp -> f sp `finally` freeUpcast sp)-withStrikedPayoff (SuperFund s ss) f = qlSuperFundPayoff s ss >>= newCastForeignPtr >>= flip withGenForeignPtr f-withStrikedPayoff (SuperSharePayoff s ss c) f = qlSuperSharePayoff s ss c >>= newCastForeignPtr >>= flip withGenForeignPtr f-withStrikedPayoff (CustomStriked t k n fp) f = qlStrikedPayoffFromFunction t k n fp >>= newCastForeignPtr >>= flip withGenForeignPtr f+withStrikedPayoff (AssetOrNothing t s) f = withConstructed (qlAssetOrNothingPayoff t s) f+withStrikedPayoff (CashOrNothing t s c) f = withConstructed (qlCashOrNothingPayoff t s c) f+withStrikedPayoff (Gap t s ss) f = withConstructed (qlGapPayoff t s ss) f+withStrikedPayoff (PercentageStrike p) f = withPercentageStrikePayoff p (\pp -> withUpcast pp f)+withStrikedPayoff (PlainVanilla p) f = withPlainVanillaPayoff p (\pp -> withUpcast pp f)+withStrikedPayoff (SuperFund s ss) f = withConstructed (qlSuperFundPayoff s ss) f+withStrikedPayoff (SuperSharePayoff s ss c) f = withConstructed (qlSuperSharePayoff s ss c) f+withStrikedPayoff (CustomStriked t k n fp) f = withConstructed (qlStrikedPayoffFromFunction t k n fp) f  data TypePayoff = Striked !StrikedPayoff   | Floating !OptionType -- ^type@@ -474,19 +489,19 @@   -- 'Payoff' exactly as 'Max'\/'Min'\/'Spread' are. Build it with 'withCustomBasketPayoff'.   | CustomAccumulate       !Payoff -- ^base payoff, applied to the accumulated value-      !(FunPtr BasketAccumulateFun)+      !Callback  withTypePayoff :: TypePayoff -> (QlTypePayoff -> IO a) -> IO a-withTypePayoff (Floating t) f = qlFloatingTypePayoff t >>= newCastForeignPtr >>= flip withGenForeignPtr f-withTypePayoff (Striked s) f = withStrikedPayoff s (\sp -> upcast sp >>= \tp -> f tp `finally` freeUpcast tp)+withTypePayoff (Floating t) f = withConstructed (qlFloatingTypePayoff t) f+withTypePayoff (Striked s) f = withStrikedPayoff s (\sp -> withUpcast sp f)  withBasketPayoff :: BasketPayoff -> (QlBasketPayoff -> IO a) -> IO a-withBasketPayoff (Average p n) f = withPayoff p (\pp -> qlAverageBasketPayoff pp n >>= newCastForeignPtr >>= flip withGenForeignPtr f)-withBasketPayoff (AverageMultiple p a) f = withPayoff p (\pp -> qlAverageBasketPayoff1 pp a >>= newCastForeignPtr >>= flip withGenForeignPtr f)-withBasketPayoff (Max p) f = withPayoff p (\pp -> qlMaxBasketPayoff pp >>= newCastForeignPtr >>= flip withGenForeignPtr f)-withBasketPayoff (Min p) f = withPayoff p (\pp -> qlMinBasketPayoff pp >>= newCastForeignPtr >>= flip withGenForeignPtr f)-withBasketPayoff (Spread p) f = withPayoff p (\pp -> qlSpreadBasketPayoff pp >>= newCastForeignPtr >>= flip withGenForeignPtr f)-withBasketPayoff (CustomAccumulate p fp) f = withPayoff p (\pp -> qlBasketPayoffFromFunction pp fp >>= newCastForeignPtr >>= flip withGenForeignPtr f)+withBasketPayoff (Average p n) f = withPayoff p (\pp -> withConstructed (qlAverageBasketPayoff pp n) f)+withBasketPayoff (AverageMultiple p a) f = withPayoff p (\pp -> withConstructed (qlAverageBasketPayoff1 pp a) f)+withBasketPayoff (Max p) f = withPayoff p (\pp -> withConstructed (qlMaxBasketPayoff pp) f)+withBasketPayoff (Min p) f = withPayoff p (\pp -> withConstructed (qlMinBasketPayoff pp) f)+withBasketPayoff (Spread p) f = withPayoff p (\pp -> withConstructed (qlSpreadBasketPayoff pp) f)+withBasketPayoff (CustomAccumulate p fp) f = withPayoff p (\pp -> withConstructed (qlBasketPayoffFromFunction pp fp) f)  -- | > Payoff -- >  DoubleStickyRatchet@@ -587,13 +602,11 @@       !Double -- ^accrualFactor   | Type !TypePayoff   | Basket !BasketPayoff-  -- |A Haskell-defined payoff. Build it with 'withCustomPayoff' rather than by hand: the-  -- 'FunPtr' must stay alive for as long as anything can still call the payoff, which-  -- 'withCustomPayoff' arranges and a hand-built value does not.+  -- |A Haskell-defined payoff with a managed callback; build with 'withCustomPayoff'.   | Custom       !String -- ^name       !String -- ^description-      !(FunPtr PayoffFun)+      !Callback   {#fun qlAssetOrNothingPayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}@@ -617,22 +630,22 @@ {#fun qlSuperFundPayoff{`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#} {#fun qlSuperSharePayoff{`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#} {#fun qlAverageBasketPayoff1{`QlPayoff',withDoubleArray*`[Double]'&,preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlPayoffFromFunction{`String',`String',id`FunPtr PayoffFun',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlBasketPayoffFromFunction{`QlPayoff',id`FunPtr BasketAccumulateFun',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlStrikedPayoffFromFunction{`OptionType',`Double',`String',id`FunPtr PayoffFun',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}+{#fun qlPayoffFromFunction{`String',`String',withCallbackPtr*`Callback',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlBasketPayoffFromFunction{`QlPayoff',withCallbackPtr*`Callback',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}+{#fun qlStrikedPayoffFromFunction{`OptionType',`Double',`String',withCallbackPtr*`Callback',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}  withPayoff :: Payoff -> (QlPayoff -> IO a) -> IO a-withPayoff (DoubleStickyRatchet t1 t2 g1 g2 g3 s1 s2 s3 i1 i2 a) f = qlDoubleStickyRatchetPayoff t1 t2 g1 g2 g3 s1 s2 s3 i1 i2 a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (ForwardType t s) f = qlForwardTypePayoff t s >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (RatchetMax g1 g2 g3 s1 s2 s3 i1 i2 a) f = qlRatchetMaxPayoff g1 g2 g3 s1 s2 s3 i1 i2 a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (RatchetMin g1 g2 g3 s1 s2 s3 i1 i2 a) f = qlRatchetMinPayoff g1 g2 g3 s1 s2 s3 i1 i2 a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (Ratchet g1 g2 s1 s2 i a) f = qlRatchetPayoff g1 g2 s1 s2 i a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (StickyMax g1 g2 g3 s1 s2 s3 i1 i2 a) f = qlStickyMaxPayoff g1 g2 g3 s1 s2 s3 i1 i2 a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (StickyMin g1 g2 g3 s1 s2 s3 i1 i2 a) f = qlStickyMinPayoff g1 g2 g3 s1 s2 s3 i1 i2 a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (Sticky g1 g2 s1 s2 i a) f = qlStickyPayoff g1 g2 s1 s2 i a >>= newCastForeignPtr >>= flip withGenForeignPtr f-withPayoff (Type t) f = withTypePayoff t (\tp -> upcast tp >>= \pp -> f pp `finally` freeUpcast pp)-withPayoff (Basket b) f = withBasketPayoff b (\bp -> upcast bp >>= \pp -> f pp `finally` freeUpcast pp)-withPayoff (Custom n d fp) f = qlPayoffFromFunction n d fp >>= newCastForeignPtr >>= flip withGenForeignPtr f+withPayoff (DoubleStickyRatchet t1 t2 g1 g2 g3 s1 s2 s3 i1 i2 a) f = withConstructed (qlDoubleStickyRatchetPayoff t1 t2 g1 g2 g3 s1 s2 s3 i1 i2 a) f+withPayoff (ForwardType t s) f = withConstructed (qlForwardTypePayoff t s) f+withPayoff (RatchetMax g1 g2 g3 s1 s2 s3 i1 i2 a) f = withConstructed (qlRatchetMaxPayoff g1 g2 g3 s1 s2 s3 i1 i2 a) f+withPayoff (RatchetMin g1 g2 g3 s1 s2 s3 i1 i2 a) f = withConstructed (qlRatchetMinPayoff g1 g2 g3 s1 s2 s3 i1 i2 a) f+withPayoff (Ratchet g1 g2 s1 s2 i a) f = withConstructed (qlRatchetPayoff g1 g2 s1 s2 i a) f+withPayoff (StickyMax g1 g2 g3 s1 s2 s3 i1 i2 a) f = withConstructed (qlStickyMaxPayoff g1 g2 g3 s1 s2 s3 i1 i2 a) f+withPayoff (StickyMin g1 g2 g3 s1 s2 s3 i1 i2 a) f = withConstructed (qlStickyMinPayoff g1 g2 g3 s1 s2 s3 i1 i2 a) f+withPayoff (Sticky g1 g2 s1 s2 i a) f = withConstructed (qlStickyPayoff g1 g2 s1 s2 i a) f+withPayoff (Type t) f = withTypePayoff t (\tp -> withUpcast tp f)+withPayoff (Basket b) f = withBasketPayoff b (\bp -> withUpcast bp f)+withPayoff (Custom n d fp) f = withConstructed (qlPayoffFromFunction n d fp) f  -- |Wrap a Haskell @price -> value@ function as a real QuantLib @Payoff@, usable anywhere a -- 'Payoff' is (@QuantLib.Instrument.Option.oneAssetOption@, @multiAssetOption@,@@ -640,11 +653,8 @@ -- @fdmCellAveragingInnerValue@, ...) -- the fully custom counterpart to the concrete -- pre-implemented payoffs listed by the 'Payoff' constructors above. ----- The payoff is valid only inside the continuation, and the continuation must span the whole--- /use/, not just the construction: every consumer stores the payoff and calls back into it--- later (an @Instrument@ at @NPV@ time, an @FdmInnerValueCalculator@ at @fdmSolve@ time), so--- pricing must happen before this function returns. Same lifetime rule, and the same reason, as--- @QuantLib.Method.withCustomFdmInnerValueCalculator@.+-- The payoff ADT and every native consumer retain the callback after the continuation returns.+-- Callback exceptions are rethrown by the enclosing Haskell call. -- -- @name@ and @description@ are what QuantLib's own error messages and @Payoff::name@ report; they -- are not interpreted.@@ -653,10 +663,8 @@ -- difference and @MCEuropeanEngine@ families all recover the strike by downcasting to -- @StrikedTypePayoff@\/@PlainVanillaPayoff@ first, and a further ~30 engines route through -- @BlackCalculator@, whose @AcyclicVisitor@ knows only the four built-in striked payoffs. Most of--- these fail with a clean QuantLib exception, but--- @QuantLib.PricingEngine.fdBlackScholesVanillaEngine@ and--- @QuantLib.PricingEngine.fdHestonVanillaEngine@ perform that downcast /unchecked/ upstream and--- will __crash the process__, not throw, on a custom payoff. Confirmed-generic consumers:+-- these fail with a clean QuantLib exception. The two bound finite-difference vanilla engines+-- validate the required striked payoff, including on QuantLib 1.43. Confirmed-generic consumers: -- @QuantLib.Method.fdmLogInnerValue@\/@fdmCellAveragingInnerValue@ (and hence @fdmSolve@), and -- @QuantLib.PricingEngine.mcAmericanEngine@ with @controlVariate = False@. withCustomPayoff :: String -- ^name@@ -671,18 +679,15 @@ -- __The pair is advisory: it does not define the payoff__ -- @payoff(price)@ alone does, exactly -- as for 'withCustomPayoff'. It exists because QuantLib's finite-difference vanilla engines reach -- past the @Payoff@ interface for a strike when sizing their grid:--- @FdBlackScholesVanillaEngine@ @dynamic_pointer_cast@s to @StrikedTypePayoff@ /without/ a check--- and calls @strike()@ twice -- once for the mesher's extent, once for its node-concentration--- point -- then hands the payoff itself to @FdmLogInnerValue@, which takes a plain @Payoff@. So a--- payoff built here prices correctly through--- 'QuantLib.PricingEngine.fdBlackScholesVanillaEngine' and--- 'QuantLib.PricingEngine.fdHestonVanillaEngine', where one built by 'withCustomPayoff' would--- crash the process on that unchecked cast. Pass the strike you want the grid centred on.+-- @FdBlackScholesVanillaEngine@ @dynamic_pointer_cast@s to @StrikedTypePayoff@ and calls+-- @strike()@ twice -- once for the mesher's extent, once for its node-concentration point -- then+-- hands the payoff itself to @FdmLogInnerValue@, which takes a plain @Payoff@. So a payoff built+-- here prices correctly through 'QuantLib.PricingEngine.fdBlackScholesVanillaEngine' and+-- 'QuantLib.PricingEngine.fdHestonVanillaEngine', where one built by 'withCustomPayoff' is+-- rejected with an exception. Pass the strike you want the grid centred on. ----- Everything else matches 'withCustomPayoff', including the continuation-lifetime rule: the--- payoff is valid only inside the continuation, which must span the whole use (pricing included),--- not just construction. @description@ is not a parameter here -- @StrikedTypePayoff@ derives it--- from the type and strike itself.+-- The payoff and native consumers retain the callback after the continuation returns.+-- @description@ is derived from the type and strike by @StrikedTypePayoff@. -- -- Engines routing through @BlackCalculator@ (the @analytic*@ family) still reject this, as they -- must: its @AcyclicVisitor@ knows only the four built-in striked payoffs, and there is no@@ -697,7 +702,7 @@ -- |Wrap a Haskell @underlyings -> accumulated@ function as a real QuantLib @BasketPayoff@ around -- @base@ (which is applied to the accumulated value, exactly as for 'Max'\/'Min'\/'Spread') -- -- usable with @QuantLib.Instrument.Option.basketOption@ and--- @QuantLib.Method.fdmLogBasketInnerValue@. Same continuation-lifetime rule as 'withCustomPayoff';+-- @QuantLib.Method.fdmLogBasketInnerValue@. Same ownership rule as 'withCustomPayoff'; -- unlike it, this callback crosses once per evaluation with the whole underlying-state vector, -- because that is the shape @BasketPayoff::accumulate@ already has upstream. withCustomBasketPayoff :: Payoff -- ^base payoff@@ -1043,7 +1048,7 @@ withLmVolatilityModel :: LmVolatilityModel -> (Ptr CLmVolatilityModel -> IO a) -> IO a withLmVolatilityModel = withEnumType volatilityModelMeta -data Claim = FaceValue | FaceValueAccrual Bond+data Claim = FaceValue | forall b. FaceValueAccrual (GenBond b) claimMeta :: EnumMeta Claim CQlClaim claimMeta = EnumMeta claim @@ -1058,7 +1063,7 @@ {#fun qlFaceValueClaim{preErrorCheck-`String'errorCheck*-}->`QlClaim'peekClaim*#}  -- |Claim on the notional of a reference security, including accrual-{#fun qlFaceValueAccrualClaim{withBond*`Bond',preErrorCheck-`String'errorCheck*-}->`QlClaim'peekClaim*#}+{#fun qlFaceValueAccrualClaim{withBond*`GenBond b',preErrorCheck-`String'errorCheck*-}->`QlClaim'peekClaim*#}  strikedPayoff :: StrikedPayoff -> Payoff strikedPayoff = Type . Striked@@ -1079,16 +1084,6 @@ data AdditionalResultVal = RealVal Double | StringVal String | RealVectorVal [Double] | UnsupportedVal String   deriving (Show, Eq) --- |Discriminants for `QlAdditionalResult.type`, bound from `enum AdditionalResultType` in--- `cbits/qlInstrument.h` (read from the header, not hardcoded).-{#enum AdditionalResultType {} deriving (Show, Eq, Read) #}---- |Registers `struct QlAdditionalResult*` with c2hs as `RawResultPtr`, `nocode` since we supply--- the Haskell type ourselves (below) rather than a c2hs-generated wrapper. This is what lets the--- `additionalResults` `{#fun#}` binding (in `QuantLib.Instrument`)'s low-level array-of-structs--- out-parameter (C type `struct QlAdditionalResult **`) be typed `Ptr RawResultPtr` =--- `Ptr (Ptr RawResult)`, instead of defaulting to an opaque `Ptr (Ptr ())`.-{#pointer *QlAdditionalResult as RawResultPtr nocode#} type RawResultPtr = Ptr RawResult  -- |One raw `QlAdditionalResult` entry, peeked field-by-field via c2hs `{#get#}` hooks. Its@@ -1131,3 +1126,10 @@ peekAdditionalResults = peekStructArray convertResult (\l p -> qlFreeAdditionalResults l (castPtr p))  -- vim: set ff=unix ts=8 sts=2 sw=2 et:++preAdditionalResults :: ((Ptr CUInt, Ptr RawResultPtr) -> IO b) -> IO b+preAdditionalResults = preArrayWith (\l p -> qlFreeAdditionalResults l (castPtr p))++{#fun qlStubIndexSelection as stubIndexSelectionRaw{`Int'+  ,withIborIndexArray*`[GenIborIndex ibor]'&+  ,preErrorCheck-`String'errorCheck*-}->`StubSelectionPtr'peekPtr*#}

@@ -1,19 +1,19 @@ {-# LANGUAGE RankNTypes, TypeFamilies, TypeOperators, FlexibleContexts, FlexibleInstances #-} module QuantLib.Internal.Type where-import Foreign.Ptr(Ptr, FunPtr, nullPtr, nullFunPtr, freeHaskellFunPtr, plusPtr, castPtr)+import Foreign.Ptr(Ptr, nullPtr) import Foreign.ForeignPtr(ForeignPtr, FinalizerPtr, newForeignPtr, withForeignPtr) import Foreign.C.Types(CUInt(..), CInt, CDouble(..)) import Foreign.C.String(CString)-import Foreign.Marshal.Array(withArray, peekArray, copyArray)-import Foreign.Marshal.Utils(withMany, fillBytes)-import Foreign.Storable(peek, sizeOf)+import Foreign.Marshal.Array(withArray, peekArray)+import Foreign.Marshal.Utils(withMany)+import Foreign.Storable(peek) -import Control.Monad((>=>), when)+import Control.Monad((>=>)) import System.IO.Unsafe(unsafePerformIO)-import qualified Data.Vector.Storable as V -import QuantLib.Internal(RealVector, borrowRealVector, peekDynString, preArray, peekDayArray, peekPtrArray)-import Control.Exception (finally, mask)+import qualified QuantLib.Internal.Callback as Callback+import QuantLib.Internal(RealVector, borrowRealVector, peekDynString, preIntArray, prePtrArray, peekDayArray, peekPtrArray)+import Control.Exception (bracket, finally, mask, mask_, onException)  (<.>) :: Functor f => (b -> r) -> (a -> f b) -> a -> f r f1 <.> f2 = fmap f1 . f2@@ -35,207 +35,38 @@ -- unsafePerformIO is safe; NOINLINE keeps GHC from duplicating or floating the C++ -- call, matching how QuantLib.Context guards its own unsafePerformIO sites. showStandalone :: (Ptr a -> IO CString) -> Standalone a -> String-showStandalone f x = unsafePerformIO $ withStandalone x (f >=> peekDynString)+showStandalone f x = unsafePerformIO $ mask_ $ withStandalone x (f >=> peekDynString) {-# NOINLINE showStandalone #-} --- On `safe' vs `unsafe' imports, file-wide (this was an open TODO; it is settled):---   * The `&qlFreeX' finalizer imports below take a symbol *address*, not a call, so their---     `unsafe' annotation is inert. The call that matters is `callFinalizer' above, plus---     whatever the GC runs; both are safe.---   * Everything that runs QuantLib logic stays `safe'. Under the non-threaded RTS an---     `unsafe' call blocks GC and the scheduler for its whole duration, and pricing or---     bootstrapping is unbounded.---   * The qlXAsY upcast shims are the one legitimate `unsafe' candidate -- bare---     `ret(new QlY(*arg(o)))', no callback into Haskell, bounded work -- but they are---     already dominated by the QuantLib call they precede, so leave them `safe' absent a---     measurement; a per-shim rule would break the first time one grows logic.--- If a Haskell callback is ever passed into C++, every import on that path must be `safe'.------ 'withCostFunction' below is the first such callback: it turns a Haskell @[Double] -> Double@--- into a C function pointer QuantLib's optimizer calls back into once per outer iteration (the--- whole parameter vector, not per component) -- the coarsened-callback shape documented in--- CLAUDE.md's "coarsen the language-boundary crossing" bullet, modeled on QuantLib-SWIG's own--- @PyCostFunction@ (@SWIG/functions.i@).-foreign import ccall "wrapper" mkCostFunPtr-  :: (Ptr CDouble -> CUInt -> IO CDouble) -> IO (FunPtr (Ptr CDouble -> CUInt -> IO CDouble))--- Build a C function pointer around a Haskell cost function for the duration of one 'optimize'--- call, freeing it with 'freeHaskellFunPtr' once the continuation returns, whether normally or--- via exception.-withCostFunction :: (RealVector -> Double) -> (FunPtr (Ptr CDouble -> CUInt -> IO CDouble) -> IO b) -> IO b-withCostFunction f g = mask $ \restore -> do-  fp <- mkCostFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n = do-      x <- borrowRealVector xs n-      pure (realToFrac (f x))---- 'fdmRollback' (QuantLib.Method) is the second callback-into-Haskell hook, driving--- @FdmBackwardSolver::rollback@ with a Haskell-defined 'FdmLinearOpComposite' (three callbacks:--- apply/apply_direction/solve_splitting) and an optional step condition -- see CLAUDE.md's--- "coarsen the language-boundary crossing" bullet and 'withCostFunction' above, whose--- mask\/finally\/freeHaskellFunPtr bracket this reuses verbatim, once per callback (four--- independent with-style marshallers, not a single tuple-returning one, so each composes as an--- ordinary c2hs @{#fun#}@ argument exactly like 'withCostFunction' does for 'optimize').------ Every callback's raw C signature is @(in, n, <extra scalar args>, out)@: a caller-owned input--- buffer of length @n@, then whatever scalars the specific virtual takes (direction, the--- splitting parameter @s@, the @(t1,t2)@ time pair QuantLib's own @setTime@ stashes and threads--- through -- never a callback of its own, since it only ever stores two doubles), then a--- caller-owned *output* buffer also of length @n@. 'pokeBoundedFdmResult' is the one new safety--- property beyond 'withCostFunction' (which returns a single scalar, so has no analogous hazard):--- the C++ side's output buffer is exactly @n@ doubles, so a too-long Haskell result list must--- never be poked past that -- 'pokeBoundedFdmResult' truncates (a too-short list numerically--- wrong but safe, implicit-zero-padded).-pokeBoundedFdmResult :: CUInt -> Ptr CDouble -> RealVector -> IO ()-pokeBoundedFdmResult n out result = do-  let expected = fromIntegral n-      copied = min expected (V.length result)-  V.unsafeWith result $ \p -> copyArray out (castPtr p) copied-  when (copied < expected) $ fillBytes (out `plusPtr` (copied * sizeOf (undefined :: CDouble))) 0 ((expected - copied) * sizeOf (undefined :: CDouble))--type FdmApplyFun = Ptr CDouble -> CUInt -> CDouble -> CDouble -> Ptr CDouble -> IO ()-foreign import ccall "wrapper" mkFdmApplyFunPtr :: FdmApplyFun -> IO (FunPtr FdmApplyFun)--- |Wrap a Haskell @(t1,t2) -> grid -> grid'@ function (QuantLib's @FdmLinearOp::apply@\/--- @FdmLinearOpComposite::apply@, no direction argument) as a 'FdmApplyFun' C callback for the--- duration of one 'QuantLib.Method.fdmRollback' call.-withFdmApply :: ((Double, Double) -> RealVector -> RealVector) -> (FunPtr FdmApplyFun -> IO b) -> IO b-withFdmApply f g = mask $ \restore -> do-  fp <- mkFdmApplyFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n t1 t2 out = do-      x <- borrowRealVector xs n-      pokeBoundedFdmResult n out (f (realToFrac t1, realToFrac t2) x)--type FdmApplyDirectionFun = Ptr CDouble -> CUInt -> CUInt -> CDouble -> CDouble -> Ptr CDouble -> IO ()-foreign import ccall "wrapper" mkFdmApplyDirectionFunPtr :: FdmApplyDirectionFun -> IO (FunPtr FdmApplyDirectionFun)--- |Wrap a Haskell @direction -> (t1,t2) -> grid -> grid'@ function--- (@FdmLinearOpComposite::apply_direction@) as an 'FdmApplyDirectionFun' C callback.-withFdmApplyDirection :: (Int -> (Double, Double) -> RealVector -> RealVector) -> (FunPtr FdmApplyDirectionFun -> IO b) -> IO b-withFdmApplyDirection f g = mask $ \restore -> do-  fp <- mkFdmApplyDirectionFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n dir t1 t2 out = do-      x <- borrowRealVector xs n-      pokeBoundedFdmResult n out (f (fromIntegral dir) (realToFrac t1, realToFrac t2) x)--type FdmSolveSplittingFun = Ptr CDouble -> CUInt -> CUInt -> CDouble -> CDouble -> CDouble -> Ptr CDouble -> IO ()-foreign import ccall "wrapper" mkFdmSolveSplittingFunPtr :: FdmSolveSplittingFun -> IO (FunPtr FdmSolveSplittingFun)--- |Wrap a Haskell @direction -> s -> (t1,t2) -> grid -> grid'@ function--- (@FdmLinearOpComposite::solve_splitting@) as an 'FdmSolveSplittingFun' C callback.-withFdmSolveSplitting :: (Int -> Double -> (Double, Double) -> RealVector -> RealVector) -> (FunPtr FdmSolveSplittingFun -> IO b) -> IO b-withFdmSolveSplitting f g = mask $ \restore -> do-  fp <- mkFdmSolveSplittingFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n dir s t1 t2 out = do-      x <- borrowRealVector xs n-      pokeBoundedFdmResult n out (f (fromIntegral dir) (realToFrac s) (realToFrac t1, realToFrac t2) x)--type FdmStepConditionFun = Ptr CDouble -> CUInt -> CDouble -> Ptr CDouble -> IO ()-foreign import ccall "wrapper" mkFdmStepConditionFunPtr :: FdmStepConditionFun -> IO (FunPtr FdmStepConditionFun)--- |Wrap an optional Haskell @t -> grid -> grid'@ early-exercise\/barrier-style step condition--- (@StepCondition\<Array\>::applyTo@) as an 'FdmStepConditionFun' C callback, or a null 'FunPtr'--- when there is no step condition -- mirrors the existing @withMaybeX@ convention (e.g.--- 'withMaybeCurrency' above) of passing a null pointer for 'Nothing' rather than a separate--- present\/absent flag.-withMaybeFdmStepCondition :: Maybe (Double -> RealVector -> RealVector) -> (FunPtr FdmStepConditionFun -> IO b) -> IO b-withMaybeFdmStepCondition Nothing g = g nullFunPtr-withMaybeFdmStepCondition (Just f) g = mask $ \restore -> do-  fp <- mkFdmStepConditionFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n t out = do-      x <- borrowRealVector xs n-      pokeBoundedFdmResult n out (f (realToFrac t) x)+type Callback = Callback.Callback -type FdmInnerValueFun = Ptr CDouble -> CUInt -> CDouble -> IO CDouble-foreign import ccall "wrapper" mkFdmInnerValueFunPtr :: FdmInnerValueFun -> IO (FunPtr FdmInnerValueFun)--- |Wrap a Haskell @t -> nodeLocation -> value@ function as an 'FdmInnerValueFun' C callback, for--- either of @FdmInnerValueCalculator::innerValue@\/@avgInnerValue@ -- the one hook in this file--- that is a genuine, uncoarsened per-grid-node callback rather than a whole-grid one (see--- 'QuantLib.Method.fdmSolve' and its accompanying haddock for why no batched shape exists here,--- matching QuantLib-SWIG's own @FdmInnerValueCalculatorDelegate@). Reuses the same--- mask\/finally\/freeHaskellFunPtr bracket as 'withCostFunction' above; unlike the--- 'FdmApplyFun'-family callbacks, this one returns a single scalar so has no--- 'pokeBoundedFdmResult'-style output-length hazard.-withFdmInnerValue :: (Double -> [Double] -> Double) -> (FunPtr FdmInnerValueFun -> IO b) -> IO b-withFdmInnerValue f g = mask $ \restore -> do-  fp <- mkFdmInnerValueFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call locPtr n t = do-      loc <- peekArray (fromIntegral n) locPtr-      pure (realToFrac (f (realToFrac t) (map realToFrac loc)))+withCallbackPtr :: Callback -> (Ptr () -> IO b) -> IO b+withCallbackPtr = Callback.withCallbackPtr -type FdmGridMappingFun = CDouble -> IO CDouble-foreign import ccall "wrapper" mkFdmGridMappingFunPtr :: FdmGridMappingFun -> IO (FunPtr FdmGridMappingFun)--- |Wrap a Haskell @Double -> Double@ function as an 'FdmGridMappingFun' C callback, for--- @FdmCellAveragingInnerValue@'s optional @gridMapping@ (@QuantLib.Method.withCustomCellAveragingInnerValue@)--- -- another genuine per-node callback (invoked from inside @avgInnerValueCalc@'s Simpson--- integration and from every @innerValue@ call), same reasoning as 'withFdmInnerValue' above.-withFdmGridMapping :: (Double -> Double) -> (FunPtr FdmGridMappingFun -> IO b) -> IO b-withFdmGridMapping f g = mask $ \restore -> do-  fp <- mkFdmGridMappingFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp+withCostFunction :: (RealVector -> Double) -> (Ptr () -> IO b) -> IO b+withCostFunction f use = Callback.withScalarCallback call (`withCallbackPtr` use)   where-    call x = pure (realToFrac (f (realToFrac x)))+    call args = f <$> borrowRealVector (Callback.callbackInput args) (fromIntegral (Callback.callbackSize args)) -type PayoffFun = CDouble -> IO CDouble-foreign import ccall "wrapper" mkPayoffFunPtr :: PayoffFun -> IO (FunPtr PayoffFun)--- |Wrap a Haskell @price -> value@ function as a 'PayoffFun' C callback, for--- @QuantLib.Internal.Common.withCustomPayoff@. Another genuine, uncoarsened callback: QuantLib's--- @Payoff::operator()@ takes one scalar price everywhere it is called -- per tree node in--- @DiscretizedVanillaOption@, inside @FdmCellAveragingInnerValue@'s per-cell Simpson integral, per--- path per exercise index in @AmericanPathPricer@ -- and nothing upstream batches an @Array@, so--- there is no whole-vector shape to coarsen to (same situation as 'withFdmInnerValue' above).-withPayoffFun :: (Double -> Double) -> (FunPtr PayoffFun -> IO b) -> IO b-withPayoffFun f g = mask $ \restore -> do-  fp <- mkPayoffFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call x = pure (realToFrac (f (realToFrac x)))+withFdmInnerValue :: (Double -> [Double] -> Double) -> (Callback -> IO b) -> IO b+withFdmInnerValue f = Callback.withScalarCallback $ \args -> do+  loc <- peekArray (Callback.callbackSize args) (Callback.callbackInput args)+  pure (f (Callback.callbackTime1 args) (map realToFrac loc)) -type BasketAccumulateFun = Ptr CDouble -> CUInt -> IO CDouble-foreign import ccall "wrapper" mkBasketAccumulateFunPtr :: BasketAccumulateFun -> IO (FunPtr BasketAccumulateFun)--- |Wrap a Haskell @underlyings -> accumulated@ function as a 'BasketAccumulateFun' C callback, for--- @QuantLib.Internal.Common.withCustomBasketPayoff@. Unlike 'withPayoffFun' this one /is/ already--- coarsened by upstream's own interface: @BasketPayoff::accumulate@ takes the whole underlying-state--- @Array@ per call, not one component at a time.-withBasketAccumulateFun :: ([Double] -> Double) -> (FunPtr BasketAccumulateFun -> IO b) -> IO b-withBasketAccumulateFun f g = mask $ \restore -> do-  fp <- mkBasketAccumulateFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call xs n = do-      x <- peekArray (fromIntegral n) xs-      pure (realToFrac (f (map realToFrac x)))+withFdmGridMapping :: (Double -> Double) -> (Callback -> IO b) -> IO b+withFdmGridMapping = withPayoffFun --- |The unary callback a Haskell-defined @DerivedQuote@ crosses on, for--- @QuantLib.Quote.withDerivedQuote@. Same C signature as 'PayoffFun', so it reuses--- 'withPayoffFun' rather than duplicating the @wrapper@ import; the alias exists so the quote--- bindings read in their own terms.-type QuoteUnaryFun = PayoffFun+withPayoffFun :: (Double -> Double) -> (Callback -> IO b) -> IO b+withPayoffFun f = Callback.withScalarCallback (pure . f . Callback.callbackScalar) --- |As 'QuoteUnaryFun', but for @MultiCompositeQuote@ (@QuantLib.Quote.withMultiCompositeQuote@):--- same C signature as 'BasketAccumulateFun', and coarsened the same way -- upstream hands the--- whole element vector over per evaluation.-type QuoteArrayFun = BasketAccumulateFun+withBasketAccumulateFun :: ([Double] -> Double) -> (Callback -> IO b) -> IO b+withBasketAccumulateFun f = Callback.withScalarCallback $ \args -> do+  xs <- peekArray (Callback.callbackSize args) (Callback.callbackInput args)+  pure (f (map realToFrac xs)) -type QuoteBinaryFun = CDouble -> CDouble -> IO CDouble-foreign import ccall "wrapper" mkQuoteBinaryFunPtr :: QuoteBinaryFun -> IO (FunPtr QuoteBinaryFun)--- |Wrap a Haskell @value1 -> value2 -> value@ function as a 'QuoteBinaryFun' C callback, for--- @QuantLib.Quote.withCompositeQuote@. The genuinely new arity of the three: @CompositeQuote@'s--- @BinaryFunction@ takes both element values at once, so there is nothing to coarsen -- one--- crossing per @Quote::value()@ evaluation is already the whole computation.-withQuoteBinaryFun :: (Double -> Double -> Double) -> (FunPtr QuoteBinaryFun -> IO b) -> IO b-withQuoteBinaryFun f g = mask $ \restore -> do-  fp <- mkQuoteBinaryFunPtr call-  restore (g fp) `finally` freeHaskellFunPtr fp-  where-    call x y = pure (realToFrac (f (realToFrac x) (realToFrac y)))+withQuoteBinaryFun :: (Double -> Double -> Double) -> (Callback -> IO b) -> IO b+withQuoteBinaryFun f = Callback.withScalarCallback $ \args ->+  pure (f (Callback.callbackScalar args) (Callback.callbackTime1 args))  data CCalendar newtype Calendar = Calendar {getCCalendar :: Standalone CCalendar}@@ -246,6 +77,9 @@ withCalendar :: Calendar -> (Ptr CCalendar -> IO b) -> IO b withCalendar = withStandalone . getCCalendar foreign import ccall safe "ql.h qlCalendarName" qlCalendarName :: Ptr CCalendar -> IO CString+withMaybeCalendar :: Maybe Calendar -> (Ptr CCalendar -> IO r) -> IO r+withMaybeCalendar x f = maybe (f nullPtr) (`withCalendar` f) x+ instance Show Calendar where show x = showStandalone qlCalendarName (getCCalendar x) -- Equality by name, here and for the Currency/Region/DayCounter/Schedule instances -- below. This is deliberate: it is how QuantLib itself compares these types.@@ -381,6 +215,9 @@ peekDayCounter = DayCounter <.> peekStandalone withDayCounter :: DayCounter -> (Ptr CDayCounter -> IO b) -> IO b withDayCounter = withStandalone . getCDayCounter++withMaybeDayCounter :: Maybe DayCounter -> (Ptr CDayCounter -> IO r) -> IO r+withMaybeDayCounter x f = maybe (f nullPtr) (`withDayCounter` f) x foreign import ccall safe "ql.h qlDayCounterName" qlDayCounterName :: Ptr CDayCounter -> IO CString instance Show DayCounter where show x = showStandalone qlDayCounterName (getCDayCounter x) instance Eq DayCounter where x == y = show x == show y@@ -396,7 +233,7 @@ foreign import ccall safe "ql.h qlScheduleDates" qlScheduleDates :: Ptr CSchedule -> Ptr CUInt -> Ptr (Ptr CInt) -> IO () showSchedule :: Schedule -> String showSchedule x = unsafePerformIO $ withSchedule x $ \p ->-  show <$> preArray (\(cp, ap) -> qlScheduleDates p cp ap >> peekDayArray cp ap)+  show <$> preIntArray (\(cp, ap) -> qlScheduleDates p cp ap >> peekDayArray cp ap) {-# NOINLINE showSchedule #-}  instance Show Schedule where@@ -544,6 +381,21 @@ withNoArbSabrInterpolatedSmileSection :: NoArbSabrInterpolatedSmileSection -> (Ptr CNoArbSabrInterpolatedSmileSection -> IO b) -> IO b withNoArbSabrInterpolatedSmileSection = withStandalone . getCNoArbSabrInterpolatedSmileSection +-- |a dedicated leaf, same reasoning and 'SmileSection' escape hatch as 'CSabrInterpolatedSmileSection'+-- above -- see 'QuantLib.TermStructure.Volatility.zabrInterpolatedSmileSection'\/+-- 'QuantLib.TermStructure.Volatility.zabrInterpolatedAsSmileSection'. Wraps a+-- @ZabrInterpolatedSmileSectionHandle@ on the C++ side, not the templated+-- @ZabrInterpolatedSmileSection\<Evaluation\>@ itself directly -- see the handle's own comment+-- in @cbits\/qlTermStructureAux.h@ for why.+data CZabrInterpolatedSmileSection+newtype ZabrInterpolatedSmileSection = ZabrInterpolatedSmileSection {getCZabrInterpolatedSmileSection :: Standalone CZabrInterpolatedSmileSection}+foreign import ccall unsafe "ql.h &qlFreeZabrInterpolatedSmileSection" qlFreeZabrInterpolatedSmileSection :: FinalizerPtr CZabrInterpolatedSmileSection+instance Finalizable CZabrInterpolatedSmileSection where finalize = qlFreeZabrInterpolatedSmileSection+peekZabrInterpolatedSmileSection :: Ptr CZabrInterpolatedSmileSection -> IO ZabrInterpolatedSmileSection+peekZabrInterpolatedSmileSection = ZabrInterpolatedSmileSection <.> peekStandalone+withZabrInterpolatedSmileSection :: ZabrInterpolatedSmileSection -> (Ptr CZabrInterpolatedSmileSection -> IO b) -> IO b+withZabrInterpolatedSmileSection = withStandalone . getCZabrInterpolatedSmileSection+ -- |a dedicated leaf, not a downcast target: 'QuantLib.TermStructure.Volatility.optionletStripperWithAtm' -- fuses construction of an 'OptionletStripper1' underneath (never exposed to Haskell, mirroring -- 'QuantLib.TermStructure.Volatility.optionletStripper') and stores the resulting@@ -560,15 +412,34 @@ withOptionletStripper2 :: OptionletStripper2 -> (Ptr COptionletStripper2 -> IO b) -> IO b withOptionletStripper2 = withStandalone . getCOptionletStripper2 -data CPricingEngine-newtype PricingEngine = PricingEngine {getCPricingEngine :: Standalone CPricingEngine}-foreign import ccall unsafe "ql.h &qlFreePricingEngine" qlFreePricingEngine :: FinalizerPtr CPricingEngine-instance Finalizable CPricingEngine where finalize = qlFreePricingEngine-peekPricingEngine :: Ptr CPricingEngine -> IO PricingEngine-peekPricingEngine = PricingEngine <.> peekStandalone-withPricingEngine :: PricingEngine -> (Ptr CPricingEngine -> IO b) -> IO b-withPricingEngine = withStandalone . getCPricingEngine+-- |Pricing engine hierarchy: PricingEngine -> AnalyticRoughHestonEngine.+data CPricingEngine'+newtype GenPricingEngine pe = GenPricingEngine {getPricingEngine :: GenForeignPtr pe CPricingEngine'}+type CPricingEngine = ForeignPtr CPricingEngine'+type PricingEngine = GenPricingEngine CPricingEngine+foreign import ccall unsafe "ql.h &qlFreePricingEngine" qlFreePricingEngine :: FinalizerPtr CPricingEngine'+instance Finalizable CPricingEngine' where finalize = qlFreePricingEngine+peekPricingEngine :: Ptr CPricingEngine' -> IO PricingEngine+peekPricingEngine = GenPricingEngine <.> newCastForeignPtr+withPricingEngine :: GenPricingEngine pe -> (Ptr CPricingEngine' -> IO b) -> IO b+withPricingEngine = withGenForeignPtr . getPricingEngine+asPricingEngine :: GenPricingEngine pe -> IO PricingEngine+asPricingEngine = transferGenForeignPtr (pure . GenPricingEngine) . getPricingEngine +data CAnalyticRoughHestonEngine'+type CAnalyticRoughHestonEngine = ForeignPtr CAnalyticRoughHestonEngine'+-- |A 'PricingEngine' with its concrete native interface preserved.+type AnalyticRoughHestonEngine = GenPricingEngine CAnalyticRoughHestonEngine+foreign import ccall unsafe "ql.h &qlFreeAnalyticRoughHestonEngine" qlFreeAnalyticRoughHestonEngine :: FinalizerPtr CAnalyticRoughHestonEngine'+instance Finalizable CAnalyticRoughHestonEngine' where finalize = qlFreeAnalyticRoughHestonEngine+foreign import ccall "ql.h qlAnalyticRoughHestonEngineAsPricingEngine" qlAnalyticRoughHestonEngineAsPricingEngine :: Ptr CAnalyticRoughHestonEngine' -> IO (Ptr CPricingEngine')+instance Upcastable CAnalyticRoughHestonEngine' where {type Base CAnalyticRoughHestonEngine' = CPricingEngine'; upcast = qlAnalyticRoughHestonEngineAsPricingEngine}+peekAnalyticRoughHestonEngine :: Ptr CAnalyticRoughHestonEngine' -> IO AnalyticRoughHestonEngine+peekAnalyticRoughHestonEngine = GenPricingEngine <.> newGenForeignPtr+withAnalyticRoughHestonEngine :: AnalyticRoughHestonEngine -> (Ptr CAnalyticRoughHestonEngine' -> IO b) -> IO b+withAnalyticRoughHestonEngine = withForeignPtr . ptr . getPricingEngine++ data CBlackDeltaCalculator newtype BlackDeltaCalculator = BlackDeltaCalculator {getCBlackDeltaCalculator :: Standalone CBlackDeltaCalculator} foreign import ccall unsafe "ql.h &qlFreeBlackDeltaCalculator" qlFreeBlackDeltaCalculator :: FinalizerPtr CBlackDeltaCalculator@@ -578,6 +449,12 @@ withBlackDeltaCalculator :: BlackDeltaCalculator -> (Ptr CBlackDeltaCalculator -> IO b) -> IO b withBlackDeltaCalculator = withStandalone . getCBlackDeltaCalculator +-- Standalone FX projection interface.+data CFxResetPricer+type FxResetPricer = Standalone CFxResetPricer+foreign import ccall unsafe "ql.h &qlFreeFxResetPricer" qlFreeFxResetPricer :: FinalizerPtr CFxResetPricer+instance Finalizable CFxResetPricer where finalize = qlFreeFxResetPricer+ -- Generic floating-rate coupon pricer; CMS pricers retain a concrete subtype. data CFloatingRateCouponPricer' @@ -590,14 +467,14 @@ foreign import ccall unsafe "ql.h &qlFreeFloatingCouponPricer" qlFreeFloatingRateCouponPricer :: FinalizerPtr CFloatingRateCouponPricer' instance Finalizable CFloatingRateCouponPricer' where finalize = qlFreeFloatingRateCouponPricer asFloatingRateCouponPricer :: GenFloatingRateCouponPricer frcp -> IO FloatingRateCouponPricer-asFloatingRateCouponPricer = transferGenForeignPtr peekFloatingRateCouponPricer . getFloatingRateCouponPricer+asFloatingRateCouponPricer = transferGenForeignPtr (pure . GenFloatingRateCouponPricer) . getFloatingRateCouponPricer peekFloatingRateCouponPricer :: Ptr CFloatingRateCouponPricer' -> IO FloatingRateCouponPricer peekFloatingRateCouponPricer = GenFloatingRateCouponPricer <.> newCastForeignPtr withFloatingRateCouponPricer :: GenFloatingRateCouponPricer frcp -> (Ptr CFloatingRateCouponPricer' -> IO b) -> IO b withFloatingRateCouponPricer = withGenForeignPtr . getFloatingRateCouponPricer withFloatingRateCouponPricerArray :: [GenFloatingRateCouponPricer frcp] -> ((CUInt, Ptr (Ptr CFloatingRateCouponPricer')) -> IO b) -> IO b withFloatingRateCouponPricerArray = withGenArray withFloatingRateCouponPricer-withMaybeFloatingRateCouponPricer :: Maybe FloatingRateCouponPricer -> (Ptr CFloatingRateCouponPricer' -> IO b) -> IO b+withMaybeFloatingRateCouponPricer :: Maybe (GenFloatingRateCouponPricer frcp) -> (Ptr CFloatingRateCouponPricer' -> IO b) -> IO b withMaybeFloatingRateCouponPricer = maybe ($ nullPtr) withFloatingRateCouponPricer  -- |CMS coupon-pricer subtype required by CMS consumers.@@ -625,7 +502,7 @@ foreign import ccall "ql.h qlFloatingRateCouponAsCoupon" qlFloatingRateCouponAsCoupon :: Ptr CFloatingRateCoupon' -> IO (Ptr CCoupon') instance Upcastable CFloatingRateCoupon' where {type Base CFloatingRateCoupon' = CCoupon'; upcast = qlFloatingRateCouponAsCoupon} asFloatingRateCoupon :: GenFloatingRateCoupon frc -> IO FloatingRateCoupon-asFloatingRateCoupon = transferGenForeignPtr peekFloatingRateCoupon . peel . peel . getCashFlow+asFloatingRateCoupon = transferGenForeignPtr newGenFloatingRateCoupon . peel . peel . getCashFlow peekFloatingRateCoupon :: Ptr CFloatingRateCoupon' -> IO FloatingRateCoupon peekFloatingRateCoupon = newCastForeignPtr >=> newGenFloatingRateCoupon newGenFloatingRateCoupon :: GenForeignPtr frc CFloatingRateCoupon' -> IO (GenFloatingRateCoupon frc)@@ -660,6 +537,19 @@ withIborCoupon :: IborCoupon -> (Ptr CIborCoupon' -> IO b) -> IO b withIborCoupon = withForeignPtr . ptr . peel . peel . getCashFlow +data CFxResetCoupon'+type CFxResetCoupon = ForeignPtr CFxResetCoupon'+-- |A 'FloatingRateCoupon' with its concrete native interface preserved.+type FxResetCoupon = GenFloatingRateCoupon CFxResetCoupon+foreign import ccall unsafe "ql.h &qlFreeFxResetCoupon" qlFreeFxResetCoupon :: FinalizerPtr CFxResetCoupon'+instance Finalizable CFxResetCoupon' where finalize = qlFreeFxResetCoupon+foreign import ccall "ql.h qlFxResetCouponAsFloatingRateCoupon" qlFxResetCouponAsFloatingRateCoupon :: Ptr CFxResetCoupon' -> IO (Ptr CFloatingRateCoupon')+instance Upcastable CFxResetCoupon' where {type Base CFxResetCoupon' = CFloatingRateCoupon'; upcast = qlFxResetCouponAsFloatingRateCoupon}+peekFxResetCoupon :: Ptr CFxResetCoupon' -> IO FxResetCoupon+peekFxResetCoupon = newGenForeignPtr >=> newGenFloatingRateCoupon+withFxResetCoupon :: FxResetCoupon -> (Ptr CFxResetCoupon' -> IO b) -> IO b+withFxResetCoupon = withForeignPtr . ptr . peel . peel . getCashFlow+ data COvernightIndexedCoupon' type COvernightIndexedCoupon = ForeignPtr COvernightIndexedCoupon' -- |A 'FloatingRateCoupon'; see the hierarchy under t'GenCashFlow'.@@ -1016,17 +906,27 @@ data GenForeignPtr a b = GenForeignPtr {   ptr :: !a   , _access :: !(forall r. a -> (Ptr b -> IO r) -> IO r)-  , _mayFree :: !(Maybe (Ptr b -> IO ())) -- `free' after upcast is needed+  , _ownership :: !(Either (a -> ForeignPtr b) (Ptr b -> IO ())) }  freeUpcast :: Finalizable b => Ptr b -> IO () freeUpcast = callFinalizer finalize +-- Temporary ADT handles are scoped to their consumer; constructors copy shared ownership.+withConstructed :: Finalizable a => IO (Ptr a) -> (Ptr a -> IO b) -> IO b+withConstructed make = bracket make freeUpcast++withUpcast :: (Upcastable a, Finalizable (Base a)) => Ptr a -> (Ptr (Base a) -> IO b) -> IO b+withUpcast p = withConstructed (upcast p)++withConstructedUpcast :: (Finalizable a, Upcastable a, Finalizable (Base a)) => IO (Ptr a) -> (Ptr (Base a) -> IO b) -> IO b+withConstructedUpcast make f = withConstructed make (`withUpcast` f)+ newtype AnyOf b a = AnyOf { getAnyOf :: GenForeignPtr a b } newAnyOf :: (Upcastable b, Finalizable (Base b)) => GenForeignPtr a b -> GenForeignPtr (AnyOf b a) (Base b) newAnyOf x = GenForeignPtr (AnyOf x)   (\(AnyOf i) f -> withGenForeignPtr i (upcast >=> f))-  (Just freeUpcast)+  (Right freeUpcast)  class Upcastable a where   type Base a@@ -1035,12 +935,12 @@ newGenForeignPtr :: (Finalizable a, Upcastable a, Finalizable (Base a)) => Ptr a -> IO (GenForeignPtr (ForeignPtr a) (Base a)) newGenForeignPtr x = do   fp <- newForeignPtr finalize x-  pure $ GenForeignPtr fp (\a f -> withForeignPtr a (upcast >=> f)) (Just freeUpcast)+  pure $ GenForeignPtr fp (\a f -> withForeignPtr a (upcast >=> f)) (Right freeUpcast)  newCastForeignPtr :: Finalizable a => Ptr a -> IO (GenForeignPtr (ForeignPtr a) a) newCastForeignPtr x = do   fp <- newForeignPtr finalize x-  pure $ GenForeignPtr fp withForeignPtr Nothing+  pure $ ownedGenForeignPtr fp  -- `access' performs the upcast, which allocates a fresh handle that `mfree' must release, so -- acquiring it and installing the handler have to be atomic -- `mask' covers the upcast@@ -1049,13 +949,21 @@ -- allocates internally. Nesting is fine: an inner level's `restore' only wraps the -- continuation that contains the outer `restore', so `f' still runs unmasked. withGenForeignPtr :: GenForeignPtr a b -> (Ptr b -> IO r) -> IO r-withGenForeignPtr (GenForeignPtr p access Nothing) f = access p f-withGenForeignPtr (GenForeignPtr p access (Just free)) f =+withGenForeignPtr (GenForeignPtr p access (Left _)) f = access p f+withGenForeignPtr (GenForeignPtr p access (Right free)) f =   mask $ \restore -> access p $ \bp -> restore (f bp) `finally` free bp -transferGenForeignPtr :: (Ptr b -> IO r) -> GenForeignPtr a b -> IO r-transferGenForeignPtr f (GenForeignPtr p access _) = access p f+ownedGenForeignPtr :: ForeignPtr b -> GenForeignPtr (ForeignPtr b) b+ownedGenForeignPtr fp = GenForeignPtr fp withForeignPtr (Left id) +-- Identity conversions share their ForeignPtr; only fresh upcast handles acquire a finalizer.+transferGenForeignPtr :: Finalizable b => (GenForeignPtr (ForeignPtr b) b -> IO r) -> GenForeignPtr a b -> IO r+transferGenForeignPtr f (GenForeignPtr p access ownership) = case ownership of+  Left owner -> f (ownedGenForeignPtr (owner p))+  Right free -> mask $ \restore -> do+    fp <- access p $ \bp -> newForeignPtr finalize bp `onException` free bp+    restore (f (ownedGenForeignPtr fp))+ withGenArray :: (a -> (Ptr c -> IO r) -> IO r) -> [a] -> ((CUInt, Ptr (Ptr c)) -> IO r) -> IO r withGenArray m x f = withMany m x (`withArray` (\p -> f (fromIntegral $ length x, p))) @@ -1074,12 +982,12 @@ -- producer of a fresh 'QuantLib.Commodity.PricingPeriods' list -- every constructor instead -- *consumes* one via 'withCommodityTypeArray'). peekCommodityTypeArray :: Ptr CUInt -> Ptr (Ptr (Ptr CCommodityType)) -> IO [CommodityType]-peekCommodityTypeArray = peekPtrArray peekCommodityType+peekCommodityTypeArray = peekPtrArray freeUpcast peekCommodityType  withUnitOfMeasureArray :: [UnitOfMeasure] -> ((CUInt, Ptr (Ptr CUnitOfMeasure)) -> IO b) -> IO b withUnitOfMeasureArray = withGenArray withUnitOfMeasure peekUnitOfMeasureArray :: Ptr CUInt -> Ptr (Ptr (Ptr CUnitOfMeasure)) -> IO [UnitOfMeasure]-peekUnitOfMeasureArray = peekPtrArray peekUnitOfMeasure+peekUnitOfMeasureArray = peekPtrArray freeUpcast peekUnitOfMeasure  -- |A nullable-per-entry array of 'UnitOfMeasure's -- @SecondaryCosts@' per-entry unit of measure, -- present only for its @CommodityUnitCost@ alternative (null for its @Money@ alternative).@@ -1090,7 +998,7 @@ withCurrencyArray :: [Currency] -> ((CUInt, Ptr (Ptr CCurrency)) -> IO b) -> IO b withCurrencyArray = withGenArray withCurrency peekCurrencyArray :: Ptr CUInt -> Ptr (Ptr (Ptr CCurrency)) -> IO [Currency]-peekCurrencyArray = peekPtrArray peekCurrency+peekCurrencyArray = peekPtrArray freeUpcast peekCurrency  -- |The root of the hierarchy shown under t'GenQuote'. type Quote = GenQuote CQuote@@ -1139,7 +1047,7 @@ -- Haskell does not allow function arguments like [forall q.GenQuote q] -- let's at least provide a way to convert all quote classes to the most generic one asQuote :: GenQuote q -> IO Quote-asQuote = transferGenForeignPtr peekQuote . getQuote+asQuote = transferGenForeignPtr (pure . GenQuote) . getQuote peekQuote :: Ptr CQuote' -> IO Quote peekQuote = GenQuote <.> newCastForeignPtr withQuote :: GenQuote q -> (Ptr CQuote' -> IO b) -> IO b@@ -1249,6 +1157,7 @@ -- >       DigitalCoupon -- >         DigitalCmsCoupon -- >         DigitalCmsSpreadCoupon+-- >       FxResetCoupon -- >       IborCoupon -- >       MultipleResetsCoupon -- >       OvernightIndexedCoupon@@ -1256,6 +1165,7 @@ -- >       StrippedCappedFlooredCoupon -- >     CPICoupon -- >     YoYInflationCoupon+-- >   FxResetNotionalExchange -- >   IndexedCashFlow -- >     CPICashFlow -- >     EquityCashFlow@@ -1268,7 +1178,7 @@ foreign import ccall unsafe "ql.h &qlFreeCashFlow" qlFreeCashFlow :: FinalizerPtr CCashFlow' instance Finalizable CCashFlow' where finalize = qlFreeCashFlow asCashFlow :: GenCashFlow cf -> IO CashFlow-asCashFlow = transferGenForeignPtr peekCashFlow . getCashFlow+asCashFlow = transferGenForeignPtr (pure . GenCashFlow) . getCashFlow peekCashFlow :: Ptr CCashFlow' -> IO CashFlow peekCashFlow = GenCashFlow <.> newCastForeignPtr withCashFlow :: GenCashFlow cf -> (Ptr CCashFlow' -> IO b) -> IO b@@ -1289,7 +1199,7 @@ foreign import ccall "ql.h qlCouponAsCashFlow" qlCouponAsCashFlow :: Ptr CCoupon' -> IO (Ptr CCashFlow') instance Upcastable CCoupon' where {type Base CCoupon' = CCashFlow'; upcast = qlCouponAsCashFlow} asCoupon :: GenCoupon c -> IO Coupon-asCoupon = transferGenForeignPtr peekCoupon . peel . getCashFlow+asCoupon = transferGenForeignPtr newGenCoupon . peel . getCashFlow peekCoupon :: Ptr CCoupon' -> IO Coupon peekCoupon = newCastForeignPtr >=> newGenCoupon newGenCoupon :: GenForeignPtr c CCoupon' -> IO (GenCoupon c)@@ -1297,7 +1207,7 @@ withCoupon :: GenCoupon c -> (Ptr CCoupon' -> IO b) -> IO b withCoupon = withGenForeignPtr . peel . getCashFlow peekCouponArray :: Ptr CUInt -> Ptr (Ptr (Ptr CCoupon')) -> IO [Coupon]-peekCouponArray = peekPtrArray peekCoupon+peekCouponArray = peekPtrArray freeUpcast peekCoupon  data CFixedRateCoupon' type CFixedRateCoupon = ForeignPtr CFixedRateCoupon'@@ -1312,6 +1222,19 @@ withFixedRateCoupon :: FixedRateCoupon -> (Ptr CFixedRateCoupon' -> IO b) -> IO b withFixedRateCoupon = withForeignPtr . ptr . peel . getCashFlow +data CFxResetNotionalExchange'+type CFxResetNotionalExchange = ForeignPtr CFxResetNotionalExchange'+-- |A 'CashFlow' with its concrete native interface preserved.+type FxResetNotionalExchange = GenCashFlow CFxResetNotionalExchange+foreign import ccall unsafe "ql.h &qlFreeFxResetNotionalExchange" qlFreeFxResetNotionalExchange :: FinalizerPtr CFxResetNotionalExchange'+instance Finalizable CFxResetNotionalExchange' where finalize = qlFreeFxResetNotionalExchange+foreign import ccall "ql.h qlFxResetNotionalExchangeAsCashFlow" qlFxResetNotionalExchangeAsCashFlow :: Ptr CFxResetNotionalExchange' -> IO (Ptr CCashFlow')+instance Upcastable CFxResetNotionalExchange' where {type Base CFxResetNotionalExchange' = CCashFlow'; upcast = qlFxResetNotionalExchangeAsCashFlow}+peekFxResetNotionalExchange :: Ptr CFxResetNotionalExchange' -> IO FxResetNotionalExchange+peekFxResetNotionalExchange = GenCashFlow <.> newGenForeignPtr+withFxResetNotionalExchange :: FxResetNotionalExchange -> (Ptr CFxResetNotionalExchange' -> IO b) -> IO b+withFxResetNotionalExchange = withForeignPtr . ptr . getCashFlow+ data CIndexedCashFlow' -- |An 'IndexedCashFlow' or one of its leaves; see the hierarchy under t'GenCashFlow'. type GenIndexedCashFlow icf = GenCashFlow (AnyOf CIndexedCashFlow' icf)@@ -1384,7 +1307,7 @@ foreign import ccall "ql.h qlCouponLegAsLeg" qlCouponLegAsLeg :: Ptr CCouponLeg' -> IO (Ptr CLeg') instance Upcastable CCouponLeg' where {type Base CCouponLeg' = CLeg'; upcast = qlCouponLegAsLeg} asLeg :: GenLeg l -> IO Leg-asLeg = transferGenForeignPtr peekLeg . getLeg+asLeg = transferGenForeignPtr (pure . GenLeg) . getLeg peekLeg :: Ptr CLeg' -> IO Leg peekLeg = GenLeg <.> newCastForeignPtr withLeg :: GenLeg l -> (Ptr CLeg' -> IO b) -> IO b@@ -1410,7 +1333,7 @@ foreign import ccall unsafe "ql.h &qlFreeRateHelper" qlFreeRateHelper :: FinalizerPtr CRateHelper' instance Finalizable CRateHelper' where finalize = qlFreeRateHelper asRateHelper :: GenRateHelper rh -> IO RateHelper-asRateHelper = transferGenForeignPtr peekRateHelper . getRateHelper+asRateHelper = transferGenForeignPtr (pure . GenRateHelper) . getRateHelper peekRateHelper :: Ptr CRateHelper' -> IO RateHelper peekRateHelper = GenRateHelper <.> newCastForeignPtr withRateHelper :: GenRateHelper rh -> (Ptr CRateHelper' -> IO b) -> IO b@@ -1501,7 +1424,7 @@ foreign import ccall "ql.h qlBlackCalibrationHelperAsCalibrationHelper" qlBlackCalibrationHelperAsCalibrationHelper :: Ptr CBlackCalibrationHelper' -> IO (Ptr CCalibrationHelper') instance Upcastable CBlackCalibrationHelper' where {type Base CBlackCalibrationHelper' = CCalibrationHelper'; upcast = qlBlackCalibrationHelperAsCalibrationHelper} asCalibrationHelper :: GenCalibrationHelper ch -> IO CalibrationHelper-asCalibrationHelper = transferGenForeignPtr peekCalibrationHelper . getCalibrationHelper+asCalibrationHelper = transferGenForeignPtr (pure . GenCalibrationHelper) . getCalibrationHelper peekCalibrationHelper :: Ptr CCalibrationHelper' -> IO CalibrationHelper peekCalibrationHelper = GenCalibrationHelper <.> newCastForeignPtr withCalibrationHelper :: GenCalibrationHelper ch -> (Ptr CCalibrationHelper' -> IO b) -> IO b@@ -1511,7 +1434,7 @@ withGenCalibrationHelper :: GenBlackCalibrationHelper (ForeignPtr ch) -> (Ptr ch -> IO b) -> IO b withGenCalibrationHelper = withForeignPtr . ptr . peel . getCalibrationHelper asBlackCalibrationHelper :: GenBlackCalibrationHelper bch -> IO BlackCalibrationHelper-asBlackCalibrationHelper = transferGenForeignPtr peekBlackCalibrationHelper . peel . getCalibrationHelper+asBlackCalibrationHelper = transferGenForeignPtr newGenBlackCalibrationHelper . peel . getCalibrationHelper peekBlackCalibrationHelper :: Ptr CBlackCalibrationHelper' -> IO BlackCalibrationHelper peekBlackCalibrationHelper = newCastForeignPtr >=> newGenBlackCalibrationHelper withBlackCalibrationHelper :: GenBlackCalibrationHelper bch -> (Ptr CBlackCalibrationHelper' -> IO b) -> IO b@@ -1523,7 +1446,7 @@ withBlackCalibrationHelperArray :: [GenBlackCalibrationHelper bch] -> ((CUInt, Ptr (Ptr CBlackCalibrationHelper')) -> IO b) -> IO b withBlackCalibrationHelperArray = withGenArray withBlackCalibrationHelper peekBlackCalibrationHelperArray :: Ptr CUInt -> Ptr (Ptr (Ptr CBlackCalibrationHelper')) -> IO [BlackCalibrationHelper]-peekBlackCalibrationHelperArray = peekPtrArray peekBlackCalibrationHelper+peekBlackCalibrationHelperArray = peekPtrArray freeUpcast peekBlackCalibrationHelper  -- SwaptionHelper is only reachable as this concrete type when hasquant itself constructs it -- (Model.chs's swaptionHelper/swaptionHelperFromDate/swaptionHelperFromDates); a basket returned@@ -1562,7 +1485,7 @@ foreign import ccall "ql.h qlBlackScholesCalculatorAsBlackCalculator" qlBlackScholesCalculatorAsBlackCalculator :: Ptr CBlackScholesCalculator' -> IO (Ptr CBlackCalculator') instance Upcastable CBlackScholesCalculator' where {type Base CBlackScholesCalculator' = CBlackCalculator'; upcast = qlBlackScholesCalculatorAsBlackCalculator} asBlackCalculator :: GenBlackCalculator bc -> IO BlackCalculator-asBlackCalculator = transferGenForeignPtr peekBlackCalculator . getBlackCalculator+asBlackCalculator = transferGenForeignPtr (pure . GenBlackCalculator) . getBlackCalculator peekBlackCalculator :: Ptr CBlackCalculator' -> IO BlackCalculator peekBlackCalculator = GenBlackCalculator <.> newCastForeignPtr withBlackCalculator :: GenBlackCalculator bc -> (Ptr CBlackCalculator' -> IO b) -> IO b@@ -1617,7 +1540,7 @@  foreign import ccall safe "ql.h qlIndexName" qlIndexName :: Ptr CIndex' -> IO CString showIndex :: GenIndex idx -> String-showIndex = unsafePerformIO . (`withIndex` (qlIndexName >=> peekDynString))+showIndex = unsafePerformIO . mask_ . (`withIndex` (qlIndexName >=> peekDynString)) {-# NOINLINE showIndex #-}  instance Show (GenIndex idx) where show = showIndex@@ -1708,16 +1631,16 @@ instance Upcastable COvernightIndexedSwapIndex' where {type Base COvernightIndexedSwapIndex' = CSwapIndex'; upcast = qlOvernightIndexedSwapIndexAsSwapIndex}  asIndex :: GenIndex idx -> IO Index-asIndex = transferGenForeignPtr peekIndex . getIndex+asIndex = transferGenForeignPtr (pure . GenIndex) . getIndex withIndex :: GenIndex idx -> (Ptr CIndex' -> IO b) -> IO b withIndex = withGenForeignPtr . getIndex peekIndex :: Ptr CIndex' -> IO Index peekIndex = GenIndex <.> newCastForeignPtr-withIndexArray :: [Index] -> ((CUInt, Ptr (Ptr CIndex')) -> IO b) -> IO b+withIndexArray :: [GenIndex idx] -> ((CUInt, Ptr (Ptr CIndex')) -> IO b) -> IO b withIndexArray = withGenArray withIndex  asInterestRateIndex :: GenInterestRateIndex ridx -> IO InterestRateIndex-asInterestRateIndex = transferGenForeignPtr peekInterestRateIndex . peel . getIndex+asInterestRateIndex = transferGenForeignPtr newGenInterestRateIndex . peel . getIndex peekInterestRateIndex :: Ptr CInterestRateIndex' -> IO InterestRateIndex peekInterestRateIndex = newCastForeignPtr >=> newGenInterestRateIndex newGenInterestRateIndex :: GenForeignPtr ridx CInterestRateIndex' -> IO (GenInterestRateIndex ridx)@@ -1728,7 +1651,7 @@ withInterestRateIndexArray = withGenArray withInterestRateIndex  asInflationIndex :: GenInflationIndex iidx -> IO InflationIndex-asInflationIndex = transferGenForeignPtr peekInflationIndex . peel . getIndex+asInflationIndex = transferGenForeignPtr newGenInflationIndex . peel . getIndex peekInflationIndex :: Ptr CInflationIndex' -> IO InflationIndex peekInflationIndex = newCastForeignPtr >=> newGenInflationIndex newGenInflationIndex :: GenForeignPtr iidx CInflationIndex' -> IO (GenInflationIndex iidx)@@ -1756,7 +1679,7 @@ withBMAIndex = withForeignPtr . ptr . peel . getIndex  asIborIndex :: GenIborIndex ibor -> IO IborIndex-asIborIndex = transferGenForeignPtr peekIborIndex . peel . peel . getIndex+asIborIndex = transferGenForeignPtr newGenIborIndex . peel . peel . getIndex peekIborIndex :: Ptr CIborIndex' -> IO IborIndex peekIborIndex = newCastForeignPtr >=> newGenIborIndex withIborIndex :: GenIborIndex ibor -> (Ptr CIborIndex' -> IO b) -> IO b@@ -1772,7 +1695,7 @@ withOvernightIborIndex = withForeignPtr . ptr . peel . peel . getIndex  asSwapIndex :: GenSwapIndex sidx -> IO SwapIndex-asSwapIndex = transferGenForeignPtr peekSwapIndex . peel . peel . getIndex+asSwapIndex = transferGenForeignPtr newGenSwapIndex . peel . peel . getIndex peekSwapIndex :: Ptr CSwapIndex' -> IO SwapIndex peekSwapIndex = newCastForeignPtr >=> newGenSwapIndex withSwapIndex :: GenSwapIndex sidx -> (Ptr CSwapIndex' -> IO b) -> IO b@@ -1829,6 +1752,7 @@ data CRelinkableSwaptionVolatilityStructure' data CSabrSwaptionVolatilityCube' data CNoArbSabrSwaptionVolatilityCube'+data CZabrSwaptionVolatilityCube' data CInterpolatedSwaptionVolatilityCube' data CCapFloorTermVolatilityStructure' data CCapFloorTermVolCurve'@@ -1847,6 +1771,7 @@ data CRelinkableYieldTermStructure' data CCallableBondVolatilityStructure' data CDefaultProbabilityTermStructure'+data CAffineHazardRateCurve' data CZeroInflationTermStructure' data CYoYInflationTermStructure' data CCommodityCurve'@@ -1865,6 +1790,7 @@ -- >      RelinkableSwaptionVolatilityStructure -- >      SabrSwaptionVolatilityCube -- >      NoArbSabrSwaptionVolatilityCube+-- >      ZabrSwaptionVolatilityCube -- >      InterpolatedSwaptionVolatilityCube -- >      SwaptionVolatilityMatrix -- >    CapFloorTermVolatilityStructure*@@ -1879,7 +1805,8 @@ -- >    YoYOptionletVolatilitySurface -- >    CPIVolatilitySurface -- >  CallableBondVolatilityStructure--- >  DefaultProbabilityTermStructure+-- >  DefaultProbabilityTermStructure = GenDefaultProbabilityTermStructure d = GenTermStructure t+-- >    AffineHazardRateCurve = GenDefaultProbabilityTermStructure ... -- >  ZeroInflationTermStructure -- >  YoYInflationTermStructure -- >  YoYCapFloorTermPriceSurface@@ -1970,6 +1897,11 @@ -- reasoning and identical getter surface. -- See the hierarchy under t'GenTermStructure'. type NoArbSabrSwaptionVolatilityCube = GenSwaptionVolatilityStructure CNoArbSabrSwaptionVolatilityCube+type CZabrSwaptionVolatilityCube = ForeignPtr CZabrSwaptionVolatilityCube'+-- | A ZABR-calibrated swaption vol cube: the same @XabrSwaptionVolatilityCube@ template as+-- 'SabrSwaptionVolatilityCube' with the default ZABR model policy and a fifth (gamma) parameter.+-- See the hierarchy under t'GenTermStructure'.+type ZabrSwaptionVolatilityCube = GenSwaptionVolatilityStructure CZabrSwaptionVolatilityCube type CInterpolatedSwaptionVolatilityCube = ForeignPtr CInterpolatedSwaptionVolatilityCube' -- | The non-SABR, linear-interpolation swaption vol cube. It /is/ a -- 'SwaptionVolatilityStructure' -- pass it anywhere one is expected. Gets the same dedicated-leaf@@ -2081,13 +2013,18 @@ type CCallableBondVolatilityStructure = ForeignPtr CCallableBondVolatilityStructure' -- |A 'TermStructure'; see the hierarchy under t'GenTermStructure'. type CallableBondVolatilityStructure = GenTermStructure CCallableBondVolatilityStructure+-- |A 'DefaultProbabilityTermStructure' or one of its leaves; see the hierarchy under t'GenTermStructure'.+type GenDefaultProbabilityTermStructure d = GenTermStructure (AnyOf CDefaultProbabilityTermStructure' d) type CDefaultProbabilityTermStructure = ForeignPtr CDefaultProbabilityTermStructure' -- |A 'TermStructure'; see the hierarchy under t'GenTermStructure'.-type DefaultProbabilityTermStructure = GenTermStructure CDefaultProbabilityTermStructure-withDefaultProbabilityTermStructureArray :: [DefaultProbabilityTermStructure] -> ((CUInt, Ptr (Ptr CDefaultProbabilityTermStructure')) -> IO b) -> IO b-withDefaultProbabilityTermStructureArray = withGenArray withGenTermStructure-withDefaultProbabilityTermStructureArrayRaw :: [DefaultProbabilityTermStructure] -> (Ptr (Ptr CDefaultProbabilityTermStructure') -> IO b) -> IO b-withDefaultProbabilityTermStructureArrayRaw x f = withMany withGenTermStructure x (`withArray` f)+type DefaultProbabilityTermStructure = GenDefaultProbabilityTermStructure CDefaultProbabilityTermStructure+type CAffineHazardRateCurve = ForeignPtr CAffineHazardRateCurve'+-- |A 'DefaultProbabilityTermStructure'; see the hierarchy under t'GenTermStructure'.+type AffineHazardRateCurve = GenDefaultProbabilityTermStructure CAffineHazardRateCurve+withDefaultProbabilityTermStructureArray :: [GenDefaultProbabilityTermStructure d] -> ((CUInt, Ptr (Ptr CDefaultProbabilityTermStructure')) -> IO b) -> IO b+withDefaultProbabilityTermStructureArray = withGenArray withDefaultProbabilityTermStructure+withDefaultProbabilityTermStructureArrayRaw :: [GenDefaultProbabilityTermStructure d] -> (Ptr (Ptr CDefaultProbabilityTermStructure') -> IO b) -> IO b+withDefaultProbabilityTermStructureArrayRaw x f = withMany withDefaultProbabilityTermStructure x (`withArray` f)  -- CREDIT: separate types encode tranche-loss and digital-loss capabilities. data CDefaultProbKey@@ -2210,6 +2147,7 @@ foreign import ccall unsafe "ql.h &qlFreeRelinkableSwaptionVolatilityStructure" qlFreeRelinkableSwaptionVolatilityStructure :: FinalizerPtr CRelinkableSwaptionVolatilityStructure' foreign import ccall unsafe "ql.h &qlFreeSabrSwaptionVolatilityCube" qlFreeSabrSwaptionVolatilityCube :: FinalizerPtr CSabrSwaptionVolatilityCube' foreign import ccall unsafe "ql.h &qlFreeNoArbSabrSwaptionVolatilityCube" qlFreeNoArbSabrSwaptionVolatilityCube :: FinalizerPtr CNoArbSabrSwaptionVolatilityCube'+foreign import ccall unsafe "ql.h &qlFreeZabrSwaptionVolatilityCube" qlFreeZabrSwaptionVolatilityCube :: FinalizerPtr CZabrSwaptionVolatilityCube' foreign import ccall unsafe "ql.h &qlFreeInterpolatedSwaptionVolatilityCube" qlFreeInterpolatedSwaptionVolatilityCube :: FinalizerPtr CInterpolatedSwaptionVolatilityCube' foreign import ccall unsafe "ql.h &qlFreeSwaptionVolatilityMatrix" qlFreeSwaptionVolatilityMatrix :: FinalizerPtr CSwaptionVolatilityMatrix' foreign import ccall unsafe "ql.h &qlFreeCapFloorTermVolatilityStructure" qlFreeCapFloorTermVolatilityStructure :: FinalizerPtr CCapFloorTermVolatilityStructure'@@ -2233,6 +2171,7 @@ foreign import ccall unsafe "ql.h &qlFreeRelinkableYieldTermStructure" qlFreeRelinkableYieldTermStructure :: FinalizerPtr CRelinkableYieldTermStructure' foreign import ccall unsafe "ql.h &qlFreeCallableBondVolatilityStructure" qlFreeCallableBondVolatilityStructure :: FinalizerPtr CCallableBondVolatilityStructure' foreign import ccall unsafe "ql.h &qlFreeDefaultProbabilityTermStructure" qlFreeDefaultProbabilityTermStructure :: FinalizerPtr CDefaultProbabilityTermStructure'+foreign import ccall unsafe "ql.h &qlFreeAffineHazardRateCurve" qlFreeAffineHazardRateCurve :: FinalizerPtr CAffineHazardRateCurve' foreign import ccall unsafe "ql.h &qlFreeZeroInflationTermStructure" qlFreeZeroInflationTermStructure :: FinalizerPtr CZeroInflationTermStructure' foreign import ccall unsafe "ql.h &qlFreeYoYInflationTermStructure" qlFreeYoYInflationTermStructure :: FinalizerPtr CYoYInflationTermStructure' foreign import ccall unsafe "ql.h &qlFreeYoYCapFloorTermPriceSurface" qlFreeYoYCapFloorTermPriceSurface :: FinalizerPtr CYoYCapFloorTermPriceSurface'@@ -2246,6 +2185,7 @@ instance Finalizable CRelinkableSwaptionVolatilityStructure' where finalize = qlFreeRelinkableSwaptionVolatilityStructure instance Finalizable CSabrSwaptionVolatilityCube' where finalize = qlFreeSabrSwaptionVolatilityCube instance Finalizable CNoArbSabrSwaptionVolatilityCube' where finalize = qlFreeNoArbSabrSwaptionVolatilityCube+instance Finalizable CZabrSwaptionVolatilityCube' where finalize = qlFreeZabrSwaptionVolatilityCube instance Finalizable CInterpolatedSwaptionVolatilityCube' where finalize = qlFreeInterpolatedSwaptionVolatilityCube instance Finalizable CSwaptionVolatilityMatrix' where finalize = qlFreeSwaptionVolatilityMatrix instance Finalizable CCapFloorTermVolatilityStructure' where finalize = qlFreeCapFloorTermVolatilityStructure@@ -2269,6 +2209,7 @@ instance Finalizable CRelinkableYieldTermStructure' where finalize = qlFreeRelinkableYieldTermStructure instance Finalizable CCallableBondVolatilityStructure' where finalize = qlFreeCallableBondVolatilityStructure instance Finalizable CDefaultProbabilityTermStructure' where finalize = qlFreeDefaultProbabilityTermStructure+instance Finalizable CAffineHazardRateCurve' where finalize = qlFreeAffineHazardRateCurve instance Finalizable CZeroInflationTermStructure' where finalize = qlFreeZeroInflationTermStructure instance Finalizable CYoYInflationTermStructure' where finalize = qlFreeYoYInflationTermStructure instance Finalizable CYoYCapFloorTermPriceSurface' where finalize = qlFreeYoYCapFloorTermPriceSurface@@ -2288,6 +2229,7 @@ foreign import ccall "ql.h qlRelinkableSwaptionVolatilityStructureAsSwaptionVolatilityStructure" qlRelinkableSwaptionVolatilityStructureAsSwaptionVolatilityStructure :: Ptr CRelinkableSwaptionVolatilityStructure' -> IO (Ptr CSwaptionVolatilityStructure') foreign import ccall "ql.h qlSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure" qlSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure :: Ptr CSabrSwaptionVolatilityCube' -> IO (Ptr CSwaptionVolatilityStructure') foreign import ccall "ql.h qlNoArbSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure" qlNoArbSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure :: Ptr CNoArbSabrSwaptionVolatilityCube' -> IO (Ptr CSwaptionVolatilityStructure')+foreign import ccall "ql.h qlZabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure" qlZabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure :: Ptr CZabrSwaptionVolatilityCube' -> IO (Ptr CSwaptionVolatilityStructure') foreign import ccall "ql.h qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure" qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure :: Ptr CInterpolatedSwaptionVolatilityCube' -> IO (Ptr CSwaptionVolatilityStructure') foreign import ccall "ql.h qlSwaptionVolatilityMatrixAsSwaptionVolatilityStructure" qlSwaptionVolatilityMatrixAsSwaptionVolatilityStructure :: Ptr CSwaptionVolatilityMatrix' -> IO (Ptr CSwaptionVolatilityStructure') foreign import ccall "ql.h qlCapFloorTermVolatilityStructureAsVolatilityTermStructure" qlCapFloorTermVolatilityStructureAsVolatilityTermStructure :: Ptr CCapFloorTermVolatilityStructure' -> IO (Ptr CVolatilityTermStructure')@@ -2303,6 +2245,7 @@ foreign import ccall "ql.h qlCPIVolatilitySurfaceAsVolatilityTermStructure" qlCPIVolatilitySurfaceAsVolatilityTermStructure :: Ptr CCPIVolatilitySurface' -> IO (Ptr CVolatilityTermStructure') foreign import ccall "ql.h qlCallableBondVolatilityStructureAsTermStructure" qlCallableBondVolatilityStructureAsTermStructure :: Ptr CCallableBondVolatilityStructure' -> IO (Ptr CTermStructure') foreign import ccall "ql.h qlDefaultProbabilityTermStructureAsTermStructure" qlDefaultProbabilityTermStructureAsTermStructure :: Ptr CDefaultProbabilityTermStructure' -> IO (Ptr CTermStructure')+foreign import ccall "ql.h qlAffineHazardRateCurveAsDefaultProbabilityTermStructure" qlAffineHazardRateCurveAsDefaultProbabilityTermStructure :: Ptr CAffineHazardRateCurve' -> IO (Ptr CDefaultProbabilityTermStructure') foreign import ccall "ql.h qlZeroInflationTermStructureAsTermStructure" qlZeroInflationTermStructureAsTermStructure :: Ptr CZeroInflationTermStructure' -> IO (Ptr CTermStructure') foreign import ccall "ql.h qlYoYInflationTermStructureAsTermStructure" qlYoYInflationTermStructureAsTermStructure :: Ptr CYoYInflationTermStructure' -> IO (Ptr CTermStructure') foreign import ccall "ql.h qlYoYCapFloorTermPriceSurfaceAsTermStructure" qlYoYCapFloorTermPriceSurfaceAsTermStructure :: Ptr CYoYCapFloorTermPriceSurface' -> IO (Ptr CTermStructure')@@ -2314,6 +2257,7 @@ instance Upcastable CVolatilityTermStructure' where {type Base CVolatilityTermStructure' = CTermStructure'; upcast = qlVolatilityTermStructureAsTermStructure} instance Upcastable CCallableBondVolatilityStructure' where {type Base CCallableBondVolatilityStructure' = CTermStructure'; upcast = qlCallableBondVolatilityStructureAsTermStructure} instance Upcastable CDefaultProbabilityTermStructure' where {type Base CDefaultProbabilityTermStructure' = CTermStructure'; upcast = qlDefaultProbabilityTermStructureAsTermStructure}+instance Upcastable CAffineHazardRateCurve' where {type Base CAffineHazardRateCurve' = CDefaultProbabilityTermStructure'; upcast = qlAffineHazardRateCurveAsDefaultProbabilityTermStructure} instance Upcastable CZeroInflationTermStructure' where {type Base CZeroInflationTermStructure' = CTermStructure'; upcast = qlZeroInflationTermStructureAsTermStructure} instance Upcastable CYoYInflationTermStructure' where {type Base CYoYInflationTermStructure' = CTermStructure'; upcast = qlYoYInflationTermStructureAsTermStructure} instance Upcastable CYoYCapFloorTermPriceSurface' where {type Base CYoYCapFloorTermPriceSurface' = CTermStructure'; upcast = qlYoYCapFloorTermPriceSurfaceAsTermStructure}@@ -2329,6 +2273,7 @@ instance Upcastable CRelinkableSwaptionVolatilityStructure' where {type Base CRelinkableSwaptionVolatilityStructure' = CSwaptionVolatilityStructure'; upcast = qlRelinkableSwaptionVolatilityStructureAsSwaptionVolatilityStructure} instance Upcastable CSabrSwaptionVolatilityCube' where {type Base CSabrSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure} instance Upcastable CNoArbSabrSwaptionVolatilityCube' where {type Base CNoArbSabrSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlNoArbSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure}+instance Upcastable CZabrSwaptionVolatilityCube' where {type Base CZabrSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlZabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure} instance Upcastable CInterpolatedSwaptionVolatilityCube' where {type Base CInterpolatedSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure} instance Upcastable CSwaptionVolatilityMatrix' where {type Base CSwaptionVolatilityMatrix' = CSwaptionVolatilityStructure'; upcast = qlSwaptionVolatilityMatrixAsSwaptionVolatilityStructure} instance Upcastable CCapFloorTermVolatilityStructure' where {type Base CCapFloorTermVolatilityStructure' = CVolatilityTermStructure'; upcast = qlCapFloorTermVolatilityStructureAsVolatilityTermStructure}@@ -2343,7 +2288,7 @@ instance Upcastable CYoYOptionletVolatilitySurface' where {type Base CYoYOptionletVolatilitySurface' = CVolatilityTermStructure'; upcast = qlYoYOptionletVolatilitySurfaceAsVolatilityTermStructure} instance Upcastable CCPIVolatilitySurface' where {type Base CCPIVolatilitySurface' = CVolatilityTermStructure'; upcast = qlCPIVolatilitySurfaceAsVolatilityTermStructure} asTermStructure :: GenTermStructure t -> IO TermStructure-asTermStructure = transferGenForeignPtr peekTermStructure . getTermStructure+asTermStructure = transferGenForeignPtr (pure . GenTermStructure) . getTermStructure withTermStructure :: GenTermStructure t  -> (Ptr CTermStructure' -> IO b) -> IO b withTermStructure = withGenForeignPtr . getTermStructure withGenTermStructure :: GenTermStructure (ForeignPtr t) -> (Ptr t -> IO b) -> IO b@@ -2352,7 +2297,7 @@ peekTermStructure = GenTermStructure <.> newCastForeignPtr  asVolatilityTermStructure :: GenVolatilityTermStructure v -> IO VolatilityTermStructure-asVolatilityTermStructure = transferGenForeignPtr peekVolatilityTermStructure . peel . getTermStructure+asVolatilityTermStructure = transferGenForeignPtr newGenVolatilityTermStructure . peel . getTermStructure peekVolatilityTermStructure :: Ptr CVolatilityTermStructure' -> IO VolatilityTermStructure peekVolatilityTermStructure = newCastForeignPtr >=> newGenVolatilityTermStructure peekGenVolatilityTermStructure :: (Finalizable v, Upcastable v, Base v ~ CVolatilityTermStructure') => Ptr v -> IO (GenVolatilityTermStructure (ForeignPtr v))@@ -2365,7 +2310,7 @@ newGenVolatilityTermStructure = pure . GenTermStructure . newAnyOf  asBlackVolTermStructure :: GenBlackVolTermStructure bv -> IO BlackVolTermStructure-asBlackVolTermStructure = transferGenForeignPtr peekBlackVolTermStructure . peel . peel . getTermStructure+asBlackVolTermStructure = transferGenForeignPtr newGenBlackVolTermStructure . peel . peel . getTermStructure peekBlackVolTermStructure :: Ptr CBlackVolTermStructure' -> IO BlackVolTermStructure peekBlackVolTermStructure = newCastForeignPtr >=> newGenBlackVolTermStructure withBlackVolTermStructure :: GenBlackVolTermStructure bv -> (Ptr CBlackVolTermStructure' -> IO b) -> IO b@@ -2424,6 +2369,10 @@ peekNoArbSabrSwaptionVolatilityCube = newGenForeignPtr >=> newGenSwaptionVolatilityStructure withNoArbSabrSwaptionVolatilityCube :: NoArbSabrSwaptionVolatilityCube -> (Ptr CNoArbSabrSwaptionVolatilityCube' -> IO b) -> IO b withNoArbSabrSwaptionVolatilityCube = withForeignPtr . ptr . peel . peel . getTermStructure+peekZabrSwaptionVolatilityCube :: Ptr CZabrSwaptionVolatilityCube' -> IO ZabrSwaptionVolatilityCube+peekZabrSwaptionVolatilityCube = newGenForeignPtr >=> newGenSwaptionVolatilityStructure+withZabrSwaptionVolatilityCube :: ZabrSwaptionVolatilityCube -> (Ptr CZabrSwaptionVolatilityCube' -> IO b) -> IO b+withZabrSwaptionVolatilityCube = withForeignPtr . ptr . peel . peel . getTermStructure peekInterpolatedSwaptionVolatilityCube :: Ptr CInterpolatedSwaptionVolatilityCube' -> IO InterpolatedSwaptionVolatilityCube peekInterpolatedSwaptionVolatilityCube = newGenForeignPtr >=> newGenSwaptionVolatilityStructure withInterpolatedSwaptionVolatilityCube :: InterpolatedSwaptionVolatilityCube -> (Ptr CInterpolatedSwaptionVolatilityCube' -> IO b) -> IO b@@ -2484,10 +2433,24 @@ withMaybeLocalVolTermStructure x f = maybe (f nullPtr) (`withGenLocalVolTermStructure` f) x peekCallableBondVolatilityStructure :: Ptr CCallableBondVolatilityStructure' -> IO CallableBondVolatilityStructure peekCallableBondVolatilityStructure = GenTermStructure <.> newGenForeignPtr+asDefaultProbabilityTermStructure :: GenDefaultProbabilityTermStructure d -> IO DefaultProbabilityTermStructure+asDefaultProbabilityTermStructure = transferGenForeignPtr newGenDefaultProbabilityTermStructure . peel . getTermStructure peekDefaultProbabilityTermStructure :: Ptr CDefaultProbabilityTermStructure' -> IO DefaultProbabilityTermStructure-peekDefaultProbabilityTermStructure = GenTermStructure <.> newGenForeignPtr-withMaybeDefaultProbabilityTermStructure :: Maybe DefaultProbabilityTermStructure -> (Ptr CDefaultProbabilityTermStructure' -> IO b) -> IO b-withMaybeDefaultProbabilityTermStructure x f = maybe (f nullPtr) (`withGenTermStructure` f) x+peekDefaultProbabilityTermStructure = newCastForeignPtr >=> newGenDefaultProbabilityTermStructure+withDefaultProbabilityTermStructure :: GenDefaultProbabilityTermStructure d -> (Ptr CDefaultProbabilityTermStructure' -> IO b) -> IO b+withDefaultProbabilityTermStructure = withGenForeignPtr . peel . getTermStructure+withMaybeDefaultProbabilityTermStructure :: Maybe (GenDefaultProbabilityTermStructure d) -> (Ptr CDefaultProbabilityTermStructure' -> IO b) -> IO b+withMaybeDefaultProbabilityTermStructure x f = maybe (f nullPtr) (`withDefaultProbabilityTermStructure` f) x+newGenDefaultProbabilityTermStructure :: GenForeignPtr d CDefaultProbabilityTermStructure' -> IO (GenDefaultProbabilityTermStructure d)+newGenDefaultProbabilityTermStructure = pure . GenTermStructure . newAnyOf+peekAffineHazardRateCurve :: Ptr CAffineHazardRateCurve' -> IO AffineHazardRateCurve+peekAffineHazardRateCurve = newGenForeignPtr >=> newGenDefaultProbabilityTermStructure+-- | Reach the concrete leaf itself, for 'QuantLib.TermStructure.Credit.conditionalSurvivalProbability'+-- (declared on the underlying @OneFactorAffineSurvivalStructure@, not the generic+-- @DefaultProbabilityTermStructure@ interface). Ordinary curve arguments go through+-- 'withDefaultProbabilityTermStructure' instead, which upcasts.+withAffineHazardRateCurve :: AffineHazardRateCurve -> (Ptr CAffineHazardRateCurve' -> IO b) -> IO b+withAffineHazardRateCurve = withForeignPtr . ptr . peel . getTermStructure peekZeroInflationTermStructure :: Ptr CZeroInflationTermStructure' -> IO ZeroInflationTermStructure peekZeroInflationTermStructure = GenTermStructure <.> newGenForeignPtr withMaybeZeroInflationTermStructure :: Maybe ZeroInflationTermStructure -> (Ptr CZeroInflationTermStructure' -> IO b) -> IO b@@ -2513,7 +2476,7 @@   | otherwise = Just <$> peekCommodityCurve p  asYieldTermStructure :: GenYieldTermStructure y -> IO YieldTermStructure-asYieldTermStructure = transferGenForeignPtr peekYieldTermStructure . peel . getTermStructure+asYieldTermStructure = transferGenForeignPtr newGenYieldTermStructure . peel . getTermStructure peekYieldTermStructure :: Ptr CYieldTermStructure' -> IO YieldTermStructure peekYieldTermStructure = newCastForeignPtr >=> newGenYieldTermStructure withYieldTermStructure :: GenYieldTermStructure y -> (Ptr CYieldTermStructure' -> IO b) -> IO b@@ -2720,7 +2683,7 @@ instance Upcastable CGeneralizedBlackScholesProcess' where {type Base CGeneralizedBlackScholesProcess' = CStochasticProcess1D'; upcast = qlGeneralizedBlackScholesProcessAsStochasticProcess1D} instance Upcastable CBlackProcess' where {type Base CBlackProcess' = CGeneralizedBlackScholesProcess'; upcast = qlBlackProcessAsGeneralizedBlackScholesProcess} asStochasticProcess :: GenStochasticProcess p -> IO StochasticProcess-asStochasticProcess = transferGenForeignPtr peekStochasticProcess . getStochasticProcess+asStochasticProcess = transferGenForeignPtr (pure . GenStochasticProcess) . getStochasticProcess peekStochasticProcess :: Ptr CStochasticProcess' -> IO StochasticProcess peekStochasticProcess = GenStochasticProcess <.> newCastForeignPtr withStochasticProcess :: GenStochasticProcess p -> (Ptr CStochasticProcess' -> IO b) -> IO b@@ -2744,7 +2707,7 @@ peekG2ForwardProcess :: Ptr CG2ForwardProcess' -> IO G2ForwardProcess peekG2ForwardProcess = GenStochasticProcess <.> newGenForeignPtr asHestonProcess :: GenHestonProcess hp -> IO HestonProcess-asHestonProcess = transferGenForeignPtr peekHestonProcess . peel . getStochasticProcess+asHestonProcess = transferGenForeignPtr newGenHestonProcess . peel . getStochasticProcess peekHestonProcess :: Ptr CHestonProcess' -> IO HestonProcess peekHestonProcess = newCastForeignPtr >=> newGenHestonProcess withHestonProcess :: GenHestonProcess hp -> (Ptr CHestonProcess' -> IO b) -> IO b@@ -2758,7 +2721,7 @@ peekGenHestonProcess :: (Finalizable hp, Upcastable hp, Base hp ~ CHestonProcess') => Ptr hp -> IO (GenHestonProcess (ForeignPtr hp)) peekGenHestonProcess = newGenForeignPtr >=> newGenHestonProcess asStochasticProcess1D :: GenStochasticProcess1D p1d -> IO StochasticProcess1D-asStochasticProcess1D = transferGenForeignPtr peekStochasticProcess1D . peel . getStochasticProcess+asStochasticProcess1D = transferGenForeignPtr newGenStochasticProcess1D . peel . getStochasticProcess peekStochasticProcess1D :: Ptr CStochasticProcess1D' -> IO StochasticProcess1D peekStochasticProcess1D = newCastForeignPtr >=> newGenStochasticProcess1D withStochasticProcess1D :: GenStochasticProcess1D p1d -> (Ptr CStochasticProcess1D' -> IO b) -> IO b@@ -2786,7 +2749,7 @@ peekVarianceGammaProcess :: Ptr CVarianceGammaProcess' -> IO VarianceGammaProcess peekVarianceGammaProcess = peekGenStochasticProcess1D asGeneralizedBlackScholesProcess :: GenGeneralizedBlackScholesProcess gbs -> IO GeneralizedBlackScholesProcess-asGeneralizedBlackScholesProcess = transferGenForeignPtr peekGeneralizedBlackScholesProcess . peel . peel . getStochasticProcess+asGeneralizedBlackScholesProcess = transferGenForeignPtr newGenGeneralizedBlackScholesProcess . peel . peel . getStochasticProcess peekGeneralizedBlackScholesProcess :: Ptr CGeneralizedBlackScholesProcess' -> IO GeneralizedBlackScholesProcess peekGeneralizedBlackScholesProcess = newCastForeignPtr >=> newGenGeneralizedBlackScholesProcess withGeneralizedBlackScholesProcess :: GenGeneralizedBlackScholesProcess gbs -> (Ptr CGeneralizedBlackScholesProcess' -> IO b) -> IO b@@ -2842,6 +2805,19 @@ data CGsr' data CMarkovFunctional' data CPiecewiseTimeDependentHestonModel'+data CRoughHestonModel'+type CRoughHestonModel = ForeignPtr CRoughHestonModel'+-- |A 'CalibratedModel' with its concrete native interface preserved.+type RoughHestonModel = GenCalibratedModel CRoughHestonModel+foreign import ccall unsafe "ql.h &qlFreeRoughHestonModel" qlFreeRoughHestonModel :: FinalizerPtr CRoughHestonModel'+instance Finalizable CRoughHestonModel' where finalize = qlFreeRoughHestonModel+foreign import ccall "ql.h qlRoughHestonModelAsCalibratedModel" qlRoughHestonModelAsCalibratedModel :: Ptr CRoughHestonModel' -> IO (Ptr CCalibratedModel')+instance Upcastable CRoughHestonModel' where {type Base CRoughHestonModel' = CCalibratedModel'; upcast = qlRoughHestonModelAsCalibratedModel}+peekRoughHestonModel :: Ptr CRoughHestonModel' -> IO RoughHestonModel+peekRoughHestonModel = GenCalibratedModel <.> newGenForeignPtr+withRoughHestonModel :: RoughHestonModel -> (Ptr CRoughHestonModel' -> IO b) -> IO b+withRoughHestonModel = withForeignPtr . ptr . getCalibratedModel+ data CHestonModel' data CShortRateModel' data CBatesModel'@@ -2857,6 +2833,7 @@ -- >  LiborForwardModel + AffineModel -- >  GJRGARCHModel -- >  PiecewiseTimeDependentHestonModel+-- >  RoughHestonModel -- >  HestonModel -- >    BatesModel -- >      BatesDetJumpModel@@ -2985,7 +2962,7 @@ instance Upcastable CHullWhite' where {type Base CHullWhite' = COneFactorAffineModel'; upcast = qlHullWhiteAsOneFactorAffineModel} instance Upcastable CG2' where {type Base CG2' = CShortRateModel'; upcast = qlG2AsShortRateModel} asCalibratedModel :: GenCalibratedModel m -> IO CalibratedModel-asCalibratedModel = transferGenForeignPtr peekCalibratedModel . getCalibratedModel+asCalibratedModel = transferGenForeignPtr (pure . GenCalibratedModel) . getCalibratedModel peekCalibratedModel :: Ptr CCalibratedModel' -> IO CalibratedModel peekCalibratedModel = GenCalibratedModel <.> newCastForeignPtr withCalibratedModel :: GenCalibratedModel m -> (Ptr CCalibratedModel' -> IO b) -> IO b@@ -3004,7 +2981,7 @@ peekPiecewiseTimeDependentHestonModel = GenCalibratedModel <.> newGenForeignPtr  asHestonModel :: GenHestonModel hm -> IO HestonModel-asHestonModel = transferGenForeignPtr peekHestonModel . peel . getCalibratedModel+asHestonModel = transferGenForeignPtr newGenHestonModel . peel . getCalibratedModel peekHestonModel :: Ptr CHestonModel' -> IO HestonModel peekHestonModel = newCastForeignPtr >=> newGenHestonModel withHestonModel :: GenHestonModel hm -> (Ptr CHestonModel' -> IO b) -> IO b@@ -3013,7 +2990,7 @@ newGenHestonModel = pure . GenCalibratedModel . newAnyOf  asShortRateModel :: GenShortRateModel sm -> IO ShortRateModel-asShortRateModel  = transferGenForeignPtr peekShortRateModel . peel . getCalibratedModel+asShortRateModel  = transferGenForeignPtr newGenShortRateModel . peel . getCalibratedModel peekShortRateModel :: Ptr CShortRateModel' -> IO ShortRateModel peekShortRateModel = newCastForeignPtr >=> newGenShortRateModel withShortRateModel :: GenShortRateModel sm -> (Ptr CShortRateModel' -> IO b) -> IO b@@ -3024,7 +3001,7 @@ peekGenShortRateModel = newGenForeignPtr >=> newGenShortRateModel  asBatesModel :: GenBatesModel bm -> IO BatesModel-asBatesModel = transferGenForeignPtr peekBatesModel . peel . peel . getCalibratedModel+asBatesModel = transferGenForeignPtr newGenBatesModel . peel . peel . getCalibratedModel peekBatesModel :: Ptr CBatesModel' -> IO BatesModel peekBatesModel = newCastForeignPtr >=> newGenBatesModel withBatesModel :: GenBatesModel bm -> (Ptr CBatesModel' -> IO b) -> IO b@@ -3037,7 +3014,7 @@ withBatesDetJumpModel = withForeignPtr . ptr . peel . peel . getCalibratedModel  asBatesDoubleExpModel :: GenBatesDoubleExpModel bdem -> IO BatesDoubleExpModel-asBatesDoubleExpModel = transferGenForeignPtr peekBatesDoubleExpModel . peel . peel . getCalibratedModel+asBatesDoubleExpModel = transferGenForeignPtr newGenBatesDoubleExpModel . peel . peel . getCalibratedModel peekBatesDoubleExpModel :: Ptr CBatesDoubleExpModel' -> IO BatesDoubleExpModel peekBatesDoubleExpModel = newCastForeignPtr >=> newGenBatesDoubleExpModel withBatesDoubleExpModel :: GenBatesDoubleExpModel bdem -> (Ptr CBatesDoubleExpModel' -> IO b) -> IO b@@ -3050,7 +3027,7 @@ withBatesDoubleExpDetJumpModel = withForeignPtr . ptr . peel . peel . getCalibratedModel  asOneFactorAffineModel :: GenOneFactorAffineModel om -> IO OneFactorAffineModel-asOneFactorAffineModel = transferGenForeignPtr peekOneFactorAffineModel . peel . peel . getCalibratedModel+asOneFactorAffineModel = transferGenForeignPtr newGenOneFactorAffineModel . peel . peel . getCalibratedModel peekOneFactorAffineModel :: Ptr COneFactorAffineModel' -> IO OneFactorAffineModel peekOneFactorAffineModel = newCastForeignPtr >=> newGenOneFactorAffineModel withOneFactorAffineModel :: GenOneFactorAffineModel om -> (Ptr COneFactorAffineModel' -> IO b) -> IO b@@ -3140,17 +3117,18 @@ -- >  Swap* -- >    FixedVsFloatingSwap* -- >      VanillaSwap+-- >      OvernightIndexedSwap -- >    IrregularSwap -- >    NonstandardSwap -- >    FloatFloatSwap -- >    AssetSwap -- >    BMASwap--- >    OvernightIndexedSwap -- >    ZeroCouponInflationSwap -- >    YearOnYearInflationSwap -- >    CPISwap -- >    ZeroCouponSwap -- >    EquityTotalReturnSwap+-- >    MtMCrossCurrencyBasisSwap -- >    ConstNotionalCrossCurrencySwap -- >      ConstNotionalCrossCurrencyBasisSwap -- >      ConstNotionalCrossCurrencyFixedVsFloatingSwap@@ -3177,7 +3155,7 @@ foreign import ccall unsafe "ql.h &qlFreeInstrument" qlFreeInstrument :: FinalizerPtr CInstrument' instance Finalizable CInstrument' where finalize = qlFreeInstrument asInstrument :: GenInstrument i -> IO Instrument-asInstrument = transferGenForeignPtr peekInstrument . getInstrument+asInstrument = transferGenForeignPtr (pure . GenInstrument) . getInstrument peekInstrument :: Ptr CInstrument' -> IO Instrument peekInstrument = GenInstrument <.> newCastForeignPtr withInstrument :: GenInstrument i -> (Ptr CInstrument' -> IO b) -> IO b@@ -3314,7 +3292,7 @@ foreign import ccall "ql.h qlForwardAsInstrument" qlForwardAsInstrument :: Ptr CForward' -> IO (Ptr CInstrument') instance Upcastable CForward' where {type Base CForward' = CInstrument'; upcast = qlForwardAsInstrument} asForward :: GenForward f -> IO Forward-asForward = transferGenForeignPtr peekForward . peel . getInstrument+asForward = transferGenForeignPtr newGenForward . peel . getInstrument peekForward :: Ptr CForward' -> IO Forward peekForward = newCastForeignPtr >=> newGenForward withForward :: GenForward f -> (Ptr CForward' -> IO b) -> IO b@@ -3336,7 +3314,7 @@ foreign import ccall "ql.h qlOptionAsInstrument" qlOptionAsInstrument :: Ptr COption' -> IO (Ptr CInstrument') instance Upcastable COption' where {type Base COption' = CInstrument'; upcast = qlOptionAsInstrument} asOption :: GenOption o -> IO Option-asOption = transferGenForeignPtr peekOption . peel . getInstrument+asOption = transferGenForeignPtr newGenOption . peel . getInstrument peekOption :: Ptr COption' -> IO Option peekOption = newCastForeignPtr >=> newGenOption withOption :: GenOption o -> (Ptr COption' -> IO b) -> IO b@@ -3358,7 +3336,7 @@ foreign import ccall "ql.h qlSwapAsInstrument" qlSwapAsInstrument :: Ptr CSwap' -> IO (Ptr CInstrument') instance Upcastable CSwap' where {type Base CSwap' = CInstrument'; upcast = qlSwapAsInstrument} asSwap :: GenSwap s -> IO Swap-asSwap = transferGenForeignPtr peekSwap . peel . getInstrument+asSwap = transferGenForeignPtr newGenSwap . peel . getInstrument peekSwap :: Ptr CSwap' -> IO Swap peekSwap = newCastForeignPtr >=> newGenSwap withSwap :: GenSwap s -> (Ptr CSwap' -> IO b) -> IO b@@ -3393,7 +3371,7 @@ foreign import ccall "ql.h qlBondAsInstrument" qlBondAsInstrument :: Ptr CBond' -> IO (Ptr CInstrument') instance Upcastable CBond' where {type Base CBond' = CInstrument'; upcast = qlBondAsInstrument} asBond :: GenBond b -> IO Bond-asBond = transferGenForeignPtr peekBond . peel . getInstrument+asBond = transferGenForeignPtr newGenBond . peel . getInstrument peekBond :: Ptr CBond' -> IO Bond peekBond = newCastForeignPtr >=> newGenBond withBond :: GenBond b -> (Ptr CBond' -> IO r) -> IO r@@ -3518,9 +3496,8 @@ withCallableBond :: CallableBond -> (Ptr CCallableBond' -> IO b) -> IO b withCallableBond = withForeignPtr . ptr . peel . getInstrument --- FixedVsFloatingSwap sits between Swap and VanillaSwap (upstream: VanillaSwap, OvernightIndexedSwap--- and MultipleResetsSwap all derive from it, but only VanillaSwap is modelled through it here ----- the others still upcast straight to Swap, collapsing the intermediate level as usual). It earns+-- FixedVsFloatingSwap sits between Swap and VanillaSwap/OvernightIndexedSwap (upstream+-- MultipleResetsSwap also derives from it but is not bound). It earns -- its own family level (mirrors MultiAssetOption/MargrabeOption's one-more-AnyOf-layer shape) -- because SwaptionHelper::underlying() (QuantLib/Model.chs) returns exactly this type, and its own -- getters (fairRate, fairSpread, fixedLeg*, floatingLeg*) are inherited, not VanillaSwap-specific --@@ -3545,7 +3522,7 @@ instance Upcastable CFixedVsFloatingSwap' where {type Base CFixedVsFloatingSwap' = CSwap'; upcast = qlFixedVsFloatingSwapAsSwap} instance Upcastable CVanillaSwap' where {type Base CVanillaSwap' = CFixedVsFloatingSwap'; upcast = qlVanillaSwapAsFixedVsFloatingSwap} asFixedVsFloatingSwap :: GenFixedVsFloatingSwap f -> IO FixedVsFloatingSwap-asFixedVsFloatingSwap = transferGenForeignPtr peekFixedVsFloatingSwap . peel . peel . getInstrument+asFixedVsFloatingSwap = transferGenForeignPtr newGenFixedVsFloatingSwap . peel . peel . getInstrument peekFixedVsFloatingSwap :: Ptr CFixedVsFloatingSwap' -> IO FixedVsFloatingSwap peekFixedVsFloatingSwap = newCastForeignPtr >=> newGenFixedVsFloatingSwap withFixedVsFloatingSwap :: GenFixedVsFloatingSwap f -> (Ptr CFixedVsFloatingSwap' -> IO b) -> IO b@@ -3565,6 +3542,19 @@ -- own engine-dispatched getters (fairPaySpread/fairRecSpread, fairRate/fairSpread) reachable only -- through the real leaf pointer. Unlike FixedVsFloatingSwap, the base class is concrete upstream -- and hasquant binds its own 2-leg/N-leg constructors directly at this level.+data CMtMCrossCurrencyBasisSwap'+type CMtMCrossCurrencyBasisSwap = ForeignPtr CMtMCrossCurrencyBasisSwap'+-- |A 'Swap' with its concrete native interface preserved.+type MtMCrossCurrencyBasisSwap = GenSwap CMtMCrossCurrencyBasisSwap+foreign import ccall unsafe "ql.h &qlFreeMtMCrossCurrencyBasisSwap" qlFreeMtMCrossCurrencyBasisSwap :: FinalizerPtr CMtMCrossCurrencyBasisSwap'+instance Finalizable CMtMCrossCurrencyBasisSwap' where finalize = qlFreeMtMCrossCurrencyBasisSwap+foreign import ccall "ql.h qlMtMCrossCurrencyBasisSwapAsSwap" qlMtMCrossCurrencyBasisSwapAsSwap :: Ptr CMtMCrossCurrencyBasisSwap' -> IO (Ptr CSwap')+instance Upcastable CMtMCrossCurrencyBasisSwap' where {type Base CMtMCrossCurrencyBasisSwap' = CSwap'; upcast = qlMtMCrossCurrencyBasisSwapAsSwap}+peekMtMCrossCurrencyBasisSwap :: Ptr CMtMCrossCurrencyBasisSwap' -> IO MtMCrossCurrencyBasisSwap+peekMtMCrossCurrencyBasisSwap = newGenForeignPtr >=> newGenSwap+withMtMCrossCurrencyBasisSwap :: MtMCrossCurrencyBasisSwap -> (Ptr CMtMCrossCurrencyBasisSwap' -> IO b) -> IO b+withMtMCrossCurrencyBasisSwap = withForeignPtr . ptr . peel . getInstrument+ data CConstNotionalCrossCurrencySwap' type GenConstNotionalCrossCurrencySwap x = GenSwap (AnyOf CConstNotionalCrossCurrencySwap' x) type CConstNotionalCrossCurrencySwap = ForeignPtr CConstNotionalCrossCurrencySwap'@@ -3591,7 +3581,7 @@ instance Upcastable CConstNotionalCrossCurrencyBasisSwap' where {type Base CConstNotionalCrossCurrencyBasisSwap' = CConstNotionalCrossCurrencySwap'; upcast = qlConstNotionalCrossCurrencyBasisSwapAsConstNotionalCrossCurrencySwap} instance Upcastable CConstNotionalCrossCurrencyFixedVsFloatingSwap' where {type Base CConstNotionalCrossCurrencyFixedVsFloatingSwap' = CConstNotionalCrossCurrencySwap'; upcast = qlConstNotionalCrossCurrencyFixedVsFloatingSwapAsConstNotionalCrossCurrencySwap} asConstNotionalCrossCurrencySwap :: GenConstNotionalCrossCurrencySwap x -> IO ConstNotionalCrossCurrencySwap-asConstNotionalCrossCurrencySwap = transferGenForeignPtr peekConstNotionalCrossCurrencySwap . peel . peel . getInstrument+asConstNotionalCrossCurrencySwap = transferGenForeignPtr newGenConstNotionalCrossCurrencySwap . peel . peel . getInstrument peekConstNotionalCrossCurrencySwap :: Ptr CConstNotionalCrossCurrencySwap' -> IO ConstNotionalCrossCurrencySwap peekConstNotionalCrossCurrencySwap = newCastForeignPtr >=> newGenConstNotionalCrossCurrencySwap withConstNotionalCrossCurrencySwap :: GenConstNotionalCrossCurrencySwap x -> (Ptr CConstNotionalCrossCurrencySwap' -> IO b) -> IO b@@ -3661,16 +3651,16 @@  data COvernightIndexedSwap' type COvernightIndexedSwap = ForeignPtr COvernightIndexedSwap'--- |A 'Swap'; see the hierarchy under t'GenInstrument'.-type OvernightIndexedSwap = GenSwap COvernightIndexedSwap+-- |A 'FixedVsFloatingSwap'; see the hierarchy under t'GenInstrument'.+type OvernightIndexedSwap = GenFixedVsFloatingSwap COvernightIndexedSwap foreign import ccall unsafe "ql.h &qlFreeOvernightIndexedSwap" qlFreeOvernightIndexedSwap :: FinalizerPtr COvernightIndexedSwap' instance Finalizable COvernightIndexedSwap' where finalize = qlFreeOvernightIndexedSwap-foreign import ccall "ql.h qlOvernightIndexedSwapAsSwap" qlOvernightIndexedSwapAsSwap :: Ptr COvernightIndexedSwap' -> IO (Ptr CSwap')-instance Upcastable COvernightIndexedSwap' where {type Base COvernightIndexedSwap' = CSwap'; upcast = qlOvernightIndexedSwapAsSwap}+foreign import ccall "ql.h qlOvernightIndexedSwapAsFixedVsFloatingSwap" qlOvernightIndexedSwapAsFixedVsFloatingSwap :: Ptr COvernightIndexedSwap' -> IO (Ptr CFixedVsFloatingSwap')+instance Upcastable COvernightIndexedSwap' where {type Base COvernightIndexedSwap' = CFixedVsFloatingSwap'; upcast = qlOvernightIndexedSwapAsFixedVsFloatingSwap} peekOvernightIndexedSwap :: Ptr COvernightIndexedSwap' -> IO OvernightIndexedSwap-peekOvernightIndexedSwap = peekGenSwap+peekOvernightIndexedSwap = newGenForeignPtr >=> newGenFixedVsFloatingSwap withOvernightIndexedSwap :: OvernightIndexedSwap -> (Ptr COvernightIndexedSwap' -> IO b) -> IO b-withOvernightIndexedSwap = withForeignPtr . ptr . peel . getInstrument+withOvernightIndexedSwap = withForeignPtr . ptr . peel . peel . getInstrument  data CZeroCouponInflationSwap' type CZeroCouponInflationSwap = ForeignPtr CZeroCouponInflationSwap'@@ -3828,7 +3818,7 @@ instance Upcastable CMargrabeOption' where {type Base CMargrabeOption' = CMultiAssetOption'; upcast = qlMargrabeOptionAsMultiAssetOption} instance Upcastable CEverestOption' where {type Base CEverestOption' = CMultiAssetOption'; upcast = qlEverestOptionAsMultiAssetOption} asMultiAssetOption :: GenMultiAssetOption mo -> IO MultiAssetOption-asMultiAssetOption = transferGenForeignPtr peekMultiAssetOption . peel . peel . getInstrument+asMultiAssetOption = transferGenForeignPtr newGenMultiAssetOption . peel . peel . getInstrument peekMultiAssetOption :: Ptr CMultiAssetOption' -> IO MultiAssetOption peekMultiAssetOption = newCastForeignPtr >=> newGenMultiAssetOption withMultiAssetOption :: GenMultiAssetOption mo -> (Ptr CMultiAssetOption' -> IO b) -> IO b@@ -3856,7 +3846,7 @@ foreign import ccall "ql.h qlOneAssetOptionAsOption" qlOneAssetOptionAsOption :: Ptr COneAssetOption' -> IO (Ptr COption') instance Upcastable COneAssetOption' where {type Base COneAssetOption' = COption'; upcast = qlOneAssetOptionAsOption} asOneAssetOption :: GenOneAssetOption oo -> IO OneAssetOption-asOneAssetOption = transferGenForeignPtr peekOneAssetOption . peel . peel . getInstrument+asOneAssetOption = transferGenForeignPtr newGenOneAssetOption . peel . peel . getInstrument peekOneAssetOption :: Ptr COneAssetOption' -> IO OneAssetOption peekOneAssetOption = newCastForeignPtr >=> newGenOneAssetOption withOneAssetOption :: GenOneAssetOption oo -> (Ptr COneAssetOption' -> IO b) -> IO b@@ -3970,16 +3960,8 @@ withQuantoDoubleBarrierOption :: QuantoDoubleBarrierOption -> (Ptr CQuantoDoubleBarrierOption' -> IO b) -> IO b withQuantoDoubleBarrierOption = withForeignPtr . ptr . peel . peel . getInstrument --- Commodity/EnergyCommodity are abstract-here: Commodity's own constructor is never called--- directly upstream (every concrete instrument goes through EnergyCommodity), and--- EnergyCommodity::quantity() is pure virtual, so neither binds a constructor here -- both are--- reachable only as upcast targets once a Stage-6 leaf (EnergyFuture, EnergyVanillaSwap,--- EnergyBasisSwap) exists. Commodity::secondaryCosts()/EnergyCommodity::commodityType() are plain,--- never-mutated echoes of each class's own constructor argument (commodity.hpp/energycommodity.hpp's--- inline getters each just `return foo_;`) -- not bound, per CLAUDE.md's trivial-getter rule.--- secondaryCostAmounts()/pricingErrors()/addPricingError are genuine (mutable, computed during--- pricing); their generalized 'withCommodity' accessor and marshalling live below, next to the--- Stage-6 leaves that finally give them a producer to verify against.+-- Commodity and EnergyCommodity are abstract upcast targets for concrete energy instruments.+-- Their calculated results use the shared 'withCommodity' accessor below. data CCommodity' type GenCommodity c = GenInstrument (AnyOf CCommodity' c) type CCommodity = ForeignPtr CCommodity'@@ -4100,9 +4082,36 @@ -- 'QuantLib.CashFlow.date' already carries the map key, so it isn't -- duplicated as a separate tuple field). peekCommodityCashFlowArray :: Ptr CUInt -> Ptr (Ptr (Ptr CCommodityCashFlow')) -> IO [CommodityCashFlow]-peekCommodityCashFlowArray = peekPtrArray peekCommodityCashFlow+peekCommodityCashFlowArray = peekPtrArray freeUpcast peekCommodityCashFlow  withInstrumentArray :: [GenInstrument i] -> ((CUInt, Ptr (Ptr CInstrument')) -> IO b) -> IO b withInstrumentArray = withGenArray withInstrument  -- vim: set ff=unix ts=8 sts=2 sw=2 et:++preCommodityTypeArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CCommodityType))) -> IO b) -> IO b+preCommodityTypeArray = prePtrArray freeUpcast++preUnitOfMeasureArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CUnitOfMeasure))) -> IO b) -> IO b+preUnitOfMeasureArray = prePtrArray freeUpcast++preCurrencyArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CCurrency))) -> IO b) -> IO b+preCurrencyArray = prePtrArray freeUpcast++preCouponArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CCoupon'))) -> IO b) -> IO b+preCouponArray = prePtrArray freeUpcast++preBlackCalibrationHelperArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CBlackCalibrationHelper'))) -> IO b) -> IO b+preBlackCalibrationHelperArray = prePtrArray freeUpcast++preCommodityCashFlowArray :: ((Ptr CUInt, Ptr (Ptr (Ptr CCommodityCashFlow'))) -> IO b) -> IO b+preCommodityCashFlowArray = prePtrArray freeUpcast++-- Temporary construction input; the native consumer copies the selected indices.+type QlStubIndexSelection = Ptr CStubIndexSelection'+data CStubIndexSelection'+foreign import ccall unsafe "ql.h &qlFreeStubIndexSelection" qlFreeStubIndexSelection :: FinalizerPtr CStubIndexSelection'+instance Finalizable CStubIndexSelection' where finalize = qlFreeStubIndexSelection++withIborIndexArray :: [GenIborIndex ibor] -> ((CUInt, Ptr (Ptr CIborIndex')) -> IO r) -> IO r+withIborIndexArray = withGenArray withIborIndex

@@ -148,7 +148,7 @@   ,withMaybeConstraint*`Maybe Constraint'   ,withOptimizationMethod*`OptimizationMethod'   ,withEndCriteria*`EndCriteria'-  ,preArray-`RealVector'&peekRealVector* -- ^solution+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^solution   ,alloca-`Double'peekDouble* -- ^achieved cost   ,alloca-`EndCriteriaType'peekEnum* -- ^end criteria reached   ,preErrorCheck-`String'errorCheck*-}->`()'#}@@ -178,7 +178,7 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Returns all times on the grid in contiguous storage.-{#fun qlTimeGridPoints as points{withTimeGrid*`TimeGrid',preArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlTimeGridPoints as points{withTimeGrid*`TimeGrid',preDoubleArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Mean of a caller-supplied sample. Each @riskStatistics*@ call evaluates a fresh sample. {#fun qlRiskStatisticsMean as riskStatisticsMean{withRealVector*`RealVector'& -- ^sample@@ -304,8 +304,8 @@   (values, r, c, vectors) <- qlSymmetricSchurDecomposition mr mc md   pure (values, Matrix r c vectors) {#fun qlSymmetricSchurDecomposition{fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'-  ,preArray-`[Double]'&peekDoubleArray*-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Pseudo square root @S@ of a real symmetric matrix @M@, i.e. the matrix with @S*transpose S == M@.@@ -317,7 +317,7 @@ pseudoSqrt (Matrix mr mc md) salvaging = toMatrixDouble <$> qlPseudoSqrt mr mc md salvaging {#fun qlPseudoSqrt{fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,fromEnumC`SalvagingAlgorithm'-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Rank-reduced pseudo square root of a real symmetric matrix: the result has rank at most@@ -332,7 +332,7 @@   toMatrixDouble <$> qlRankReducedSqrt mr mc md maxRank retained salvaging {#fun qlRankReducedSqrt{fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,fromIntegral`Word',`Double',fromEnumC`SalvagingAlgorithm'-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Cholesky factor @L@ of a symmetric positive-definite matrix @M@, i.e. the lower-triangular@@ -345,7 +345,7 @@ choleskyDecomposition (Matrix mr mc md) flexible = toMatrixDouble <$> qlCholeskyDecomposition mr mc md flexible {#fun qlCholeskyDecomposition{fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,`Bool'-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Solves @M*x == b@ given the Cholesky factor @L@ of @M@ -- the first argument is the factor@@ -356,7 +356,7 @@ choleskySolveFor (Matrix mr mc md) b = qlCholeskySolveFor mr mc md b {#fun qlCholeskySolveFor{fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,withDoubleArray*`[Double]'&-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -56,6 +56,19 @@ -- row per path, and guard the ITM-fit-size check with 'lsmBasisSize' instead of the basis order -- -- the multi-asset basis has combinatorially many more terms than the scalar case. --+-- To keep a fit and evaluate it later, split the combined call: 'lsmFit' returns the basis+-- coefficients and 'lsmEvaluate' applies them to new states. Both pick the basis by the state+-- matrix's column count -- the scalar basis of 'lsmRegress' at one column, the basis of+-- 'lsmRegressMulti' at several -- and share the combined calls' native code, so within one build+-- fitting then evaluating gives the combined call's values bit for bit. Across builds the bits are+-- not promised: 'lsmEvaluatorIdentity' names the basis revision, QuantLib version, compiler and+-- architecture, so a stored fit can be refused elsewhere. It is necessary, not sufficient: a+-- library rebuilt under the same version string keeps it.+--+-- Both Chebyshev types are QuantLib's weighted bases, undefined outside (-1, 1): with a state there+-- the least-squares solve of every regression above does not return. Scale the states into that+-- interval or choose another 'PolynomialType'.+-- -- @test\/example\/QuantLib\/Example\/HaskellLSM.hs@ benchmarks 'lsmRegress' against the same -- backward induction with the per-date regression reimplemented from scratch in plain Haskell -- (QuantLib used only for path generation) -- a worked illustration of why this module exposes@@ -152,7 +165,7 @@ -- -- [@Rolling a grid back@] 'fdmRollback' takes a precomputed initial grid (a plain @[Double]@) and --   rolls it back through time via three Haskell-defined operator callbacks---   ('QuantLib.Internal.Type.withFdmApply' et al.) plus an optional step condition (e.g.+--   (@withFdmApply@ et al. below) plus an optional step condition (e.g. --   American\/Bermudan early exercise). These callbacks cross the language boundary once per outer --   timestep, over the /whole/ grid. 'fdmSolve' is the sibling that instead derives its own --   initial grid from a mesher and@@ -171,22 +184,19 @@ --   @t -> location -> value@ pair of functions as an 'FdmInnerValueCalculator'. Unlike every --   callback above, this one crosses the language boundary once /per grid node/ -- there is no --   batched shape for it anywhere in QuantLib or QuantLib-SWIG, so the real per-call cost is---   accepted, matching QuantLib-SWIG's own @FdmInnerValueCalculatorDelegate@ precedent. Because the---   two callbacks are stored /inside/ the returned calculator and invoked again on every later---   'fdmSolve'\/'fdmInnerValue' call (not just during construction), the calculator is only valid---   /inside/ this continuation -- it cannot be built with a plain @IO FdmInnerValueCalculator@---   smart constructor the way the native calculators below can.+--   accepted, matching QuantLib-SWIG's own @FdmInnerValueCalculatorDelegate@ precedent.+--   The calculator and native dependents retain both callbacks after the continuation returns;+--   callback exceptions are rethrown by the enclosing Haskell call. -- -- [@Custom inner values, native@] QuantLib's own concrete 'FdmInnerValueCalculator' subclasses are --   bound directly, for the common cases that don't need a per-node Haskell callback at all: --   'fdmZeroInnerValue' (always 0), 'fdmCellAveragingInnerValue'\/'fdmLogInnerValue' (a payoff --   cell-averaged -- Simpson-integrated across each grid cell, not just evaluated at its center -- --   with an identity or @exp@ value mapping respectively), and 'fdmLogBasketInnerValue' (the---   multi-asset counterpart, one @exp@ mapping per dimension). These hold no Haskell callback, so---   they're plain @IO FdmInnerValueCalculator@ constructors -- except+--   multi-asset counterpart, one @exp@ mapping per dimension). These retain their payoff,+--   including any Haskell callback it owns. There is also --   'withCustomCellAveragingInnerValue', the one native constructor that /does/ take an explicit---   @gridMapping@ callback, which needs the same continuation treatment as the fully custom case---   above. 'fdmAffineG2ModelSwapInnerValue'\/'fdmAffineHullWhiteModelSwapInnerValue' price a swap+--   @gridMapping@ callback, retained by the native calculator. 'fdmAffineG2ModelSwapInnerValue'\/'fdmAffineHullWhiteModelSwapInnerValue' price a swap --   under a calibrated 'QuantLib.Model.G2'\/'QuantLib.Model.HullWhite' model directly -- the same --   calculator @fdG2SwaptionEngine@\/@fdHullWhiteSwaptionEngine@ use internally. --@@ -267,6 +277,9 @@   , lsmRegress   , lsmBasisSize   , lsmRegressMulti+  , lsmFit+  , lsmEvaluate+  , lsmEvaluatorIdentity     -- ** Finite differences   , fdmRollback   , fdmInnerValue@@ -281,6 +294,7 @@     -- ** Random sequences and meshers   , rsgDimension   , lastSequence+  , pathGeneratorSequence   , fdmMesherLocations   ) where #include "qlTypesC2HS.h"@@ -289,13 +303,17 @@ #include "ql.h"  import QuantLib.Internal-import QuantLib.Internal.Type+import qualified QuantLib.Internal.Callback as Callback+import QuantLib.Internal.Type hiding (ptr) -- c2hs {#get#} binds its own `ptr' import QuantLib.Internal.Common {#import QuantLib.Math#}-import Foreign.C.String(CString)-import Foreign.C.Types(CUInt)-import Foreign.Ptr(Ptr, FunPtr)+import Foreign.C.String(peekCString)+import Foreign.C.Types(CDouble)+import Foreign.Ptr(Ptr, nullPtr, castPtr) import Foreign.Marshal.Alloc(alloca)+import Foreign.Marshal.Array(moveArray)+import Control.Exception(throwIO)+import qualified Data.Vector.Storable as V  {#pointer *PolymorphicPathGenerator as PathGenerator foreign -> CPathGenerator nocode#} {#pointer *SamplePath as SamplePath foreign -> CSamplePath nocode#}@@ -317,6 +335,34 @@ {#pointer *QlFdmMesher as FdmMesher foreign -> CFdmMesher nocode#} {#pointer *QlFdmInnerValueCalculator as FdmInnerValueCalculator foreign -> CFdmInnerValueCalculator nocode#} +-- A step condition may return its borrowed input, which shares the output buffer.+pokeFdmResult :: Int -> Ptr CDouble -> RealVector -> IO ()+pokeFdmResult expected out result+  | V.length result /= expected = throwIO (CallbackResultLength expected (V.length result))+  | otherwise = V.unsafeWith result $ \p -> moveArray out (castPtr p) expected++withFdmResult :: (Callback.CallbackArgs -> RealVector -> RealVector) -> (Ptr () -> IO b) -> IO b+withFdmResult f use = Callback.withCallback call (`withCallbackPtr` use)+  where+    call args = do+      x <- borrowRealVector (Callback.callbackInput args) (fromIntegral (Callback.callbackSize args))+      pokeFdmResult (Callback.callbackSize args) (Callback.callbackOutput args) (f args x)++withFdmApply :: ((Double, Double) -> RealVector -> RealVector) -> (Ptr () -> IO b) -> IO b+withFdmApply f = withFdmResult $ \args -> f (Callback.callbackTime1 args, Callback.callbackTime2 args)++withFdmApplyDirection :: (Int -> (Double, Double) -> RealVector -> RealVector) -> (Ptr () -> IO b) -> IO b+withFdmApplyDirection f = withFdmResult $ \args ->+  f (Callback.callbackDirection args) (Callback.callbackTime1 args, Callback.callbackTime2 args)++withFdmSolveSplitting :: (Int -> Double -> (Double, Double) -> RealVector -> RealVector) -> (Ptr () -> IO b) -> IO b+withFdmSolveSplitting f = withFdmResult $ \args ->+  f (Callback.callbackDirection args) (Callback.callbackScalar args) (Callback.callbackTime1 args, Callback.callbackTime2 args)++withMaybeFdmStepCondition :: Maybe (Double -> RealVector -> RealVector) -> (Ptr () -> IO b) -> IO b+withMaybeFdmStepCondition Nothing use = use nullPtr+withMaybeFdmStepCondition (Just f) use = withFdmResult (f . Callback.callbackTime1) use+ -- |build a multi-asset path generator driven by a pseudo-random number generator (Mersenne Twister, Poisson, or Ziggurat, chosen by the RNG trait) over the given process and time grid. {#fun qlPathGenerator as pathGenerator{fromEnumC`RngTrait',withStochasticProcess*`GenStochasticProcess p',withTimeGrid*`TimeGrid'   ,fromIntegral`Word' -- ^seed@@ -345,17 +391,20 @@ -- engine would have accepted a custom process anyway: their constructors are typed on concrete -- process classes (@GeneralizedBlackScholesProcess@ and friends), not on the abstract base. ----- @dimension@ is the length of each drawn sequence -- for a path set, @assets * timesteps@,--- matching what 'pathGenerator' is passed. The construction mirrors 'pathGenerator''s exactly--- (same trait, same seed, same direction integers), so a Haskell-evolved path can be compared--- draw for draw against a 'pathGenerator' one on a bound process.+-- @dimension@ is the length of each drawn sequence: (normals drawn per step) * timesteps. For+-- 'pathGenerator' parity the per-step count is the process's @factors@; a Haskell-evolved model+-- may draw more normals per step than it has Brownian drivers. The construction mirrors+-- 'pathGenerator''s exactly (same trait, same seed, same direction integers), so a+-- Haskell-evolved path can be compared draw for draw against a 'pathGenerator' one on a bound+-- process. {#fun qlGaussianRsg as gaussianRsg{fromEnumC`RngTrait'   ,fromIntegral`Word' -- ^dimension   ,fromIntegral`Word' -- ^seed   ,preErrorCheck-`String'errorCheck*-}->`GaussianRsg'peekGaussianRsg*#}  -- |'gaussianRsg' driven by a low-discrepancy (Sobol) sequence with the given direction integers ----- the 'sobolPathGenerator' counterpart.+-- the 'sobolPathGenerator' counterpart. The maximum @dimension@ depends on the direction-integer+-- set and on QuantLib's build-time @PPMT_MAX_DIM@; a larger one raises an exception. {#fun qlSobolGaussianRsg as sobolGaussianRsg{fromEnumC`SobolDirectionIntegers'   ,fromIntegral`Word' -- ^dimension   ,fromIntegral`Word' -- ^seed@@ -367,16 +416,24 @@ -- |draw the next sequence of standard normal variates, with its sample weight (1 for every trait -- bound here, carried through for symmetry with 'weight'). {#fun qlGaussianRsgNextSequence as nextSequence{withGaussianRsg*`GaussianRsg'-  ,preArray-`RealVector'&peekRealVector* -- ^draws+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^draws   ,alloca-`Double'peekDouble* -- ^weight   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |re-read the sequence 'nextSequence' last drew, without advancing the generator. {#fun qlGaussianRsgLastSequence as lastSequence{withGaussianRsg*`GaussianRsg'-  ,preArray-`RealVector'&peekRealVector* -- ^draws+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^draws   ,alloca-`Double'peekDouble* -- ^weight   ,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |The random sequence consumed by the last 'next', with its sample weight, without advancing+-- the generator. Refuses before the first draw. These are variates before process correlation;+-- 'antithetic' uses their negatives and leaves this original sequence unchanged.+{#fun qlPathGeneratorSequence as pathGeneratorSequence{withPathGenerator*`PathGenerator' -- ^generator+  ,preDoubleArray-`RealVector'&peekRealVector*+  ,alloca-`Double'peekDouble*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |draw the next weighted sample path from the generator. {#fun qlPathGeneratorNext as next{withPathGenerator*`PathGenerator',preErrorCheck-`String'errorCheck*-}->`SamplePath'peekSamplePath*#} @@ -398,7 +455,7 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The full simulated path (values at every time step) of a single asset.-{#fun qlSamplePathAssetPath as asset{withSamplePath*`SamplePath',fromIntegral`Word',preArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlSamplePathAssetPath as asset{withSamplePath*`SamplePath',fromIntegral`Word',preDoubleArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |one step of Longstaff-Schwartz early-exercise regression: fit a polynomial basis of the given -- order/type against the (in-the-money) fit states and their continuation targets, then evaluate the@@ -411,7 +468,7 @@   ,withRealVector*`RealVector'& -- ^fit states (in-the-money paths only)   ,withRealVector*`RealVector'& -- ^fit targets (continuation value at these states)   ,withRealVector*`RealVector'& -- ^eval states (all paths' state at this date)-  ,preArray-`RealVector'&peekRealVector* -- ^continuation value estimate per eval state+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^continuation value estimate per eval state   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |number of basis terms 'lsmRegressMulti' fits for a given number of underlyings and order --@@ -444,9 +501,43 @@   ,fromIntegral`Word' -- ^eval rows   ,fromIntegral`Word' -- ^eval columns (underlyings)   ,withRealVectorRaw*`RealVector' -- ^eval states, row-major-  ,preArray-`RealVector'&peekRealVector* -- ^continuation value estimate per eval row+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^continuation value estimate per eval row   ,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |basis coefficients of one Longstaff-Schwartz fit, the fitting half of 'lsmRegress' (one state+-- column) or 'lsmRegressMulti' (several): fit states are a row-major 'RealMatrix', one row per+-- path. There are 'lsmBasisSize' of them, in QuantLib's basis order; evaluate them with 'lsmEvaluate'.+lsmFit :: PolynomialType -> Word -> RealMatrix -- ^fit states (in-the-money paths only)+  -> RealVector -- ^fit targets (continuation value at these states)+  -> IO RealVector -- ^basis coefficients+lsmFit p order (RealMatrix r c d) = qlLsmFit p order r c d+{#fun qlLsmFit{`PolynomialType',fromIntegral`Word' -- ^basis order+  ,fromIntegral`Word' -- ^rows+  ,fromIntegral`Word' -- ^columns+  ,withRealVectorRaw*`RealVector' -- ^states, row-major+  ,withRealVector*`RealVector'& -- ^targets+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^coefficients+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |continuation value of 'lsmFit' coefficients at each row of the given states, which must have+-- the fit's column count; the polynomial type and order must be the fit's too. Throws unless there+-- are 'lsmBasisSize' coefficients for that column count.+lsmEvaluate :: PolynomialType -> Word -> RealVector -- ^coefficients+  -> RealMatrix -- ^eval states (one row per path)+  -> IO RealVector -- ^continuation value estimate per row+lsmEvaluate p order coefficients (RealMatrix r c d) = qlLsmEvaluate p order coefficients r c d+{#fun qlLsmEvaluate{`PolynomialType',fromIntegral`Word' -- ^basis order+  ,withRealVector*`RealVector'& -- ^coefficients+  ,fromIntegral`Word' -- ^rows+  ,fromIntegral`Word' -- ^columns+  ,withRealVectorRaw*`RealVector' -- ^states, row-major+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^continuation values+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |the build that 'lsmFit' and 'lsmEvaluate' belong to: the shim's basis revision, the QuantLib+-- version, the compiler and the architecture. Store it beside coefficients meant for later use.+{#fun pure qlLsmEvaluatorIdentity as lsmEvaluatorIdentity{}->`String'peekCString*#}+ -- |Drive @FdmBackwardSolver::rollback@ with a Haskell-defined 'FdmLinearOpComposite' (the -- @apply@\/@apply_direction@\/@solve_splitting@ callbacks) and an optional Haskell-defined step -- condition (e.g. American\/Bermudan early exercise, or a barrier), instead of a bound mesher +@@ -455,10 +546,13 @@ -- @FdmLinearOpCompositeDelegate@\/ -- @FdmStepConditionDelegate@ (@SWIG\/fdm.i@): each callback crosses once per outer iteration over -- the whole grid array, not once per grid node.+-- Internally each callback receives one native argument record, avoiding a wide mixed-argument+-- callback ABI at the Haskell boundary; this does not affect the public callback types. -- -- The grid is a plain @[Double]@ in and out -- no mesher, no @FdmInnerValueCalculator@, no -- @FdmSolverDesc@ is bound; callers manage their own grid geometry entirely in Haskell. Boundary--- conditions are always the empty @FdmBoundaryConditionSet()@ (not bound).+-- conditions are always the empty @FdmBoundaryConditionSet()@ (not bound). Every callback must+-- return an array of its input's length; any other length throws 'QuantLib.Context.CallbackResultLength'. -- -- /Only DouglasScheme::step's three virtuals are implemented -- 'apply', 'apply_direction' and/ -- /'solve_splitting'; @apply_mixed@\/@preconditioner@ are unimplemented and @QL_FAIL@ at the C++/@@ -479,7 +573,7 @@   ,`Double' -- ^to (end time of the rollback, e.g. 0)   ,fromIntegral`Int' -- ^steps   ,fromIntegral`Int' -- ^dampingSteps-  ,preArray-`RealVector'&peekRealVector* -- ^grid values at time \'to\'+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^grid values at time \'to\'   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |'Predefined1dMesher(points)' -- an 'Fdm1dMesher' over an explicit, caller-supplied set of grid points.@@ -534,7 +628,7 @@ -- for a Black-Scholes-family process, reusing the same 'GeneralizedBlackScholesProcess'\/ -- 'Dividend'\/'FdmQuantoHelper' plumbing "QuantLib.PricingEngine"'s @fd*@ engines already use. {#fun qlFdmBlackScholesMesher as fdmBlackScholesMesher{fromIntegral`Word' -- ^size-  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,`Double' -- ^maturity   ,`Double' -- ^strike   ,fromMaybeDouble`Maybe Double' -- ^xMinConstraint@@ -573,7 +667,7 @@ -- |'FdmSimpleProcess1dMesher(size, process, maturity, tAvgSteps, epsilon, mandatoryPoint)' -- -- generic mesher for any bound one-dimensional 'StochasticProcess1D'. {#fun qlFdmSimpleProcess1dMesher as fdmSimpleProcess1dMesher{fromIntegral`Word' -- ^size-  ,withStochasticProcess1D*`StochasticProcess1D'+  ,withStochasticProcess1D*`GenStochasticProcess1D p1d'   ,`Double' -- ^maturity   ,fromIntegral`Word' -- ^tAvgSteps   ,`Double' -- ^epsilon@@ -612,22 +706,16 @@ -- @x_@ arrays from this same call upstream). {#fun qlFdmMesherLocations as fdmMesherLocations{withFdmMesher*`FdmMesher'   ,fromIntegral`Int' -- ^direction-  ,preArray-`RealVector'&peekRealVector*+  ,preDoubleArray-`RealVector'&peekRealVector*   ,preErrorCheck-`String'errorCheck*-}->`()'#} --- Raw import, not a {#fun#}: 'withCustomFdmInnerValueCalculator' below needs the two--- 'FunPtr's kept alive for as long as the returned 'FdmInnerValueCalculator' can be called into--- (i.e. across the whole continuation, which typically includes a later 'fdmSolve' call), not--- just for the duration of this one construction call the way a plain {#fun#}-generated--- 'withFdmInnerValue' bracket would provide -- see the haddock below.-foreign import ccall "ql.h qlFdmInnerValueCalculatorFromFunctions"-  c_qlFdmInnerValueCalculatorFromFunctions :: Ptr CFdmMesher -> FunPtr FdmInnerValueFun -> FunPtr FdmInnerValueFun-    -> Ptr CString -> IO (Ptr CFdmInnerValueCalculator)+{#fun qlFdmInnerValueCalculatorFromFunctions{withFdmMesher*`FdmMesher'+  ,withCallbackPtr*`Callback',withCallbackPtr*`Callback'+  ,preErrorCheck-`String'errorCheck*-}->`FdmInnerValueCalculator'peekFdmInnerValueCalculator*#}  -- |Wraps a Haskell @t -> location -> value@ pair of @innerValue@\/@avgInnerValue@ functions as a--- real 'FdmInnerValueCalculator' object, valid only inside the continuation -- the fully custom--- counterpart to constructors built from QuantLib's own concrete subclasses (bound alongside--- this, which need no such bracket: they hold no Haskell callback). Unlike every callback+-- real 'FdmInnerValueCalculator' that retains both callbacks after the continuation returns.+-- Callback exceptions are rethrown by the enclosing Haskell call. Unlike every callback -- 'fdmRollback' takes, this crosses the language boundary once /per grid node/, not once per outer -- iteration over the whole grid -- there is no batched \"whole-grid inner value\" shape anywhere -- in QuantLib or QuantLib-SWIG. The per-call FFI cost across@@ -639,13 +727,9 @@   -> (Double -> [Double] -> Double) -- ^avgInnerValue(t, location)   -> (FdmInnerValueCalculator -> IO b) -> IO b withCustomFdmInnerValueCalculator mesher iv aiv k =-  withFdmMesher mesher $ \mesher' ->-  withFdmInnerValue iv $ \ivFp ->-  withFdmInnerValue aiv $ \aivFp ->-  preErrorCheck $ \errPtr -> do-    res <- c_qlFdmInnerValueCalculatorFromFunctions mesher' ivFp aivFp errPtr-    errorCheck errPtr-    peekFdmInnerValueCalculator res >>= k+  withFdmInnerValue iv $ \inner ->+  withFdmInnerValue aiv $ \average ->+  qlFdmInnerValueCalculatorFromFunctions mesher inner average >>= k  -- |'FdmZeroInnerValue' -- an 'FdmInnerValueCalculator' whose @innerValue@\/@avgInnerValue@ are -- always 0.@@ -662,29 +746,19 @@   ,fromIntegral`Int' -- ^direction   ,preErrorCheck-`String'errorCheck*-}->`FdmInnerValueCalculator'peekFdmInnerValueCalculator*#} --- Raw import, not a {#fun#}: same FunPtr-lifetime hazard as--- 'c_qlFdmInnerValueCalculatorFromFunctions' above -- 'gridMapping' is stored inside the C++--- object and invoked again on every later 'innerValue'\/'avgInnerValue' call, not just during--- construction.-foreign import ccall "ql.h qlFdmCellAveragingInnerValueMapped"-  c_qlFdmCellAveragingInnerValueMapped :: QlPayoff -> Ptr CFdmMesher -> CUInt -> FunPtr FdmGridMappingFun-    -> Ptr CString -> IO (Ptr CFdmInnerValueCalculator)+{#fun qlFdmCellAveragingInnerValueMapped{withPayoff*`Payoff',withFdmMesher*`FdmMesher'+  ,fromIntegral`Int',withCallbackPtr*`Callback'+  ,preErrorCheck-`String'errorCheck*-}->`FdmInnerValueCalculator'peekFdmInnerValueCalculator*#}  -- |As 'fdmCellAveragingInnerValue', but with an explicit @gridMapping :: Double -> Double@ applied -- to each node's location before the payoff sees it (e.g. @exp@ on a log-spot grid, reproducing -- 'fdmLogInnerValue' by hand) -- a genuine per-node Haskell callback; see--- 'withCustomFdmInnerValueCalculator'. The--- resulting 'FdmInnerValueCalculator' is only valid inside this continuation.+-- 'withCustomFdmInnerValueCalculator'. The calculator retains the callback after the continuation. withCustomCellAveragingInnerValue :: Payoff -> FdmMesher -> Int -> (Double -> Double)   -> (FdmInnerValueCalculator -> IO b) -> IO b withCustomCellAveragingInnerValue payoff mesher direction mapping k =-  withPayoff payoff $ \payoff' ->-  withFdmMesher mesher $ \mesher' ->-  withFdmGridMapping mapping $ \mappingFp ->-  preErrorCheck $ \errPtr -> do-    res <- c_qlFdmCellAveragingInnerValueMapped payoff' mesher' (fromIntegral direction) mappingFp errPtr-    errorCheck errPtr-    peekFdmInnerValueCalculator res >>= k+  withFdmGridMapping mapping $ \callback ->+  qlFdmCellAveragingInnerValueMapped payoff mesher direction callback >>= k  -- |'FdmLogInnerValue(payoff, mesher, direction)' -- 'fdmCellAveragingInnerValue' with the -- @gridMapping = exp@ QuantLib itself gives its own dedicated subclass (the standard shape for a@@ -776,7 +850,7 @@   ,`Double' -- ^to (end time of the rollback, e.g. 0)   ,fromIntegral`Int' -- ^steps   ,fromIntegral`Int' -- ^dampingSteps-  ,preArray-`RealVector'&peekRealVector* -- ^grid values at time \'to\'+  ,preDoubleArray-`RealVector'&peekRealVector* -- ^grid values at time \'to\'   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -21,6 +21,7 @@   , G2   , GenHestonModel   , HestonModel+  , RoughHestonModel   , PiecewiseTimeDependentHestonModel   , GenBatesModel   , BatesModel@@ -84,6 +85,7 @@   , generalizedHullWhite   , gjrGarchModel   , hestonModel+  , roughHestonModel   , mtBrownianGeneratorFactory   , sobolBrownianGeneratorFactory   , hestonSlvMcModel@@ -94,6 +96,7 @@   , liborForwardModel   , lfmHullWhiteParameterization   , gsr+  , gsrWithReversions   , markovFunctional   , markovFunctionalCaplet   , garch11@@ -108,9 +111,11 @@   , setCovarParam   , calibrate   , calibrateVolatilitiesIterative+  , calibrateReversionsIterative   , moveVolatility   , moveReversion   , setPricingEngine+  , setParams      -- * Inspectors     -- ** Pricing and rate calculations@@ -121,6 +126,7 @@   , numeraire   , gaussian1dZerobond   , gaussian1dZerobondOption+  , gaussian1dCompoundedRate   , gaussian1dForwardRate   , gaussian1dSwapRate   , gaussian1dSwapAnnuity@@ -131,8 +137,16 @@   , impliedVolatility      -- ** Model state and calibration+  , roughHestonTheta+  , roughHestonKappa+  , roughHestonSigma+  , roughHestonRho+  , roughHestonV0+  , roughHestonHurst+  , roughHestonProcess   , HasLeverageFunction(..)   , HasVolatilities(..)+  , reversions   , HasHelperUnderlying(..)   , g2Dynamics   , shortRate@@ -172,6 +186,7 @@ #include "qlEnumObjects.h"  #include "ql.h"+{#pointer *QlOvernightIndexedCoupon as OvernightIndexedCoupon foreign -> COvernightIndexedCoupon' nocode#}  import QuantLib.Internal {#import QuantLib.Time.Schedule#}(Frequency)@@ -186,6 +201,7 @@ import Data.Maybe(fromMaybe)  {#enum CalibrationErrorType{} deriving(Show, Eq, Read)#}+{#enum Garch11Mode{} deriving(Show, Eq, Read)#}  -- |Sobol Brownian-bridge coordinate ordering. data SobolBrownianOrdering = Factors | Steps | Diagonal deriving (Show, Eq, Read, Enum, Bounded)@@ -217,9 +233,7 @@   } deriving (Show, Eq)  {#pointer *QlQuote as Quote foreign -> CQuote' nocode#}-{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine nocode#}-{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}+{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine' nocode#} {#pointer *QlOptimizationMethod as QlOptimizationMethod foreign -> COptimizationMethod nocode#} {#pointer *QlEndCriteria as QlEndCriteria foreign -> CEndCriteria nocode#} {#pointer *Constraint as QlConstraint foreign -> CConstraint nocode#}@@ -227,6 +241,7 @@ {#pointer *QlLmVolatilityModel foreign -> CLmVolatilityModel nocode#} {#pointer *QlLfmHullWhiteParameterization as LfmHullWhiteParameterization foreign -> CLfmHullWhiteParameterization nocode#} {#pointer *QlGJRGARCHModel as GJRGARCHModel foreign -> CGJRGARCHModel' nocode#}+{#pointer *QlRoughHestonModel as RoughHestonModel foreign -> CRoughHestonModel' nocode#} {#pointer *QlHestonModel as HestonModel foreign -> CHestonModel' nocode#} {#pointer *QlLocalVolTermStructure as LocalVolTermStructure foreign -> CLocalVolTermStructure' nocode#} {#pointer *QlBrownianGeneratorFactory as BrownianGeneratorFactory foreign -> CBrownianGeneratorFactory' nocode#}@@ -235,7 +250,6 @@ {#pointer *HestonSLVFDMLogEntries as HestonSLVFDMLogEntries foreign -> CHestonSLVFDMLogEntries nocode#} {#pointer *FdmSchemeDesc as QlFdmSchemeDesc foreign -> CFdmSchemeDesc nocode#} {#pointer *QlBatesModel as BatesModel foreign -> CBatesModel' nocode#}-{#pointer *QlPiecewiseTimeDependentHestonModel as PiecewiseTimeDependentHestonModel foreign -> CPiecewiseTimeDependentHestonModel' nocode#} {#pointer *QlShortRateModel as ShortRateModel foreign -> CShortRateModel' nocode#} {#pointer *QlOneFactorAffineModel as OneFactorAffineModel foreign -> COneFactorAffineModel' nocode#} {#pointer *QlLiborForwardModel as LiborForwardModel foreign -> CLiborForwardModel' nocode#}@@ -243,37 +257,21 @@ {#pointer *QlCalibratedModel as CalibratedModel foreign -> CCalibratedModel' nocode#} {#pointer *QlG2 as G2 foreign -> CG2' nocode#} {#pointer *QlShortRateDynamics as ShortRateDynamics foreign -> CShortRateDynamics' nocode#}-{#pointer *QlBatesDetJumpModel as BatesDetJumpModel foreign -> CBatesDetJumpModel' nocode#}-{#pointer *QlBatesDoubleExpDetJumpModel as BatesDoubleExpDetJumpModel foreign -> CBatesDoubleExpDetJumpModel' nocode#}-{#pointer *QlBatesDoubleExpModel as BatesDoubleExpModel foreign -> CBatesDoubleExpModel' nocode#} {#pointer *QlGsr as Gsr foreign -> CGsr' nocode#} {#pointer *QlMarkovFunctional as MarkovFunctional foreign -> CMarkovFunctional' nocode#} {#pointer *QlAffineModel foreign -> CAffineModel' nocode#} {#pointer *QlGaussian1dModel foreign -> CGaussian1dModel' nocode#}-{#pointer *QlSwapIndex as SwapIndex foreign -> CSwapIndex' nocode#}-{#pointer *QlSwaptionVolatilityStructure as SwaptionVolatilityStructure foreign -> CSwaptionVolatilityStructure' nocode#} {#pointer *QlCalibrationHelper as CalibrationHelper foreign -> CCalibrationHelper' nocode#} {#pointer *QlBlackCalibrationHelper as BlackCalibrationHelper foreign -> CBlackCalibrationHelper' nocode#} {#pointer *QlSwaptionHelper as SwaptionHelper foreign -> CSwaptionHelper' nocode#}-{#pointer *QlFixedVsFloatingSwap as FixedVsFloatingSwap foreign -> CFixedVsFloatingSwap' nocode#} {#pointer *QlSwaption as Swaption foreign -> CSwaption' nocode#}-{#pointer *QlGeneralizedBlackScholesProcess as GeneralizedBlackScholesProcess foreign -> CGeneralizedBlackScholesProcess' nocode#} {#pointer *QlStochasticProcess1D as StochasticProcess1D foreign -> CStochasticProcess1D' nocode#}-{#pointer *QlStochasticProcess as StochasticProcess foreign -> CStochasticProcess' nocode#}-{#pointer *QlBlackProcess as BlackProcess foreign -> CBlackProcess' nocode#}-{#pointer *QlExtOUWithJumpsProcess as ExtOUWithJumpsProcess foreign -> CExtOUWithJumpsProcess' nocode#}-{#pointer *QlExtendedOrnsteinUhlenbeckProcess as ExtendedOrnsteinUhlenbeckProcess foreign -> CExtendedOrnsteinUhlenbeckProcess' nocode#} {#pointer *QlGJRGARCHProcess as GJRGARCHProcess foreign -> CGJRGARCHProcess' nocode#} {#pointer *QlHestonProcess as HestonProcess foreign -> CHestonProcess' nocode#} {#pointer *QlBatesProcess as BatesProcess foreign -> CBatesProcess' nocode#}-{#pointer *QlHybridHestonHullWhiteProcess as HybridHestonHullWhiteProcess foreign -> CHybridHestonHullWhiteProcess' nocode#}-{#pointer *QlKlugeExtOUProcess as KlugeExtOUProcess foreign -> CKlugeExtOUProcess' nocode#} {#pointer *QlLiborForwardModelProcess as LiborForwardModelProcess foreign -> CLiborForwardModelProcess' nocode#}-{#pointer *QlStochasticProcessArray as StochasticProcessArray foreign -> CStochasticProcessArray' nocode#} {#pointer *QlVarianceGammaProcess as VarianceGammaProcess foreign -> CVarianceGammaProcess' nocode#}-{#pointer *QlMerton76Process as Merton76Process foreign -> CMerton76Process' nocode#}-{#pointer *QlHullWhiteProcess as HullWhiteProcess foreign -> CHullWhiteProcess' nocode#}-{#pointer *QlHullWhiteForwardProcess as HullWhiteForwardProcess foreign -> CHullWhiteForwardProcess' nocode#}+{#pointer *Garch11 foreign -> CGarch11 nocode#}  -- |Bates stochastic-volatility model: extends Heston with jumps in the underlying's return process. {#fun qlBatesModel as batesModel{withBatesProcess*`BatesProcess',preErrorCheck-`String'errorCheck*-}->`BatesModel'peekBatesModel*#}@@ -426,12 +424,12 @@ {#fun qlHestonSLVFDMModelLogEntries as hestonSlvFdmLogEntriesSnapshot{withHestonSLVFDMModel*`HestonSLVFDMModel',preErrorCheck-`String'errorCheck*-}->`HestonSLVFDMLogEntries'peekHestonSLVFDMLogEntries*#} {#fun pure qlHestonSLVFDMLogEntriesSize as hestonSlvFdmLogEntriesSize{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries'}->`Word'fromIntegral#} {#fun qlHestonSLVFDMLogEntriesTime as hestonSlvFdmLogEntriesTime{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}-{#fun qlHestonSLVFDMLogEntriesSpotGrid as hestonSlvFdmLogEntriesSpotGrid{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',preArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}-{#fun qlHestonSLVFDMLogEntriesVarianceGrid as hestonSlvFdmLogEntriesVarianceGrid{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',preArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}-{#fun qlHestonSLVFDMLogEntriesDensity as hestonSlvFdmLogEntriesDensity{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHestonSLVFDMLogEntriesSpotGrid as hestonSlvFdmLogEntriesSpotGrid{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',preDoubleArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHestonSLVFDMLogEntriesVarianceGrid as hestonSlvFdmLogEntriesVarianceGrid{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',preDoubleArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlHestonSLVFDMLogEntriesDensity as hestonSlvFdmLogEntriesDensity{withHestonSLVFDMLogEntries*`HestonSLVFDMLogEntries',fromIntegral`Word',prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`RealVector'&peekRealVector*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Single-factor Hull-White (extended Vasicek) short-rate model: dr = (theta(t) - a r) dt + sigma dW, fitted to the given term structure.-{#fun qlHullWhite as hullWhite{withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^y+{#fun qlHullWhite as hullWhite{withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^a (mean reversion)   ,`Double' -- ^sigma   ,preErrorCheck-`String'errorCheck*-}->`HullWhite'peekHullWhite*#} @@ -454,29 +452,45 @@ -- piecewise-constant changes at the given dates, plus a single constant reversion. gsr :: GenYieldTermStructure y -> GenQuote q1 -> [(Day, GenQuote q1)] -> GenQuote q2 -> Double -> IO Gsr gsr ts initialVol subsequentVols reversion horizon =-  qlGsr ts dates (initialVol : vols) reversion horizon+  qlGsr ts dates (initialVol : vols) [reversion] horizon   where (dates, vols) = unzip subsequentVols++-- |One-factor GSR model with a piecewise-constant reversion as well as volatility: the initial+-- (volatility, reversion) pair holds until the first step date, and each step date starts a new+-- pair. 'calibrateReversionsIterative' needs this form, one reversion per calibration helper.+gsrWithReversions :: GenYieldTermStructure y -> (GenQuote q1, GenQuote q2) -> [(Day, (GenQuote q1, GenQuote q2))]+  -> Double -> IO Gsr+gsrWithReversions ts (initialVol, initialReversion) steps horizon =+  qlGsr ts dates (initialVol : vols) (initialReversion : reversions') horizon+  where (dates, pairs) = unzip steps+        (vols, reversions') = unzip pairs+ {#fun qlGsr{withYieldTermStructure*`GenYieldTermStructure y',withDayArray*`[Day]'& -- ^volstepdates   ,withQuoteArray*`[GenQuote q1]'& -- ^volatilities-  ,withQuote*`GenQuote q2' -- ^reversion+  ,withQuoteArray*`[GenQuote q2]'& -- ^reversions: one, or one per volatility   ,`Double' -- ^T   ,preErrorCheck-`String'errorCheck*-}->`Gsr'peekGsr*#}  -- |Volatility step values, as calibrated so far.-{#fun qlGsrVolatility{withGenCalibratedModel*`Gsr',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlGsrVolatility{withGenCalibratedModel*`Gsr',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |Reversion values, as calibrated so far: one for a constant reversion, otherwise one per+-- volatility step.+{#fun qlGsrReversion as reversions{withGenCalibratedModel*`Gsr',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |The calibration mask ('calibrate''s @fixParameters@) that fixes every model parameter except -- the volatility at step index @i@ (0-based) -- a ready-made @fixParameters@ argument for -- calibrating that one volatility in isolation. {#fun qlGsrMoveVolatility as moveVolatility{withGenCalibratedModel*`Gsr'   ,fromIntegral`Word' -- ^i-  ,preArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preIntArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The calibration mask that fixes every model parameter except the reversion at index @i@--- (0-based) -- the reversion counterpart of 'moveVolatility'.+-- (0-based) -- the reversion counterpart of 'moveVolatility'. Only index 0 exists unless the model+-- was built by 'gsrWithReversions'. {#fun qlGsrMoveReversion as moveReversion{withGenCalibratedModel*`Gsr'   ,fromIntegral`Word' -- ^i-  ,preArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preIntArray-`[Bool]'&peekBoolArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Iteratively calibrates the volatility step values, one at a time, to the given helpers (assumed to have step dates matching the model's volatility step dates). {#fun qlGsrCalibrateVolatilitiesIterative as calibrateVolatilitiesIterative{withGenCalibratedModel*`Gsr',withBlackCalibrationHelperArray*`[GenBlackCalibrationHelper bch]'&,withOptimizationMethod*`OptimizationMethod',withEndCriteria*`EndCriteria'@@ -484,11 +498,23 @@   ,withDoubleArray*`[Double]'&   ,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |Iteratively calibrates the reversions, one at a time: reversion @i@ is fitted to helper @i@+-- with every other parameter held. The model needs one reversion per helper at least, so build+-- it with 'gsrWithReversions'. The end criteria reflect only the last calibration.+--+-- A swaption's price depends on the reversion over its swap's life, so helper @i@ should exercise+-- inside reversion interval @i@ and span it. Helpers expiring at the volatility step dates leave+-- the fit ill-conditioned, and alternating with 'calibrateVolatilitiesIterative' can diverge.+{#fun qlGsrCalibrateReversionsIterative as calibrateReversionsIterative{withGenCalibratedModel*`Gsr',withBlackCalibrationHelperArray*`[GenBlackCalibrationHelper bch]'&,withOptimizationMethod*`OptimizationMethod',withEndCriteria*`EndCriteria'+  ,withMaybeConstraint*`Maybe Constraint'+  ,withDoubleArray*`[Double]'&+  ,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |Markov-functional interest-rate model, calibrated to a swaption volatility cube against @swapIndexBase@. markovFunctional :: GenYieldTermStructure y -> Double -- ^reversion   -> Double -- ^initial volatility   -> [(Day, Double)] -- ^subsequent volatility steps-  -> SwaptionVolatilityStructure+  -> GenSwaptionVolatilityStructure sv   -> NonEmpty (Day, (Word, TimeUnit)) -- ^swaption expiry/tenor calibration points   -> GenSwapIndex sidx -- ^swapIndexBase   -> Word -- ^yGridPoints@@ -508,21 +534,21 @@  -- |Markov-functional interest-rate model, calibrated to a caplet volatility structure against @iborIndex@. markovFunctionalCaplet :: GenYieldTermStructure y -> Double -> Double -> [(Day, Double)]-  -> OptionletVolatilityStructure -> NonEmpty Day -> GenIborIndex ibor -> Word -> IO MarkovFunctional+  -> GenOptionletVolatilityStructure ov -> NonEmpty Day -> GenIborIndex ibor -> Word -> IO MarkovFunctional markovFunctionalCaplet ts reversion initialVol steps capletVol expiries ibor gridPoints =   qlMarkovFunctionalCaplet ts reversion dates (initialVol : vols) capletVol (toList expiries) ibor gridPoints   where (dates, vols) = unzip steps {#fun qlMarkovFunctionalCaplet{withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^reversion   ,withDayArray*`[Day]'& -- ^volstepdates   ,withDoubleArray*`[Double]'& -- ^volatilities-  ,withOptionletVolatilityStructure*`OptionletVolatilityStructure' -- ^capletVol+  ,withOptionletVolatilityStructure*`GenOptionletVolatilityStructure ov' -- ^capletVol   ,withDayArray*`[Day]'& -- ^capletExpiries   ,withIborIndex*`GenIborIndex ibor' -- ^iborIndex   ,fromIntegral`Word' -- ^yGridPoints   ,preErrorCheck-`String'errorCheck*-}->`MarkovFunctional'peekMarkovFunctional*#}  -- |Volatility step values, as calibrated so far.-{#fun qlMarkovFunctionalVolatility{withGenCalibratedModel*`MarkovFunctional',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlMarkovFunctionalVolatility{withGenCalibratedModel*`MarkovFunctional',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Discount factor at time @t@ under the model's own fitted curve -- @AffineModel::discount@. -- Not 'pure': depends on the model's 'YieldTermStructure' handle, which can be relinked after@@ -638,7 +664,7 @@   ,`Double' -- ^bigT   ,`Double' -- ^t   ,`Double' -- ^y-  ,preArray-`RealVector'&peekRealVector*+  ,preDoubleArray-`RealVector'&peekRealVector*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |The model's own state process. Throws if the model was constructed without one set.@@ -716,7 +742,7 @@ {#fun qlLfmHullWhiteCovariance{withStandalone*`LfmHullWhiteParameterization' -- ^parameterization   ,`Double' -- ^t   ,withDoubleArray*`[Double]'& -- ^x-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Calibrate to a set of market instruments (caps/swaptions)@@ -819,11 +845,19 @@ {#fun qlSwaptionHelperSwaption as helperSwaption{withSwaptionHelper*`SwaptionHelper',preErrorCheck-`String'errorCheck*-}->`Swaption'peekSwaption*#}  -- |Times relevant to pricing this calibration helper's instrument, to be added to the model's evolution time grid.-{#fun qlBlackCalibrationHelperTimes as times{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlBlackCalibrationHelperTimes as times{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Returns array of arguments on which calibration is done.-{#fun qlCalibratedModelParams as params{withCalibratedModel*`GenCalibratedModel m',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlCalibratedModelParams as params{withCalibratedModel*`GenCalibratedModel m',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#} +-- |Replace the arguments on which calibration is done, in the order 'params' returns them, and+-- notify the model's observers, so engines on it reprice. An array whose length differs from+-- 'params'' throws and leaves the model unchanged; the model's constraint is not checked. A later+-- 'calibrate' starts from these values.+{#fun qlCalibratedModelSetParams as setParams{withCalibratedModel*`GenCalibratedModel m'+  ,withDoubleArray*`[Double]'& -- ^params+  ,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |Black price given a volatility. {#fun qlBlackCalibrationHelperBlackPrice as blackPrice{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',`Double' -- ^volatility   ,preErrorCheck-`String'errorCheck*-}->`Double'#}@@ -849,10 +883,7 @@ {#fun qlBlackCalibrationHelperVolatility as volatility{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#}  -- |Sets the pricing engine used to compute this calibration helper's model value.-{#fun qlBlackCalibrationHelperSetPricingEngine as setPricingEngine{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',withPricingEngine*`PricingEngine',preErrorCheck-`String'errorCheck*-}->`()'#}--{#enum Garch11Mode{} deriving(Show, Eq, Read)#}-{#pointer *Garch11 foreign -> CGarch11 nocode#}+{#fun qlBlackCalibrationHelperSetPricingEngine as setPricingEngine{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',withPricingEngine*`GenPricingEngine pe',preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Direct-parameter GARCH(1,1) model: @vl@ is the long-term (unconditional) volatility: the -- model's persistence @gamma = 1 - alpha - beta@ and @omega = vl * gamma@ are derived from it.@@ -912,7 +943,7 @@   return $ zip ds vs   where (dates, vals) = unzip (toList series) {#fun qlGarch11Calculate{withGarch11*`Garch11',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass (1980) simple estimator: @sigma^2 = ln(close\/open)^2@, scaled by @yearFraction@.@@ -926,7 +957,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSimpleSigma{`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass Sigma1: blends 'garmanKlassSimpleSigma' with the overnight (previous close to@@ -942,7 +973,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSigma1{`Double',`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Parkinson (1980) high-low estimator: @sigma^2 = ln(high\/low)^2 \/ (4 ln 2)@, scaled by@@ -956,7 +987,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlParkinsonSigma{`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass Sigma3: blends 'parkinsonSigma' with the overnight jump, same@@ -971,7 +1002,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSigma3{`Double',`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass (1980) Sigma4 estimator, combining the high-low range with the close-open@@ -985,7 +1016,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSigma4{`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass (1980) Sigma5 estimator: an alternative high-low\/close-open combination to@@ -999,7 +1030,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSigma5{`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Garman-Klass Sigma6: blends 'garmanKlassSigma5' with the overnight jump, same@@ -1014,7 +1045,7 @@   where (dates, opens, closes, highs, lows) = unzipBars bars {#fun qlGarmanKlassSigma6{`Double',`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&   ,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Smooths an already-computed volatility series with a rolling constant estimate over the@@ -1027,7 +1058,7 @@   return $ zip ds vs   where (dates, vals) = unzip (toList series) {#fun qlConstantVolatilityEstimator{fromIntegral`Word',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Local (point-to-point) volatility estimate from a raw price series: @|ln(p_i\/p_{i-1})| \/@@ -1041,7 +1072,7 @@   return $ zip ds vs   where (dates, vals) = unzip (toList series) {#fun qlSimpleLocalVolatilityEstimator{`Double',withDayArray*`[Day]'&,withDoubleArray*`[Double]'&-  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*+  ,preIntArray-`[Day]'&peekDayArray*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  unzipBars :: NonEmpty (Day, Double, Double, Double, Double) -> ([Day], [Double], [Double], [Double], [Double])@@ -1053,5 +1084,48 @@     c5 (_,_,c,_,_) = c     h5 (_,_,_,h,_) = h     l5 (_,_,_,_,l) = l++-- |Conditional compounded overnight rate using the coupon's observation dates and index day+-- counter; ignores gearing/spread and historical fixings. Requires QuantLib 1.44.+-- Nothing selects the model reference date or model curve.+{#fun qlGaussian1dModelCompoundedRate as gaussian1dCompoundedRate{withStandalone*`Gaussian1dModel' -- ^model+  ,withOvernightIndexedCoupon*`OvernightIndexedCoupon' -- ^coupon+  ,withMaybeDay*`Maybe Day' -- ^referenceDate+  ,`Double' -- ^y+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^curve+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Rough Heston volatility model (1.44). Hurst is constrained to [0, 0.5]; 0.5 is classical Heston.+{#fun qlRoughHestonModel as roughHestonModel{withHestonProcess*`GenHestonProcess hp' -- ^process+  ,`Double' -- ^hurst+  ,preErrorCheck-`String'errorCheck*-}->`RoughHestonModel'peekRoughHestonModel*#}++-- |Current calibrated theta (1.44).+{#fun qlRoughHestonModelTheta as roughHestonTheta{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated kappa (1.44).+{#fun qlRoughHestonModelKappa as roughHestonKappa{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated sigma (1.44).+{#fun qlRoughHestonModelSigma as roughHestonSigma{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated rho (1.44).+{#fun qlRoughHestonModelRho as roughHestonRho{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated v0 (1.44).+{#fun qlRoughHestonModelV0 as roughHestonV0{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated hurst (1.44).+{#fun qlRoughHestonModelHurst as roughHestonHurst{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Current calibrated process (1.44).+{#fun qlRoughHestonModelProcess as roughHestonProcess{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,preErrorCheck-`String'errorCheck*-}->`HestonProcess'peekHestonProcess*#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -3,7 +3,9 @@   (     -- * Types     -- ** Engines-    PricingEngine+    GenPricingEngine+  , PricingEngine+  , AnalyticRoughHestonEngine   , FdmQuantoHelper      -- ** Option calculators@@ -24,6 +26,9 @@   , FixedPointEquation(..)   , QdFpScheme(..)   , IntegrationControl(..)+  , RoughHestonApproximation(..)+  , FourierIntegration(..)+  , H1HwMean(..)   , LatticeTime(..)   , FdmGrid(..)   , OperatorSplittingOrder(..)@@ -31,12 +36,14 @@   , StrikeSpec(..)      -- * Constructors+  , asPricingEngine     -- ** Discounting and counterparty engines   , discountingBondEngine   , riskyBondEngine   , discountingSwapEngine   , discountingFxForwardEngine   , discountingConstNotionalCrossCurrencySwapEngine+  , discountingMtmCrossCurrencyBasisSwapEngine   , counterpartyAdjSwapEngine   , discountingPerpetualFuturesEngine @@ -116,6 +123,9 @@     -- ** Equity, stochastic-volatility and exotic products   , analyticGjrGarchEngine   , analyticHestonEngine+  , analyticRoughHestonEngine+  , analyticRoughHestonEngineWithIntegration+  , analyticH1HwEngine   , analyticHestonHullWhiteEngine   , batesEngine   , fftVanillaEngine@@ -156,6 +166,7 @@   , qdFpAmericanEngine   , continuousArithmeticAsianVecerEngine     -- ** Credit and spread products+  , blackCdsOptionEngine   , integralCdsEngine   , integralEngine   , isdaCdsEngine@@ -216,6 +227,11 @@   , blackDeltaCalculator      -- * Inspectors+  , roughHestonPriceVanillaPayoff+  , roughHestonCharacteristicFunction+  , roughHestonLogCharacteristicFunction+  , roughHestonRiccatiSolution+  , roughHestonNumberOfEvaluations     -- ** Option-calculator capability   , HasOptionCalculator(..) @@ -268,6 +284,8 @@ #include "qlEnumObjects.h"  import QuantLib.Internal+import Data.Complex(Complex)+import QuantLib.TermStructure(TermPoint(..)) import QuantLib.Internal.Type {#import QuantLib.InterestRate#}(VolatilityType) {#import QuantLib.Math#}@@ -284,6 +302,16 @@   | IntegrationTolerance Double Word   deriving (Eq, Show) +-- |How the H1-HW engine reads E[sqrt v] of the Heston variance. QuantLib fits @a + b exp(-c t)@+-- at one year or @1 / kappa@, depending on its variance parameters; the fit can fail for a+-- nonmonotone mean. 'ExactMean' uses Gauss-Legendre on the specified positive number of nodes,+-- with an asymptotic expectation for large noncentrality. Its accuracy depends on the node count+-- and model parameters; it provides no adaptive error estimate and retains the H1-HW approximation.+data H1HwMean+  = FittedExponentialMean+  | ExactMean Word+  deriving (Eq, Show)+ -- |An option's type and strike, given directly or carried by a striked payoff. data StrikeSpec   = Strike !OptionType !Double@@ -313,7 +341,6 @@ {#pointer *DayCounter foreign -> CDayCounter nocode#} {#pointer *Currency foreign -> CCurrency nocode#} {#pointer *QlDividend as Dividend foreign -> CDividend nocode#}-{#pointer *QlQuote as Quote foreign -> CQuote' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlBlackVolTermStructure as BlackVolTermStructure foreign -> CBlackVolTermStructure' nocode#} {#pointer *QlCallableBondVolatilityStructure as CallableBondVolatilityStructure foreign -> CCallableBondVolatilityStructure' nocode#}@@ -326,40 +353,32 @@ {#pointer *QlGJRGARCHModel as GJRGARCHModel foreign -> CGJRGARCHModel' nocode#} {#pointer *QlHestonModel as HestonModel foreign -> CHestonModel' nocode#} {#pointer *QlBatesModel as BatesModel foreign -> CBatesModel' nocode#}-{#pointer *QlPiecewiseTimeDependentHestonModel as PiecewiseTimeDependentHestonModel foreign -> CPiecewiseTimeDependentHestonModel' nocode#} {#pointer *QlShortRateModel as ShortRateModel foreign -> CShortRateModel' nocode#} {#pointer *QlAffineModel foreign -> CAffineModel' nocode#} {#pointer *QlGaussian1dModel foreign -> CGaussian1dModel' nocode#} {#pointer *QlOneFactorAffineModel as OneFactorAffineModel foreign -> COneFactorAffineModel' nocode#} {#pointer *QlLiborForwardModel as LiborForwardModel foreign -> CLiborForwardModel' nocode#} {#pointer *QlHullWhite as HullWhite foreign -> CHullWhite' nocode#}-{#pointer *QlCalibratedModel as CalibratedModel foreign -> CCalibratedModel' nocode#} {#pointer *QlG2 as G2 foreign -> CG2' nocode#} {#pointer *QlBatesDetJumpModel as BatesDetJumpModel foreign -> CBatesDetJumpModel' nocode#} {#pointer *QlBatesDoubleExpDetJumpModel as BatesDoubleExpDetJumpModel foreign -> CBatesDoubleExpDetJumpModel' nocode#} {#pointer *QlBatesDoubleExpModel as BatesDoubleExpModel foreign -> CBatesDoubleExpModel' nocode#} {#pointer *QlGeneralizedBlackScholesProcess as GeneralizedBlackScholesProcess foreign -> CGeneralizedBlackScholesProcess' nocode#}-{#pointer *QlStochasticProcess1D as StochasticProcess1D foreign -> CStochasticProcess1D' nocode#}-{#pointer *QlStochasticProcess as StochasticProcess foreign -> CStochasticProcess' nocode#} {#pointer *QlBlackProcess as BlackProcess foreign -> CBlackProcess' nocode#}-{#pointer *QlExtOUWithJumpsProcess as ExtOUWithJumpsProcess foreign -> CExtOUWithJumpsProcess' nocode#}-{#pointer *QlExtendedOrnsteinUhlenbeckProcess as ExtendedOrnsteinUhlenbeckProcess foreign -> CExtendedOrnsteinUhlenbeckProcess' nocode#} {#pointer *QlGJRGARCHProcess as GJRGARCHProcess foreign -> CGJRGARCHProcess' nocode#} {#pointer *QlHestonProcess as HestonProcess foreign -> CHestonProcess' nocode#}-{#pointer *QlBatesProcess as BatesProcess foreign -> CBatesProcess' nocode#} {#pointer *QlHybridHestonHullWhiteProcess as HybridHestonHullWhiteProcess foreign -> CHybridHestonHullWhiteProcess' nocode#}-{#pointer *QlKlugeExtOUProcess as KlugeExtOUProcess foreign -> CKlugeExtOUProcess' nocode#}-{#pointer *QlLiborForwardModelProcess as LiborForwardModelProcess foreign -> CLiborForwardModelProcess' nocode#} {#pointer *QlStochasticProcessArray as StochasticProcessArray foreign -> CStochasticProcessArray' nocode#} {#pointer *QlVarianceGammaProcess as VarianceGammaProcess foreign -> CVarianceGammaProcess' nocode#} {#pointer *QlMerton76Process as Merton76Process foreign -> CMerton76Process' nocode#} {#pointer *QlHullWhiteProcess as HullWhiteProcess foreign -> CHullWhiteProcess' nocode#}-{#pointer *QlHullWhiteForwardProcess as HullWhiteForwardProcess foreign -> CHullWhiteForwardProcess' nocode#} {#pointer *QlBlackCalculator as BlackCalculator foreign -> CBlackCalculator' nocode#} {#pointer *QlBlackScholesCalculator as BlackScholesCalculator foreign -> CBlackScholesCalculator' nocode#} {#pointer *QlBachelierCalculator as BachelierCalculator foreign -> CBachelierCalculator nocode#} {#pointer *BlackDeltaCalculator foreign -> CBlackDeltaCalculator nocode#}-{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine nocode#}+{#pointer *QlRoughHestonModel as RoughHestonModel foreign -> CRoughHestonModel' nocode#}+{#pointer *QlAnalyticRoughHestonEngine as AnalyticRoughHestonEngine foreign -> CAnalyticRoughHestonEngine' nocode#}+{#pointer *QlPricingEngine as PricingEngine foreign -> CPricingEngine' nocode#} {#pointer *QlStrikedTypePayoff nocode#} {#pointer *QlPlainVanillaPayoff nocode#} {#pointer *QlLocalVolTermStructure as LocalVolTermStructure foreign -> CLocalVolTermStructure' nocode#}@@ -394,7 +413,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |discounts a bond's cash flows off a default-risky curve and a flat recovery rate-{#fun qlRiskyBondEngine as riskyBondEngine{withGenTermStructure*`DefaultProbabilityTermStructure',`Double' -- ^recoveryRate+{#fun qlRiskyBondEngine as riskyBondEngine{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double' -- ^recoveryRate   ,withYieldTermStructure*`GenYieldTermStructure y'   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -432,69 +451,69 @@ -- match upstream's unilateral-CVA-only defaults. {#fun qlCounterpartyAdjSwapEngine as counterpartyAdjSwapEngine{withYieldTermStructure*`GenYieldTermStructure y' -- ^discountCurve   ,withQuote*`GenQuote q' -- ^blackVol-  ,withGenTermStructure*`DefaultProbabilityTermStructure' -- ^ctptyDTS+  ,withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d1' -- ^ctptyDTS   ,`Double' -- ^ctptyRecoveryRate-  ,withMaybeDefaultProbabilityTermStructure*`Maybe DefaultProbabilityTermStructure' -- ^invstDTS+  ,withMaybeDefaultProbabilityTermStructure*`Maybe (GenDefaultProbabilityTermStructure d2)' -- ^invstDTS   ,`Double' -- ^invstRecoveryRate   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for barrier options-{#fun qlAnalyticBarrierEngine as analyticBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticBarrierEngine as analyticBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic (Heynen and Kat) pricing engine for a barrier option on two assets, where the first asset's value is compared to the strike and the second's is monitored against the barrier-{#fun qlAnalyticTwoAssetBarrierEngine as analyticTwoAssetBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process1-  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process2+{#fun qlAnalyticTwoAssetBarrierEngine as analyticTwoAssetBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1' -- ^process1+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2' -- ^process2   ,withQuote*`GenQuote q' -- ^rho   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for soft barrier options, knocked in/out proportionally over a barrier range-{#fun qlAnalyticSoftBarrierEngine as analyticSoftBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticSoftBarrierEngine as analyticSoftBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for simple chooser options-{#fun qlAnalyticSimpleChooserEngine as analyticSimpleChooserEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticSimpleChooserEngine as analyticSimpleChooserEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Analytic Black-Scholes engine for a 'complexChooserOption'. Both alternatives must have European exercise.-{#fun qlAnalyticComplexChooserEngine as analyticComplexChooserEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process+{#fun qlAnalyticComplexChooserEngine as analyticComplexChooserEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs' -- ^process   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for two-asset correlation options-{#fun qlAnalyticTwoAssetCorrelationEngine as analyticTwoAssetCorrelationEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process1-  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process2+{#fun qlAnalyticTwoAssetCorrelationEngine as analyticTwoAssetCorrelationEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1' -- ^process1+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2' -- ^process2   ,withQuote*`GenQuote q' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Analytic (Margrabe) engine for a European 'margrabeOption': the closed-form price of an -- option to exchange one asset for another, from W. Margrabe, \"The Value of an Option to -- Exchange One Asset for Another\", Journal of Finance 33 (March 1978), 177-186.-{#fun qlAnalyticEuropeanMargrabeEngine as analyticEuropeanMargrabeEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process1-  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process2+{#fun qlAnalyticEuropeanMargrabeEngine as analyticEuropeanMargrabeEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1' -- ^process1+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2' -- ^process2   ,`Double' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Analytic (Margrabe) engine for an American 'margrabeOption': the closed-form price of an -- option to exchange one asset for another with early exercise, from W. Margrabe, \"The Value -- of an American Option to Exchange One Asset for Another\", Journal of Finance 33, 177-86.-{#fun qlAnalyticAmericanMargrabeEngine as analyticAmericanMargrabeEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process1-  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process2+{#fun qlAnalyticAmericanMargrabeEngine as analyticAmericanMargrabeEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1' -- ^process1+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2' -- ^process2   ,`Double' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for writer-extensible options-{#fun qlAnalyticWriterExtensibleOptionEngine as analyticWriterExtensibleOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticWriterExtensibleOptionEngine as analyticWriterExtensibleOptionEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Analytic Black-Scholes engine for a 'holderExtensibleOption'. The original option must have European exercise.-{#fun qlAnalyticHolderExtensibleOptionEngine as analyticHolderExtensibleOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process+{#fun qlAnalyticHolderExtensibleOptionEngine as analyticHolderExtensibleOptionEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs' -- ^process   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for partial-time barrier options-{#fun qlAnalyticPartialTimeBarrierOptionEngine as analyticPartialTimeBarrierOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticPartialTimeBarrierOptionEngine as analyticPartialTimeBarrierOptionEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for American binary barrier options (cash-or-nothing/asset-or-nothing)-{#fun qlAnalyticBinaryBarrierEngine as analyticBinaryBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticBinaryBarrierEngine as analyticBinaryBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |/NB/ Timesteps for Cox-Ross-Rubinstein trees are adjusted using the Boyle-Lau algorithm; -- pass @maxTimeSteps = timeSteps@ to disable it, or @0@ to use the library's default heuristic.-{#fun qlBinomialBarrierEngine as binomialBarrierEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^timeSteps+{#fun qlBinomialBarrierEngine as binomialBarrierEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^timeSteps   ,fromIntegral`Word' -- ^maxTimeSteps   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -510,7 +529,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for double-barrier European options-{#fun qlAnalyticDoubleBarrierEngine as analyticDoubleBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Int' -- ^series+{#fun qlAnalyticDoubleBarrierEngine as analyticDoubleBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Int' -- ^series   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |always uses 'AnalyticDoubleBarrierEngine' as the underlying smile-free double-barrier engine@@ -526,11 +545,11 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for double-barrier options using binomial trees-{#fun qlBinomialDoubleBarrierEngine as binomialDoubleBarrierEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^timeSteps+{#fun qlBinomialDoubleBarrierEngine as binomialDoubleBarrierEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^timeSteps   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for double-barrier options-{#fun qlMCDoubleBarrierEngine as mcDoubleBarrierEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCDoubleBarrierEngine as mcDoubleBarrierEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -541,25 +560,25 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for Cliquet (ratchet) options-{#fun qlAnalyticCliquetEngine as analyticCliquetEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticCliquetEngine as analyticCliquetEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for compound options-{#fun qlAnalyticCompoundOptionEngine as analyticCompoundOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticCompoundOptionEngine as analyticCompoundOptionEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European continuous fixed-strike lookback options-{#fun qlAnalyticContinuousFixedLookbackEngine as analyticContinuousFixedLookbackEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticContinuousFixedLookbackEngine as analyticContinuousFixedLookbackEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European continuous floating-strike lookback options-{#fun qlAnalyticContinuousFloatingLookbackEngine as analyticContinuousFloatingLookbackEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticContinuousFloatingLookbackEngine as analyticContinuousFloatingLookbackEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European continuous partial-time floating-strike lookback options-{#fun qlAnalyticContinuousPartialFloatingLookbackEngine as analyticContinuousPartialFloatingLookbackEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticContinuousPartialFloatingLookbackEngine as analyticContinuousPartialFloatingLookbackEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European continuous partial-time fixed-strike lookback options-{#fun qlAnalyticContinuousPartialFixedLookbackEngine as analyticContinuousPartialFixedLookbackEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticContinuousPartialFixedLookbackEngine as analyticContinuousPartialFixedLookbackEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European continuous geometric average-price Asian options-{#fun qlAnalyticContinuousGeometricAveragePriceAsianEngine as analyticContinuousGeometricAveragePriceAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticContinuousGeometricAveragePriceAsianEngine as analyticContinuousGeometricAveragePriceAsianEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Analytic pricing engine for European continuous geometric average-price Asian options under -- the Heston stochastic-volatility model.  Implements the closed-form solution of Kim & Wee,@@ -582,7 +601,7 @@  -- |Monte Carlo pricing engine for continuous fixed-strike lookback options. Exactly one of -- @timeSteps@\/@timeStepsPerYear@ must be given; the other must be 'Nothing'.-{#fun qlMCLookbackFixedEngine as mcLookbackFixedEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCLookbackFixedEngine as mcLookbackFixedEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -594,7 +613,7 @@  -- |Monte Carlo pricing engine for continuous floating-strike lookback options. Exactly one of -- @timeSteps@\/@timeStepsPerYear@ must be given; the other must be 'Nothing'.-{#fun qlMCLookbackFloatingEngine as mcLookbackFloatingEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCLookbackFloatingEngine as mcLookbackFloatingEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -606,7 +625,7 @@  -- |Monte Carlo pricing engine for continuous partial-time fixed-strike lookback options. Exactly -- one of @timeSteps@\/@timeStepsPerYear@ must be given; the other must be 'Nothing'.-{#fun qlMCLookbackPartialFixedEngine as mcLookbackPartialFixedEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCLookbackPartialFixedEngine as mcLookbackPartialFixedEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -618,7 +637,7 @@  -- |Monte Carlo pricing engine for continuous partial-time floating-strike lookback options. -- Exactly one of @timeSteps@\/@timeStepsPerYear@ must be given; the other must be 'Nothing'.-{#fun qlMCLookbackPartialFloatingEngine as mcLookbackPartialFloatingEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCLookbackPartialFloatingEngine as mcLookbackPartialFloatingEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -629,45 +648,45 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for American digital (cash-or-nothing/asset-or-nothing) options-{#fun qlAnalyticDigitalAmericanEngine as analyticDigitalAmericanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticDigitalAmericanEngine as analyticDigitalAmericanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for American knock-out digital (cash-or-nothing/asset-or-nothing) options-{#fun qlAnalyticDigitalAmericanKOEngine as analyticDigitalAmericanKoEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticDigitalAmericanKOEngine as analyticDigitalAmericanKoEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European discrete geometric average-price Asian options-{#fun qlAnalyticDiscreteGeometricAveragePriceAsianEngine as analyticDiscreteGeometricAveragePriceAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticDiscreteGeometricAveragePriceAsianEngine as analyticDiscreteGeometricAveragePriceAsianEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European discrete geometric average-strike Asian options-{#fun qlAnalyticDiscreteGeometricAverageStrikeAsianEngine as analyticDiscreteGeometricAverageStrikeAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticDiscreteGeometricAverageStrikeAsianEngine as analyticDiscreteGeometricAverageStrikeAsianEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Turnbull-Wakeman moment-matching pricing engine for discrete arithmetic average-price\/-strike Asian options-{#fun qlTurnbullWakemanAsianEngine as turnbullWakemanAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlTurnbullWakemanAsianEngine as turnbullWakemanAsianEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for European options with discrete dividends-{#fun qlAnalyticDividendEuropeanEngine as analyticDividendEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withDividendArray*`[Dividend]'&,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticDividendEuropeanEngine as analyticDividendEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',withDividendArray*`[Dividend]'&,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic Black-Scholes pricing engine for European options-{#fun qlAnalyticEuropeanEngine as analyticEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlAnalyticEuropeanEngine as analyticEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountCurve   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for performance (return) options-{#fun qlAnalyticPerformanceEngine as analyticPerformanceEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticPerformanceEngine as analyticPerformanceEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic pricing engine for forward-starting European options; binds the @AnalyticEuropeanEngine@ instantiation of upstream's @ForwardVanillaEngine\<Engine\>@ template-{#fun qlForwardEuropeanEngine as forwardEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlForwardEuropeanEngine as forwardEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Barone-Adesi\/Whaley approximation pricing engine for forward-starting American options; binds the @BaroneAdesiWhaleyApproximationEngine@ instantiation of @ForwardVanillaEngine\<Engine\>@-{#fun qlForwardBaroneAdesiWhaleyEngine as forwardBaroneAdesiWhaleyEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlForwardBaroneAdesiWhaleyEngine as forwardBaroneAdesiWhaleyEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Bjerksund\/Stensland approximation pricing engine for forward-starting American options; binds the @BjerksundStenslandApproximationEngine@ instantiation of @ForwardVanillaEngine\<Engine\>@-{#fun qlForwardBjerksundStenslandEngine as forwardBjerksundStenslandEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlForwardBjerksundStenslandEngine as forwardBjerksundStenslandEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for forward-starting vanilla options, with the wrapped engine's grid\/scheme params fixed at their QuantLib defaults; binds the @FdBlackScholesVanillaEngine@ instantiation of @ForwardVanillaEngine\<Engine\>@-{#fun qlForwardFdBlackScholesVanillaEngine as forwardFdBlackScholesVanillaEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlForwardFdBlackScholesVanillaEngine as forwardFdBlackScholesVanillaEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for forward-starting European options under a Black-Scholes process-{#fun qlMCForwardEuropeanBSEngine1 as mcForwardEuropeanBsEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCForwardEuropeanBSEngine1 as mcForwardEuropeanBsEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -696,35 +715,35 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |quanto-adjusts a European vanilla option's price and greeks for a payoff paid in a currency other than the underlying's; binds the @VanillaOption@\/@AnalyticEuropeanEngine@ instantiation of upstream's @QuantoEngine\<Instr,Engine\>@ template-{#fun qlQuantoEuropeanEngine as quantoEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQuantoEuropeanEngine as quantoEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^foreignRiskFreeRate   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv' -- ^exchangeRateVolatility   ,withQuote*`GenQuote q' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |quanto-adjusts a forward-starting vanilla option; binds the @ForwardVanillaOption@\/@ForwardVanillaEngine\<AnalyticEuropeanEngine\>@ instantiation of @QuantoEngine\<Instr,Engine\>@-{#fun qlQuantoForwardEuropeanEngine as quantoForwardEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQuantoForwardEuropeanEngine as quantoForwardEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^foreignRiskFreeRate   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv' -- ^exchangeRateVolatility   ,withQuote*`GenQuote q' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |quanto-adjusts a forward-starting performance (strike-resetting, percentage-payoff) vanilla option; binds the @ForwardVanillaOption@\/@ForwardPerformanceVanillaEngine\<AnalyticEuropeanEngine\>@ instantiation of @QuantoEngine\<Instr,Engine\>@-{#fun qlQuantoForwardPerformanceEuropeanEngine as quantoForwardPerformanceEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQuantoForwardPerformanceEuropeanEngine as quantoForwardPerformanceEuropeanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^foreignRiskFreeRate   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv' -- ^exchangeRateVolatility   ,withQuote*`GenQuote q' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |quanto-adjusts a single-barrier option; binds the @BarrierOption@\/@AnalyticBarrierEngine@ instantiation of @QuantoEngine\<Instr,Engine\>@-{#fun qlQuantoBarrierEngine as quantoBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQuantoBarrierEngine as quantoBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^foreignRiskFreeRate   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv' -- ^exchangeRateVolatility   ,withQuote*`GenQuote q' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |quanto-adjusts a double-barrier option; binds the @DoubleBarrierOption@\/@AnalyticDoubleBarrierEngine@ instantiation of @QuantoEngine\<Instr,Engine\>@-{#fun qlQuantoDoubleBarrierEngine as quantoDoubleBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQuantoDoubleBarrierEngine as quantoDoubleBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^foreignRiskFreeRate   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv' -- ^exchangeRateVolatility   ,withQuote*`GenQuote q' -- ^correlation@@ -788,7 +807,7 @@ {#fun qlBachelierSwaptionEngine1 as bachelierSwaptionEngineFromVolatilityStructure{withYieldTermStructure*`GenYieldTermStructure y',withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |analytic European option pricer including stochastic interest rates (Black-Scholes-Merton + Hull-White)-{#fun qlAnalyticBSMHullWhiteEngine as analyticBsmHullWhiteEngine{`Double',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withHullWhite*`HullWhite',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticBSMHullWhiteEngine as analyticBsmHullWhiteEngine{`Double',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',withHullWhite*`HullWhite',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |the term structure is only needed when the short-rate model cannot provide one itself. {#fun qlAnalyticCapFloorEngine as analyticCapFloorEngine{withStandalone*`AffineModel',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}@@ -812,6 +831,14 @@   ,fromIntegral`Word' -- ^maxEvaluations   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +-- |Heston/Hull-White approximation engine for European vanilla options. The H1-HW approximation assumes zero variance/short-rate correlation; @rhoSr@ is the equity/short-rate correlation.+{#fun qlAnalyticH1HWEngine as analyticH1HwEngineOrder{withHestonModel*`GenHestonModel hm',withHullWhite*`HullWhite'+  ,`Double' -- ^rhoSr+  ,fromIntegral`Word' -- ^integrationOrder+  ,`Bool' -- ^exactMean+  ,fromIntegral`Word' -- ^meanOrder+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |semi-analytic pricing engine combining a Heston equity model with a Hull-White short-rate model {#fun qlAnalyticHestonHullWhiteEngine as analyticHestonHullWhiteEngineOrder{withHestonModel*`GenHestonModel hm',withHullWhite*`HullWhite'   ,fromIntegral`Word' -- ^integrationOrder@@ -823,7 +850,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |FFT-based pricing engine for vanilla options under a Black-Scholes process-{#fun qlFFTVanillaEngine as fftVanillaEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^logStrikeSpacing+{#fun qlFFTVanillaEngine as fftVanillaEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Double' -- ^logStrikeSpacing   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |swaption pricing engine for the G2 two-factor short-rate model, priced via the Black formula@@ -881,6 +908,14 @@   ,fromIntegral`Word' -- ^maxEvaluations   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +{#fun qlAnalyticH1HWEngine1 as analyticH1HwEngineTolerance{withHestonModel*`GenHestonModel hm',withHullWhite*`HullWhite'+  ,`Double' -- ^rhoSr+  ,`Double' -- ^relTolerance+  ,fromIntegral`Word' -- ^maxEvaluations+  ,`Bool' -- ^exactMean+  ,fromIntegral`Word' -- ^meanOrder+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |Semi-analytic Heston/Hull-White engine with fixed-order or tolerance-based integration. analyticHestonHullWhiteEngine :: GenHestonModel hm -> HullWhite -> IntegrationControl -> IO PricingEngine analyticHestonHullWhiteEngine heston hullWhite control =@@ -888,6 +923,20 @@     IntegrationOrder order -> analyticHestonHullWhiteEngineOrder heston hullWhite order     IntegrationTolerance tolerance evaluations -> analyticHestonHullWhiteEngineTolerance heston hullWhite tolerance evaluations +-- |H1-HW approximation engine with fixed-order or tolerance-based integration. @rhoSr@ must be+-- non-negative. 'ExactMean' uses QuantLib's native variance-root expectation integration when+-- available, otherwise hasquant's backport. 'FittedExponentialMean' delegates to QuantLib's fitted+-- engine: invalid or singular fits can return NaN or throw, depending on the linked version.+analyticH1HwEngine :: GenHestonModel hm -> HullWhite -> Double -> IntegrationControl -> H1HwMean -> IO PricingEngine+analyticH1HwEngine heston hullWhite rhoSr control mean =+  case control of+    IntegrationOrder order -> analyticH1HwEngineOrder heston hullWhite rhoSr order exact meanOrder+    IntegrationTolerance tolerance evaluations -> analyticH1HwEngineTolerance heston hullWhite rhoSr tolerance evaluations exact meanOrder+  where+    (exact, meanOrder) = case mean of+      FittedExponentialMean -> (False, 0)+      ExactMean n -> (True, n)+ -- |semi-analytic Bates-model pricing engine, integrating with a fixed relative tolerance and evaluation cap {#fun qlBatesEngine1 as batesEngineTolerance{withBatesModel*`GenBatesModel bm',`Double' -- ^relTolerance   ,fromIntegral`Word' -- ^maxEvaluations@@ -901,7 +950,7 @@     IntegrationTolerance tolerance evaluations -> batesEngineTolerance model tolerance evaluations  -- |Barone-Adesi and Whaley (1987) quadratic-approximation engine for American options-{#fun qlBaroneAdesiWhaleyApproximationEngine as baroneAdesiWhaleyApproximationEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlBaroneAdesiWhaleyApproximationEngine as baroneAdesiWhaleyApproximationEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  {#fun qlBatesDetJumpEngine1 as batesDetJumpEngineTolerance{withBatesDetJumpModel*`BatesDetJumpModel',`Double' -- ^relTolerance   ,fromIntegral`Word' -- ^maxEvaluations@@ -946,12 +995,12 @@     IntegrationTolerance tolerance evaluations -> batesDoubleExpEngineTolerance model tolerance evaluations  -- |Bjerksund and Stensland (1993) approximation engine for American options-{#fun qlBjerksundStenslandApproximationEngine as bjerksundStenslandApproximationEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlBjerksundStenslandApproximationEngine as bjerksundStenslandApproximationEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |American engine based on the QD+ approximation to the exercise boundary. Mainly a good -- initial guess for the exercise boundary of 'qdFpAmericanEngine'; usable as a standalone -- (lower-accuracy) American pricer on its own.-{#fun qlQdPlusAmericanEngine as qdPlusAmericanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQdPlusAmericanEngine as qdPlusAmericanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,fromIntegral`Word' -- ^interpolationPoints, number of Chebyshev nodes used to interpolate the exercise boundary   ,`SolverType' -- ^solverType, root-finding method used to locate the exercise boundary   ,`Double' -- ^eps, solver accuracy@@ -962,7 +1011,7 @@ -- boundary (Andersen, Lake and Offengenden 2015; Andersen and Lake 2021). 'QdFpScheme' selects -- one of upstream's three built-in 'iterationScheme's ('FastScheme', 'AccurateScheme', -- 'HighPrecisionScheme'), trading speed for accuracy.-{#fun qlQdFpAmericanEngine as qdFpAmericanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlQdFpAmericanEngine as qdFpAmericanEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,`QdFpScheme' -- ^iterationScheme   ,`FixedPointEquation' -- ^fpEquation, which fixed-point formulation of the exercise boundary equation to solve   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}@@ -973,7 +1022,7 @@ -- date (seasoned Asians are not supported). @currentAverage@ is accepted for parity with upstream's -- constructor but is not read by the current implementation (only the not-yet-seasoned case is -- handled), so 'Nothing' is fine.-{#fun qlContinuousArithmeticAsianVecerEngine as continuousArithmeticAsianVecerEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlContinuousArithmeticAsianVecerEngine as continuousArithmeticAsianVecerEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,withMaybeQuote*`Maybe (GenQuote q)' -- ^currentAverage   ,withDay*`Day' -- ^startDate   ,fromIntegral`Word' -- ^timeSteps@@ -983,19 +1032,27 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |CDS pricing engine that integrates the default-leg payoff over the CDS's step-wise schedule+-- |Black-formula CDS-option engine: the option on the forward spread, lognormal at the quoted+-- volatility, scaled by the risky annuity. It assumes the exercise date is the CDS's start date.+{#fun qlBlackCdsOptionEngine as blackCdsOptionEngine{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double' -- ^recoveryRate+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^termStructure+  ,withQuote*`GenQuote q' -- ^volatility+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ {#fun qlIntegralCdsEngine as integralCdsEngine{fromEnumQuantity`(Word,TimeUnit)'& -- ^integrationStep-  ,withGenTermStructure*`DefaultProbabilityTermStructure',`Double' -- ^recoveryRate+  ,withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double' -- ^recoveryRate   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^discountCurve   ,fromMaybeBool`Maybe Bool' -- ^includeSettlementDateFlows   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for European vanilla options using an integral approach-{#fun qlIntegralEngine as integralEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlIntegralEngine as integralEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |the term structure is only needed when the short-rate model cannot provide one itself. {#fun qlJamshidianSwaptionEngine as jamshidianSwaptionEngine{withOneFactorAffineModel*`GenOneFactorAffineModel om',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} --- |swaption pricing engine for any one-factor Gaussian short-rate model, evaluated by integration over the model's state variable+-- |swaption pricing engine for any one-factor Gaussian short-rate model, evaluated by integration over the model's state variable.+-- On QuantLib 1.44 it also prices an 'QuantLib.Instrument.Swap.OvernightIndexedSwap' underlying (see 'QuantLib.Instrument.Swap.swaption'). {#fun qlGaussian1dSwaptionEngine as gaussian1dSwaptionEngine{withStandalone*`Gaussian1dModel'   ,fromIntegral`Int' -- ^integrationPoints   ,`Double' -- ^stddevs@@ -1007,7 +1064,7 @@  -- |As 'gaussian1dSwaptionEngine', for a 'QuantLib.Instrument.Swap.NonstandardSwaption'. Adds -- an optional OAS ('oas', continuously compounded w.r.t. the discount curve's day counter) on--- top of the shared parameters.+-- top of the shared parameters. Overnight-indexed floating coupons are compounded on QuantLib 1.44. {#fun qlGaussian1dNonstandardSwaptionEngine as gaussian1dNonstandardSwaptionEngine{withStandalone*`Gaussian1dModel'   ,fromIntegral`Int' -- ^integrationPoints   ,`Double' -- ^stddevs@@ -1033,18 +1090,18 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |swaption pricing engine using Jamshidian's decomposition, for any one-factor Gaussian--- short-rate model.+-- short-rate model. QuantLib 1.44 freezes a floating payment lag's convexity at time zero. {#fun qlGaussian1dJamshidianSwaptionEngine as gaussian1dJamshidianSwaptionEngine{withStandalone*`Gaussian1dModel',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Ju (1999) quadratic-approximation engine for American options-{#fun qlJuQuadraticApproximationEngine as juQuadraticApproximationEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlJuQuadraticApproximationEngine as juQuadraticApproximationEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for a spread option on two futures/assets {#fun qlKirkEngine as kirkEngine{withBlackProcess*`BlackProcess',withBlackProcess*`BlackProcess',`Double' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |CDS pricing engine using the mid-point approximation, evaluating the default leg at the mid-point of each accrual period-{#fun qlMidPointCdsEngine as midPointCdsEngine{withGenTermStructure*`DefaultProbabilityTermStructure',`Double' -- ^recoveryRate+{#fun qlMidPointCdsEngine as midPointCdsEngine{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double' -- ^recoveryRate   ,withYieldTermStructure*`GenYieldTermStructure y'   ,fromMaybeBool`Maybe Bool' -- ^includeSettlementDateFlows   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}@@ -1068,7 +1125,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |CDS pricing engine implementing the ISDA standard model-{#fun qlIsdaCdsEngine as isdaCdsEngine{withGenTermStructure*`DefaultProbabilityTermStructure',`Double' -- ^recoveryRate+{#fun qlIsdaCdsEngine as isdaCdsEngine{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double' -- ^recoveryRate   ,withYieldTermStructure*`GenYieldTermStructure y'   ,fromMaybeBool`Maybe Bool' -- ^includeSettlementDateFlows   ,`NumericalFix' -- ^numericalFix@@ -1077,46 +1134,46 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |variance-swap pricing engine using a replicating portfolio of vanilla options at the given strikes-{#fun qlReplicatingVarianceSwapEngine as replicatingVarianceSwapEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^dk+{#fun qlReplicatingVarianceSwapEngine as replicatingVarianceSwapEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Double' -- ^dk   ,withNonEmptyDoubleArray*`NonEmpty Double'& -- ^callStrikes   ,withNonEmptyDoubleArray*`NonEmpty Double'& -- ^putStrikes   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for 2D European basket options (Stulz formula)-{#fun qlStulzEngine as stulzEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlStulzEngine as stulzEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Bjerksund-Stensland (2014) closed-form pricing engine for a spread option on two futures-{#fun qlBjerksundStenslandSpreadEngine as bjerksundStenslandSpreadEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlBjerksundStenslandSpreadEngine as bjerksundStenslandSpreadEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Chi-Fai Lo (2015) operator-splitting-approximation pricing engine for a spread option-{#fun qlOperatorSplittingSpreadEngine as operatorSplittingSpreadEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlOperatorSplittingSpreadEngine as operatorSplittingSpreadEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,`OperatorSplittingOrder' -- ^order, upstream default: 'Second'   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Pearson (1995) 1-D-numerical-integration pricing engine for a spread option-{#fun qlPearsonSpreadEngine as pearsonSpreadEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlPearsonSpreadEngine as pearsonSpreadEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,`Double' -- ^integrationTolerance, upstream default: 1e-10   ,fromIntegral`Word' -- ^maxIntegrationIterations, upstream default: 10000   ,`Double' -- ^nStd, upstream default: 8.0   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Gaussian-copula nested-Gauss-Hermite-quadrature pricing engine for a spread option with smile-implied marginals-{#fun qlGaussianCopulaSpreadEngine as gaussianCopulaSpreadEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlGaussianCopulaSpreadEngine as gaussianCopulaSpreadEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,fromIntegral`Word' -- ^nPoints, upstream default: 64   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Choi (2018) \"sum of Black-Scholes-Merton models\" pricing engine for a basket option on -- multiple underlyings, correlated via @rho@-choiBasketEngine :: NonEmpty GeneralizedBlackScholesProcess -> Matrix Double -- ^correlation matrix rho+choiBasketEngine :: NonEmpty (GenGeneralizedBlackScholesProcess gbs) -> Matrix Double -- ^correlation matrix rho   -> Double -- ^lambda, upstream default: 10.0   -> Word -- ^maxNrIntegrationSteps, upstream default: unbounded; the C shim takes a 32-bit count   -> Bool -- ^calcfwdDelta   -> Bool -- ^controlVariate   -> IO PricingEngine choiBasketEngine ps (Matrix mr mc md) = qlChoiBasketEngine (toList ps) mr mc md-{#fun qlChoiBasketEngine{withGeneralizedBlackScholesProcessArray*`[GeneralizedBlackScholesProcess]'&+{#fun qlChoiBasketEngine{withGeneralizedBlackScholesProcessArray*`[GenGeneralizedBlackScholesProcess gbs]'&   ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,`Double' -- ^lambda   ,fromIntegral`Word' -- ^maxNrIntegrationSteps@@ -1126,19 +1183,19 @@  -- |Deng-Li-Zhou (2008) closed-form-approximation pricing engine for a spread option on multiple -- underlyings, correlated via @rho@-dengLiZhouBasketEngine :: NonEmpty GeneralizedBlackScholesProcess -> Matrix Double -- ^correlation matrix rho+dengLiZhouBasketEngine :: NonEmpty (GenGeneralizedBlackScholesProcess gbs) -> Matrix Double -- ^correlation matrix rho   -> IO PricingEngine dengLiZhouBasketEngine ps (Matrix mr mc md) = qlDengLiZhouBasketEngine (toList ps) mr mc md-{#fun qlDengLiZhouBasketEngine{withGeneralizedBlackScholesProcessArray*`[GeneralizedBlackScholesProcess]'&+{#fun qlDengLiZhouBasketEngine{withGeneralizedBlackScholesProcessArray*`[GenGeneralizedBlackScholesProcess gbs]'&   ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for a basket where all underlyings are driven by one stochastic factor-singleFactorBsmBasketEngine :: NonEmpty GeneralizedBlackScholesProcess+singleFactorBsmBasketEngine :: NonEmpty (GenGeneralizedBlackScholesProcess gbs)   -> Double -- ^xTol, upstream default: @1e4*QL_EPSILON@   -> IO PricingEngine singleFactorBsmBasketEngine ps = qlSingleFactorBsmBasketEngine (toList ps)-{#fun qlSingleFactorBsmBasketEngine{withGeneralizedBlackScholesProcessArray*`[GeneralizedBlackScholesProcess]'&+{#fun qlSingleFactorBsmBasketEngine{withGeneralizedBlackScholesProcessArray*`[GenGeneralizedBlackScholesProcess gbs]'&   ,`Double' -- ^xTol   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -1193,7 +1250,7 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |two-dimensional finite-differences Black-Scholes basket-option pricing engine-{#fun qlFd2dBlackScholesVanillaEngine as fd2dBlackScholesVanillaEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^correlation+{#fun qlFd2dBlackScholesVanillaEngine as fd2dBlackScholesVanillaEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs1',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs2',`Double' -- ^correlation   ,fromIntegral`Word' -- ^xGrid, upstream default: 100   ,fromIntegral`Word' -- ^yGrid, upstream default: 100   ,fromIntegral`Word' -- ^tGrid, upstream default: 50@@ -1205,14 +1262,14 @@  -- |n-dimensional finite-differences Black-Scholes basket-option pricing engine, with an explicit -- per-axis grid size-fdndimBlackScholesVanillaEngineAxisGrids :: NonEmpty GeneralizedBlackScholesProcess -> Matrix Double -- ^correlation matrix rho+fdndimBlackScholesVanillaEngineAxisGrids :: NonEmpty (GenGeneralizedBlackScholesProcess gbs) -> Matrix Double -- ^correlation matrix rho   -> NonEmpty Word -- ^xGrids, one per underlying   -> Word -- ^tGrid, upstream default: 50   -> Word -- ^dampingSteps, upstream default: 0   -> FdmScheme -- ^schemeDesc, upstream default: 'Douglas'   -> IO PricingEngine fdndimBlackScholesVanillaEngineAxisGrids ps (Matrix mr mc md) xGrids = qlFdndimBlackScholesVanillaEngine (toList ps) mr mc md (toList xGrids)-{#fun qlFdndimBlackScholesVanillaEngine{withGeneralizedBlackScholesProcessArray*`[GeneralizedBlackScholesProcess]'&+{#fun qlFdndimBlackScholesVanillaEngine{withGeneralizedBlackScholesProcessArray*`[GenGeneralizedBlackScholesProcess gbs]'&   ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,withIntArray*`[Word]'&   ,fromIntegral`Word' -- ^tGrid@@ -1222,14 +1279,14 @@  -- |n-dimensional finite-differences Black-Scholes basket-option pricing engine, auto-scaling every -- axis' grid from a single size (largest eigenvalue gets @xGrid@)-fdndimBlackScholesVanillaEngineUniformGrid :: NonEmpty GeneralizedBlackScholesProcess -> Matrix Double -- ^correlation matrix rho+fdndimBlackScholesVanillaEngineUniformGrid :: NonEmpty (GenGeneralizedBlackScholesProcess gbs) -> Matrix Double -- ^correlation matrix rho   -> Word -- ^xGrid   -> Word -- ^tGrid, upstream default: 50   -> Word -- ^dampingSteps, upstream default: 0   -> FdmScheme -- ^schemeDesc, upstream default: 'Douglas'   -> IO PricingEngine fdndimBlackScholesVanillaEngineUniformGrid ps (Matrix mr mc md) = qlFdndimBlackScholesVanillaEngine1 (toList ps) mr mc md-{#fun qlFdndimBlackScholesVanillaEngine1{withGeneralizedBlackScholesProcessArray*`[GeneralizedBlackScholesProcess]'&+{#fun qlFdndimBlackScholesVanillaEngine1{withGeneralizedBlackScholesProcessArray*`[GenGeneralizedBlackScholesProcess gbs]'&   ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]'   ,fromIntegral`Word' -- ^xGrid   ,fromIntegral`Word' -- ^tGrid@@ -1238,7 +1295,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |N-dimensional Black-Scholes finite-difference engine with uniform or per-axis grids.-fdndimBlackScholesVanillaEngine :: NonEmpty GeneralizedBlackScholesProcess -> Matrix Double+fdndimBlackScholesVanillaEngine :: NonEmpty (GenGeneralizedBlackScholesProcess gbs) -> Matrix Double   -> FdmGrid -> Word -> Word -> FdmScheme -> IO PricingEngine fdndimBlackScholesVanillaEngine processes correlations grid =   case grid of@@ -1261,7 +1318,7 @@   ,withFdmSchemeDesc*`FdmScheme',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes barrier-option pricing engine-{#fun qlFdBlackScholesBarrierEngine as fdBlackScholesBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^tGrid+{#fun qlFdBlackScholesBarrierEngine as fdBlackScholesBarrierEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^tGrid   ,fromIntegral`Word' -- ^xGrid   ,fromIntegral`Word' -- ^dampingSteps   ,withFdmSchemeDesc*`FdmScheme'@@ -1324,7 +1381,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo (least-squares) pricing engine for American options-{#fun qlMCAmericanEngine1 as mcAmericanEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word', -- ^timeSteps+{#fun qlMCAmericanEngine1 as mcAmericanEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word', -- ^timeSteps   fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^antitheticVariate   ,`Bool' -- ^controlVariate@@ -1339,7 +1396,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for barrier options-{#fun qlMCBarrierEngine1 as mcBarrierEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCBarrierEngine1 as mcBarrierEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -1351,7 +1408,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for digital (cash-or-nothing/asset-or-nothing) options-{#fun qlMCDigitalEngine1 as mcDigitalEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCDigitalEngine1 as mcDigitalEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word', -- ^timeStepsPerYear   `Bool', -- ^brownianBridge   `Bool', -- ^antitheticVariate@@ -1362,7 +1419,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for discrete arithmetic average-price Asian options-{#fun qlMCDiscreteArithmeticAPEngine1 as mcDiscreteArithmeticApEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Bool' -- ^brownianBridge+{#fun qlMCDiscreteArithmeticAPEngine1 as mcDiscreteArithmeticApEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate   ,`Bool' -- ^controlVariate   ,fromMaybeInt`Maybe Word' -- ^requiredSamples@@ -1372,7 +1429,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for discrete arithmetic average-strike Asian options-{#fun qlMCDiscreteArithmeticASEngine1 as mcDiscreteArithmeticAsEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Bool' -- ^brownianBridge+{#fun qlMCDiscreteArithmeticASEngine1 as mcDiscreteArithmeticAsEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate   ,fromMaybeInt`Maybe Word' -- ^requiredSamples   ,fromMaybeDouble`Maybe Double' -- ^requiredTolerance@@ -1381,7 +1438,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for discrete geometric average-price Asian options-{#fun qlMCDiscreteGeometricAPEngine1 as mcDiscreteGeometricApEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Bool' -- ^brownianBridge+{#fun qlMCDiscreteGeometricAPEngine1 as mcDiscreteGeometricApEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate   ,fromMaybeInt`Maybe Word' -- ^requiredSamples   ,fromMaybeDouble`Maybe Double' -- ^requiredTolerance@@ -1418,7 +1475,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for European options under a Black-Scholes process-{#fun qlMCEuropeanEngine1 as mcEuropeanEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCEuropeanEngine1 as mcEuropeanEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -1520,7 +1577,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Monte Carlo pricing engine for performance (return) options-{#fun qlMCPerformanceEngine1 as mcPerformanceEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Bool' -- ^brownianBridge+{#fun qlMCPerformanceEngine1 as mcPerformanceEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate   ,fromMaybeInt`Maybe Word' -- ^requiredSamples   ,fromMaybeDouble`Maybe Double' -- ^requiredTolerance@@ -1530,7 +1587,7 @@  -- |variance-swap pricing engine using Monte Carlo simulation (see the note above -- 'mcHestonHullWhiteEngine' for the 'StatisticsTrait' parameter shared by every MC engine here).-{#fun qlMCVarianceSwapEngine1 as mcVarianceSwapEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+{#fun qlMCVarianceSwapEngine1 as mcVarianceSwapEngine{`RngTrait',`StatisticsTrait',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromMaybeInt`Maybe Word' -- ^timeSteps   ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear   ,`Bool' -- ^brownianBridge   ,`Bool' -- ^antitheticVariate@@ -1541,18 +1598,18 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |pricing engine for vanilla options using binomial trees-{#fun qlBinomialVanillaEngine as binomialVanillaEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^timeSteps+{#fun qlBinomialVanillaEngine as binomialVanillaEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^timeSteps   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for discrete-averaging Asian options-{#fun qlFdBlackScholesAsianEngine as fdBlackScholesAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^tGrid+{#fun qlFdBlackScholesAsianEngine as fdBlackScholesAsianEngine{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^tGrid   ,fromIntegral`Word' -- ^xGrid   ,fromIntegral`Word' -- ^aGrid   ,withFdmSchemeDesc*`FdmScheme'   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for vanilla options-{#fun qlFdBlackScholesVanillaEngine as fdBlackScholesVanillaEngineNoDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromIntegral`Word' -- ^timeSteps+{#fun qlFdBlackScholesVanillaEngine as fdBlackScholesVanillaEngineNoDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',fromIntegral`Word' -- ^timeSteps   ,fromIntegral`Word' -- ^gridPoints   ,fromIntegral`Word' -- ^timeDependent   ,withFdmSchemeDesc*`FdmScheme'@@ -1562,7 +1619,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for vanilla options, with discrete dividends-{#fun qlFdBlackScholesVanillaEngine1 as fdBlackScholesVanillaEngineWithDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withDividendArray*`[Dividend]'&+{#fun qlFdBlackScholesVanillaEngine1 as fdBlackScholesVanillaEngineWithDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',withDividendArray*`[Dividend]'&   ,fromIntegral`Word' -- ^timeSteps   ,fromIntegral`Word' -- ^gridPoints   ,fromIntegral`Word' -- ^timeDependent@@ -1573,7 +1630,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Finite-difference Black-Scholes vanilla engine; @[]@ selects no-dividend behavior.-fdBlackScholesVanillaEngine :: GeneralizedBlackScholesProcess -> [Dividend] -> Word -> Word -> Word+fdBlackScholesVanillaEngine :: GenGeneralizedBlackScholesProcess gbs -> [Dividend] -> Word -> Word -> Word   -> FdmScheme -> Bool -> Double -> CashDividendModel -> IO PricingEngine fdBlackScholesVanillaEngine process dividends =   case dividends of@@ -1581,7 +1638,7 @@     _ -> fdBlackScholesVanillaEngineWithDividends process dividends  -- |finite-differences Black-Scholes pricing engine for vanilla options, with quanto adjustment-{#fun qlFdBlackScholesVanillaEngine2 as fdBlackScholesVanillaEngineQuantoNoDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withMaybeFdmQuantoHelper*`Maybe FdmQuantoHelper'+{#fun qlFdBlackScholesVanillaEngine2 as fdBlackScholesVanillaEngineQuantoNoDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',withMaybeFdmQuantoHelper*`Maybe FdmQuantoHelper'   ,fromIntegral`Word' -- ^timeSteps   ,fromIntegral`Word' -- ^gridPoints   ,fromIntegral`Word' -- ^timeDependent@@ -1592,7 +1649,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for vanilla options, with discrete dividends and quanto adjustment-{#fun qlFdBlackScholesVanillaEngine3 as fdBlackScholesVanillaEngineQuantoWithDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withDividendArray*`[Dividend]'&,withMaybeFdmQuantoHelper*`Maybe FdmQuantoHelper'+{#fun qlFdBlackScholesVanillaEngine3 as fdBlackScholesVanillaEngineQuantoWithDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',withDividendArray*`[Dividend]'&,withMaybeFdmQuantoHelper*`Maybe FdmQuantoHelper'   ,fromIntegral`Word' -- ^timeSteps   ,fromIntegral`Word' -- ^gridPoints   ,fromIntegral`Word' -- ^timeDependent@@ -1603,7 +1660,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Quanto-adjusted Black-Scholes vanilla engine; @[]@ selects no-dividend behavior.-fdBlackScholesVanillaEngineQuanto :: GeneralizedBlackScholesProcess -> [Dividend]+fdBlackScholesVanillaEngineQuanto :: GenGeneralizedBlackScholesProcess gbs -> [Dividend]   -> Maybe FdmQuantoHelper -> Word -> Word -> Word -> FdmScheme -> Bool -> Double   -> CashDividendModel -> IO PricingEngine fdBlackScholesVanillaEngineQuanto process dividends =@@ -1680,7 +1737,7 @@     _ -> fdBatesVanillaEngineWithDividends model dividends  -- |Finite-difference Black-Scholes engine for American shout options.-{#fun qlFdBlackScholesShoutEngine as fdBlackScholesShoutEngineNoDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process+{#fun qlFdBlackScholesShoutEngine as fdBlackScholesShoutEngineNoDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs' -- ^process   ,fromIntegral`Word' -- ^tGrid   ,fromIntegral`Word' -- ^xGrid   ,fromIntegral`Word' -- ^dampingSteps@@ -1688,7 +1745,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Finite-difference Black-Scholes engine for American shout options with discrete dividends.-{#fun qlFdBlackScholesShoutEngine1 as fdBlackScholesShoutEngineWithDividends{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process+{#fun qlFdBlackScholesShoutEngine1 as fdBlackScholesShoutEngineWithDividends{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs' -- ^process   ,withDividendArray*`[Dividend]'& -- ^dividends   ,fromIntegral`Word' -- ^tGrid   ,fromIntegral`Word' -- ^xGrid@@ -1697,7 +1754,7 @@   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |Finite-difference Black-Scholes shout engine; @[]@ selects no-dividend behavior.-fdBlackScholesShoutEngine :: GeneralizedBlackScholesProcess -> [Dividend] -> Word -> Word+fdBlackScholesShoutEngine :: GenGeneralizedBlackScholesProcess gbs -> [Dividend] -> Word -> Word   -> Word -> FdmScheme -> IO PricingEngine fdBlackScholesShoutEngine process dividends =   case dividends of@@ -1768,7 +1825,7 @@     _ -> fdHestonHullWhiteVanillaEngineWithDividends heston hullWhite dividends  -- |binomial Tsiveriotis-Fernandes pricing engine for convertible bonds-{#fun qlBinomialConvertibleEngine as binomialConvertibleEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess'+{#fun qlBinomialConvertibleEngine as binomialConvertibleEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'   ,fromIntegral`Word' -- ^timeSteps   ,withQuote*`GenQuote q' -- ^creditSpread   ,withDividendArray*`[Dividend]'& -- ^dividends@@ -2115,7 +2172,6 @@   ,`Double' -- ^displacement   ,preErrorCheck-`String'errorCheck*-}->`Double'#} - -- |Black 1976 probability of being in the money (in the bond martingale measure), i.e. N(d2). It is a risk-neutral probability, not the real world one. /Warning/ instead of volatility it uses standard deviation, i.e. volatility*sqrt(timeToMaturity) {#fun qlQuantLibBlackFormulaCashItmProbability as blackCashItmProbability{fromEnumC`OptionType',`Double'   ,`Double' -- ^forward@@ -2353,7 +2409,7 @@   ,`Double' -- ^beta   ,`Double' -- ^shift   ,`VolatilityType' -- ^volatilityType-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Black 1976 option-price calculator.@@ -2374,5 +2430,139 @@ bachelierCalculator spec = case spec of   Strike t k -> bachelierCalculatorAtStrikeRaw t k   StrikePayoff p -> bachelierCalculatorFromPayoffRaw p++-- |Fractional Riccati solver. Pade is most accurate for strongly negative correlation.+data RoughHestonApproximation = AdamsPredictorCorrector | Pade | Lifted Word deriving (Eq, Show, Read)+-- |Construction-time Fourier integration configuration for Rough Heston (1.44).+data FourierIntegration+  = FourierGaussLaguerre Word | FourierGaussLegendre Word+  | FourierGaussChebyshev Word | FourierGaussChebyshev2nd Word+  | FourierGaussLobatto Double Double Word Bool+  | FourierGaussKronrod Double Word | FourierSimpson Double Word | FourierTrapezoid Double Word+  | FourierDiscreteSimpson Word | FourierDiscreteTrapezoid Word+  | FourierExpSinh Double | FourierTanhSinh Double+  deriving (Eq, Show, Read)+roughApproximation :: RoughHestonApproximation -> (Int, Word)+roughApproximation AdamsPredictorCorrector = (0, 20)+roughApproximation Pade = (1, 20)+roughApproximation (Lifted factors) = (2, factors)+fourierConfiguration :: FourierIntegration -> (Int, Word, Double, Double, Bool)+fourierConfiguration integration = case integration of+  FourierGaussLaguerre n -> (0, n, 0, 0, False)+  FourierGaussLegendre n -> (1, n, 0, 0, False)+  FourierGaussChebyshev n -> (2, n, 0, 0, False)+  FourierGaussChebyshev2nd n -> (3, n, 0, 0, False)+  FourierGaussLobatto r a n c -> (4, n, r, a, c)+  FourierGaussKronrod a n -> (5, n, 0, a, False)+  FourierSimpson a n -> (6, n, 0, a, False)+  FourierTrapezoid a n -> (7, n, 0, a, False)+  FourierDiscreteSimpson n -> (8, n, 0, 0, False)+  FourierDiscreteTrapezoid n -> (9, n, 0, 0, False)+  FourierExpSinh r -> (10, 0, r, 0, False)+  FourierTanhSinh r -> (11, 0, r, 0, False)++-- |European vanilla engine with Gauss-Laguerre integration (1.44).+-- Upstream defaults are order 128 and 256 Riccati steps; Adams costs O(steps^2).+analyticRoughHestonEngine :: RoughHestonModel -- ^Calibrated model+  -> Word -- ^Gauss-Laguerre integration order+  -> Word -- ^Riccati time steps+  -> RoughHestonApproximation -- ^Riccati approximation and lifted factor count+  -> IO AnalyticRoughHestonEngine+analyticRoughHestonEngine model order steps approximation =+  let (method, factors) = roughApproximation approximation+  in roughHestonEngineRaw model order steps method factors+-- |Native fixed-order construction.+{#fun qlAnalyticRoughHestonEngine as roughHestonEngineRaw{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,fromIntegral`Word' -- ^integrationOrder+  ,fromIntegral`Word' -- ^timeSteps+  ,`Int' -- ^approximation+  ,fromIntegral`Word' -- ^nFactors+  ,preErrorCheck-`String'errorCheck*-}->`AnalyticRoughHestonEngine'peekAnalyticRoughHestonEngine*#}++-- |European engine with full Fourier integration controls (1.44).+-- Upstream defaults: steps 256, epsilon 1e-25, dampening alpha -0.5; alpha must be in (-1, 0).+analyticRoughHestonEngineWithIntegration :: RoughHestonModel -- ^Calibrated model+  -> FourierIntegration -- ^Integration algorithm and tolerances/order+  -> Word -- ^Riccati time steps+  -> Double -- ^Andersen-Piterbarg integration-limit epsilon+  -> Double -- ^Dampening alpha, strictly between -1 and 0+  -> RoughHestonApproximation -- ^Riccati approximation and lifted factor count+  -> IO AnalyticRoughHestonEngine+analyticRoughHestonEngineWithIntegration model integration steps epsilon dampening approximation =+  let (algorithm, count, relative, absolute, convergence) = fourierConfiguration integration+      (method, factors) = roughApproximation approximation+  in roughHestonEngineIntegrationRaw model algorithm count relative absolute convergence steps epsilon dampening method factors+-- |Native integration construction.+{#fun qlAnalyticRoughHestonEngineWithIntegration as roughHestonEngineIntegrationRaw{withRoughHestonModel*`RoughHestonModel' -- ^model+  ,`Int' -- ^algorithm+  ,fromIntegral`Word' -- ^count+  ,`Double' -- ^relative+  ,`Double' -- ^absolute+  ,`Bool' -- ^convergence+  ,fromIntegral`Word' -- ^timeSteps+  ,`Double' -- ^epsilon+  ,`Double' -- ^alpha+  ,`Int' -- ^approximation+  ,fromIntegral`Word' -- ^nFactors+  ,preErrorCheck-`String'errorCheck*-}->`AnalyticRoughHestonEngine'peekAnalyticRoughHestonEngine*#}++-- |Normalized log-forward chF at time in years (1.44).+{#fun qlRoughHestonchF as roughHestonCharacteristicFunction{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,withComplex`Complex Double'& -- ^frequency+  ,`Double' -- ^time+  ,preComplex-`Complex Double'&peekComplex* -- ^result+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Normalized log-forward lnChF at time in years (1.44).+{#fun qlRoughHestonlnChF as roughHestonLogCharacteristicFunction{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,withComplex`Complex Double'& -- ^frequency+  ,`Double' -- ^time+  ,preComplex-`Complex Double'&peekComplex* -- ^result+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Normalized log-forward riccatiSolution at time in years (1.44).+{#fun qlRoughHestonriccatiSolution as roughHestonRiccatiSolution{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,withComplex`Complex Double'& -- ^frequency+  ,`Double' -- ^time+  ,preComplex-`Complex Double'&peekComplex* -- ^result+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Fourier evaluations in the most recent pricing calculation (1.44).+{#fun qlRoughHestonNumberOfEvaluations as roughHestonNumberOfEvaluations{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,preErrorCheck-`String'errorCheck*-}->`Word'fromIntegral#}++-- |Native direct European pricing.+{#fun qlRoughHestonPriceDate as roughHestonPriceDateRaw{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,withPlainVanillaPayoff*`PlainVanillaPayoff' -- ^payoff+  ,withDay*`Day' -- ^maturity+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Native direct European pricing.+{#fun qlRoughHestonPriceTime as roughHestonPriceTimeRaw{withAnalyticRoughHestonEngine*`AnalyticRoughHestonEngine' -- ^engine+  ,withPlainVanillaPayoff*`PlainVanillaPayoff' -- ^payoff+  ,`Double' -- ^maturity+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Direct European plain-vanilla pricing at a maturity date or time in years (1.44).+roughHestonPriceVanillaPayoff :: AnalyticRoughHestonEngine -- ^Engine+  -> PlainVanillaPayoff -- ^Call/put and strike+  -> TermPoint -- ^Maturity; time is relative to the model risk-free curve's reference date+  -> IO Double+roughHestonPriceVanillaPayoff engine payoff maturity = case maturity of+  DatePoint date -> roughHestonPriceDateRaw engine payoff date+  TimePoint time -> roughHestonPriceTimeRaw engine payoff time++-- |MTM cross-currency discounting (1.44). Spot is domestic currency per foreign currency.+-- Historical reset observations come from ExchangeRateManager; live leg cash flows need their own FX reset pricer.+{#fun qlDiscountingMtMCrossCurrencyBasisSwapEngine as discountingMtmCrossCurrencyBasisSwapEngine{withCurrency*`Currency' -- ^domesticCcy+  ,withYieldTermStructure*`GenYieldTermStructure y1' -- ^domesticCurve+  ,withCurrency*`Currency' -- ^foreignCcy+  ,withYieldTermStructure*`GenYieldTermStructure y2' -- ^foreignCurve+  ,withQuote*`GenQuote q' -- ^spotFx+  ,fromMaybeBool`Maybe Bool' -- ^includeSettlementDateFlows+  ,withMaybeDay*`Maybe Day' -- ^settlementDate+  ,withMaybeDay*`Maybe Day' -- ^npvDate+  ,withMaybeDay*`Maybe Day' -- ^spotFxSettleDate+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -115,7 +115,6 @@ import QuantLib.Internal import QuantLib.Internal.Type import Data.List.NonEmpty(NonEmpty, toList)-import Foreign.Ptr(FunPtr)  {#enum ProcessDiscretization{} deriving(Show,Eq, Read)#} {#enum ExtendedBlackScholesMertonProcessDiscretization{} deriving(Show, Eq, Read)#}@@ -243,15 +242,15 @@   {`Double' -- ^speed   ,`Double' -- ^sigma (volatility)   ,`Double' -- ^x0-  ,id`FunPtr PayoffFun'+  ,withCallbackPtr*`Callback'   ,`ExtendedOrnsteinUhlenbeckProcessDiscretization'   ,`Double' -- ^intEps   ,preErrorCheck-`String'errorCheck*-}->`ExtendedOrnsteinUhlenbeckProcess'peekExtendedOrnsteinUhlenbeckProcess*#}  -- |An extended Ornstein-Uhlenbeck process @dx = speed*(b(t) - x)dt + sigma*dW@ with an arbitrary -- deterministic mean-reversion level @b@, usable with 'QuantLib.Method.pathGenerator'. The--- 'FunPtr' backing @b@ is kept alive only for the continuation's duration. The process and any--- dependent process must not escape it (same rule as 'QuantLib.Quote.withDerivedQuote').+-- process and its native dependents retain @b@ after the continuation returns.+-- Callback exceptions are rethrown by the enclosing Haskell call. withExtendedOrnsteinUhlenbeckProcess :: Double -- ^speed   -> Double -- ^sigma   -> Double -- ^x0@@ -279,7 +278,7 @@  -- |Kluge model: an extended Ornstein-Uhlenbeck process plus an exponential-jump component, -- S = exp(X + Y) with dX = alpha (mu(t) - X) dt + sigma dW and dY = -beta Y dt + J dN. When the--- extended process is callback-backed, this result must remain inside the same continuation.+-- extended process is callback-backed, this result retains its callback. {#fun qlExtOUWithJumpsProcess as extOuWithJumpsProcess{withGenStochasticProcess1D*`ExtendedOrnsteinUhlenbeckProcess',`Double' -- ^Y0   ,`Double' -- ^beta   ,`Double' -- ^jumpIntensity@@ -369,14 +368,14 @@  -- |the process's state at time 0, e.g. @(0, 0)@ for a curveless 'g2Process' or -- @(phi(0), 0)@ once a term structure is given.-{#fun qlStochasticProcessInitialValues as initialValues{withStochasticProcess*`GenStochasticProcess p',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlStochasticProcessInitialValues as initialValues{withStochasticProcess*`GenStochasticProcess p',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the drift part of the process's SDE at state /x/ and time /t/, i.e. @mu(t, x_t)@ in -- @dx_t = mu(t, x_t) dt + sigma(t, x_t) dW_t@. {#fun qlStochasticProcessDrift as drift{withStochasticProcess*`GenStochasticProcess p'   ,`Double' -- ^t   ,withDoubleArray*`[Double]'& -- ^x-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  toMatrixDouble :: (Word, Word, [Double]) -> Matrix Double@@ -389,7 +388,7 @@ {#fun qlStochasticProcessDiffusion{withStochasticProcess*`GenStochasticProcess p'   ,`Double' -- ^t   ,withDoubleArray*`[Double]'& -- ^x-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |E[x_(t0+dt) | x_t0 = x0], the expected state at /t0+dt/ given state /x0/ at time /t0/.@@ -397,7 +396,7 @@   ,`Double' -- ^t0   ,withDoubleArray*`[Double]'& -- ^x0   ,`Double' -- ^dt-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the standard deviation matrix of the process over /dt/ given state /x0/ at time /t0/, i.e.@@ -410,7 +409,7 @@   ,`Double' -- ^t0   ,withDoubleArray*`[Double]'& -- ^x0   ,`Double' -- ^dt-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the covariance matrix of the process over /dt/ given state /x0/ at time /t0/; equals@@ -421,7 +420,7 @@   ,`Double' -- ^t0   ,withDoubleArray*`[Double]'& -- ^x0   ,`Double' -- ^dt-  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preArray-`[Double]'&peekDoubleArray*+  ,prePtr-`Word'peekWord*,prePtr-`Word'peekWord*,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |applies an increment /dx/ to a state /x0/ in the process's own state space -- not always@@ -430,7 +429,7 @@ {#fun qlStochasticProcessApply as apply{withStochasticProcess*`GenStochasticProcess p'   ,withDoubleArray*`[Double]'& -- ^x0   ,withDoubleArray*`[Double]'& -- ^dx-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |one discretized step of the process: the state at /t0+dt/ given state /x0/ at /t0/ and the@@ -446,7 +445,7 @@   ,withDoubleArray*`[Double]'& -- ^x0   ,`Double' -- ^dt   ,withDoubleArray*`[Double]'& -- ^dw-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Geman-Roncoroni process, a mean-reverting jump-diffusion model for electricity spot prices@@ -610,12 +609,12 @@  -- |the reset (fixing) dates of the forward rates this process evolves {#fun qlLiborForwardModelProcessFixingDates as fixingDates{withGenStochasticProcess*`LiborForwardModelProcess'-  ,preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the reset (fixing) times of the forward rates this process evolves, in the process's own -- day count fraction from the evaluation date {#fun qlLiborForwardModelProcessFixingTimes as fixingTimes{withGenStochasticProcess*`LiborForwardModelProcess'-  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+  ,preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the leg of Ibor coupons (notional @amount@ each) this process's forward rates reset -- used -- e.g. to build the 'QuantLib.Instrument.CapFloor.cap' this process prices via 'liborForwardModel'@@ -633,7 +632,7 @@ -- individual one-period factors. {#fun qlLiborForwardModelProcessDiscountBond as discountBond{withGenStochasticProcess*`LiborForwardModelProcess'   ,withDoubleArray*`[Double]'& -- ^rates-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |the @(start, end)@ accrual times of the forward rates this process evolves, in its own day@@ -642,8 +641,8 @@ accrualTimes :: LiborForwardModelProcess -> IO [(Double, Double)] accrualTimes p = uncurry zip <$> qlLiborForwardModelProcessAccrualTimes p {#fun qlLiborForwardModelProcessAccrualTimes{withGenStochasticProcess*`LiborForwardModelProcess'-  ,preArray-`[Double]'&peekDoubleArray*-  ,preArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*+  ,preDoubleArray-`[Double]'&peekDoubleArray*   ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Merton (1976) jump-diffusion process: a Black-Scholes process plus a log-normal jump@@ -681,7 +680,7 @@ {#fun qlStochasticProcessArray{withStochasticProcess1DArray*`[GenStochasticProcess1D p1d]'&,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]',preErrorCheck-`String'errorCheck*-}->`StochasticProcessArray'peekStochasticProcessArray*#}  -- |default theta calculation for Black-Scholes options-{#fun qlQuantLibBlackScholesTheta as thetaAt{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',`Double' -- ^value+{#fun qlQuantLibBlackScholesTheta as thetaAt{withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs',`Double' -- ^value   ,`Double' -- ^delta   ,`Double' -- ^gamma   ,preErrorCheck-`String'errorCheck*-}->`Double'#}

@@ -48,7 +48,6 @@   , isValid   , futuresValue   ) where-import Foreign.Ptr(FunPtr)  import QuantLib.Internal import QuantLib.Internal.Common@@ -190,31 +189,30 @@ {#fun qlMultiCompositeQuote as multiCompositeQuote{fromEnumC`MultiQuoteOp'   ,withQuoteArray*`[GenQuote q]'&,preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#} -{#fun qlDerivedQuoteFromFunction{withQuote*`GenQuote q',id`FunPtr QuoteUnaryFun'+{#fun qlDerivedQuoteFromFunction{withQuote*`GenQuote q',withCallbackPtr*`Callback'   ,preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#} {#fun qlCompositeQuoteFromFunction{withQuote*`GenQuote q1',withQuote*`GenQuote q2'-  ,id`FunPtr QuoteBinaryFun',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#}+  ,withCallbackPtr*`Callback',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#} {#fun qlMultiCompositeQuoteFromFunction{withQuoteArray*`[GenQuote q]'&-  ,id`FunPtr QuoteArrayFun',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#}+  ,withCallbackPtr*`Callback',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#}  -- |As 'derivedQuote', with an arbitrary Haskell function. ----- __The continuation must span the whole use, not only construction.__ QuantLib calls @f@ later from @Quote::value()@. Returning frees its function pointer, so a later read crashes.------ @f@ must be total: exceptions cross C++, including during bootstrap. Prefer 'derivedQuote' when its 'QuoteOp' fits.+-- The quote and its native dependents retain the callback after the continuation returns.+-- Callback exceptions are rethrown by the enclosing Haskell call. withDerivedQuote :: (Double -> Double) -- ^f(value)   -> GenQuote q -> (Quote -> IO b) -> IO b withDerivedQuote f q k = withPayoffFun f (\fp -> qlDerivedQuoteFromFunction q fp >>= k)  -- |As 'compositeQuote', but combining the two quotes with an arbitrary Haskell function. Same--- continuation-lifetime and totality rules as 'withDerivedQuote'.+-- ownership and exception rules as 'withDerivedQuote'. withCompositeQuote :: (Double -> Double -> Double) -- ^f(value1, value2)   -> GenQuote q1 -> GenQuote q2 -> (Quote -> IO b) -> IO b withCompositeQuote f q1 q2 k = withQuoteBinaryFun f (\fp -> qlCompositeQuoteFromFunction q1 q2 fp >>= k)  -- |As 'multiCompositeQuote', but folding with an arbitrary Haskell function. The whole element -- vector is passed per evaluation, so this crosses into Haskell once per value, not once per--- element. Same continuation-lifetime and totality rules as 'withDerivedQuote'.+-- element. Same ownership and exception rules as 'withDerivedQuote'. withMultiCompositeQuote :: ([Double] -> Double) -- ^f(values)   -> [GenQuote q] -> (Quote -> IO b) -> IO b withMultiCompositeQuote f qs k = withBasketAccumulateFun f (\fp -> qlMultiCompositeQuoteFromFunction qs fp >>= k)

@@ -23,6 +23,7 @@   , HasHelperUnderlying(..)   , referenceDate   , maxDate+  , maxTime   , allowsExtrapolation   , timeFromReference   ) where@@ -35,10 +36,6 @@  #include "ql.h" --- Pointer aliases for the HasHelperUnderlying instances below. The helper types and the--- instruments they build are declared in QuantLib.Internal.Type; these are the c2hs-local--- mappings the {#fun#} hooks need, copied from the modules that construct them--- (QuantLib.TermStructure.Yield, .Inflation, QuantLib.Model). {#pointer *QlBondHelper as BondHelper foreign -> CBondHelper' nocode#} {#pointer *QlSwapRateHelper as SwapRateHelper foreign -> CSwapRateHelper' nocode#} {#pointer *QlOISRateHelper as OISRateHelper foreign -> COISRateHelper' nocode#}@@ -51,6 +48,7 @@ {#pointer *QlZeroCouponInflationSwap as ZeroCouponInflationSwap foreign -> CZeroCouponInflationSwap' nocode#} {#pointer *QlYearOnYearInflationSwap as YearOnYearInflationSwap foreign -> CYearOnYearInflationSwap' nocode#} {#pointer *QlFixedVsFloatingSwap as FixedVsFloatingSwap foreign -> CFixedVsFloatingSwap' nocode#}+{#pointer *QlTermStructure as TermStructure foreign -> CTermStructure' nocode#}  -- |Bootstrap and calibration helpers that build and hold the instrument whose market quote -- they match. The class lives here, in the term-structure root module, because its instances@@ -90,8 +88,6 @@ {#fun qlYearOnYearInflationSwapHelperSwap{withYearOnYearInflationSwapHelper*`YearOnYearInflationSwapHelper',preErrorCheck-`String'errorCheck*-}->`YearOnYearInflationSwap'peekYearOnYearInflationSwap*#} {#fun qlSwaptionHelperUnderlying{withSwaptionHelper*`SwaptionHelper',preErrorCheck-`String'errorCheck*-}->`FixedVsFloatingSwap'peekFixedVsFloatingSwap*#} -{#pointer *QlTermStructure as TermStructure foreign -> CTermStructure' nocode#}- -- |A term-structure reference point. 'ReferenceDate' stays fixed for the object's lifetime; -- 'SettlementDays' follows the global evaluation date using the supplied calendar. data Reference@@ -128,6 +124,9 @@  -- |the latest date for which the curve can return values {#fun qlTermStructureMaxDate as maxDate{withTermStructure*`GenTermStructure t',preErrorCheck-`String'errorCheck*-}->`Day'toDay#}++-- |'maxDate' expressed as a year fraction from the structure's reference date+{#fun qlTermStructureMaxTime as maxTime{withTermStructure*`GenTermStructure t',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Whether calls beyond the term structure's maximum date are allowed by default. {#fun qlTermStructureAllowsExtrapolation as allowsExtrapolation{withTermStructure*`GenTermStructure t'}->`Bool'#}

@@ -26,6 +26,7 @@   , priceNearby   , underlyingPriceDate   ) where+import Control.Exception (mask_) import QuantLib.Internal import QuantLib.Internal.Type import Data.List.NonEmpty(NonEmpty, toList)@@ -64,7 +65,9 @@   ,preErrorCheck-`String'errorCheck*-}->`CommodityCurve'peekCommodityCurve*#}  -- |The curve's name, as given at construction.-{#fun qlCommodityCurveName as name{withGenTermStructure*`CommodityCurve'}->`String'peekDynString*#}+name :: CommodityCurve -> IO String+name x = mask_ (nameRaw x)+{#fun qlCommodityCurveName as nameRaw{withGenTermStructure*`CommodityCurve'}->`String'peekDynString*#}  -- |The commodity type this curve prices. {#fun qlCommodityCurveCommodityType as commodityType{withGenTermStructure*`CommodityCurve',preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}@@ -81,8 +84,8 @@   dates <- qlCommodityCurveDates curve   prices <- qlCommodityCurvePrices curve   pure (zip dates prices)-{#fun qlCommodityCurveDates as qlCommodityCurveDates{withGenTermStructure*`CommodityCurve',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}-{#fun qlCommodityCurvePrices as qlCommodityCurvePrices{withGenTermStructure*`CommodityCurve',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlCommodityCurveDates as qlCommodityCurveDates{withGenTermStructure*`CommodityCurve',preIntArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlCommodityCurvePrices as qlCommodityCurvePrices{withGenTermStructure*`CommodityCurve',preDoubleArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Whether this curve has any nodes. {#fun pure qlCommodityCurveEmpty as isEmpty{withGenTermStructure*`CommodityCurve'}->`Bool'#}

@@ -2,7 +2,9 @@   (     -- * Types     -- ** Curves and helpers-    DefaultProbabilityTermStructure+    GenDefaultProbabilityTermStructure+  , DefaultProbabilityTermStructure+  , AffineHazardRateCurve   , DefaultProbabilityHelper      -- ** Coordinates@@ -24,6 +26,7 @@   , upfrontCdsHelper   , interpolatedDefaultDensityCurve   , interpolatedHazardRateCurve+  , interpolatedAffineHazardRateCurve   , interpolatedSurvivalProbabilityCurve   , defaultIterativeBootstrapOpts   , piecewiseDefaultCurve@@ -34,7 +37,9 @@   , survivalProbability   , defaultDensity   , defaultProbabilityBetween+  , conditionalSurvivalProbability   , impliedQuote+  , impliedQuoteOn   ) where #include "qlTypesC2HS.h" #include "qlEnumC2HS.h"@@ -53,13 +58,14 @@  {#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *QlDefaultProbabilityTermStructure as DefaultProbabilityTermStructure foreign -> CDefaultProbabilityTermStructure' nocode#}+{#pointer *QlAffineHazardRateCurve as AffineHazardRateCurve foreign -> CAffineHazardRateCurve' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}-{#pointer *QlTermStructure as TermStructure foreign -> CTermStructure' nocode#} {#pointer *QlQuote as Quote foreign -> CQuote' nocode#} {#pointer *QlDefaultProbabilityHelper as DefaultProbabilityHelper foreign -> CDefaultProbabilityHelper nocode#}+{#pointer *QlOneFactorAffineModel as OneFactorAffineModel foreign -> COneFactorAffineModel' nocode#}  -- |a curve whose hazard rate is another curve's, scaled by a spread factor-{#fun qlFactorSpreadedHazardRateCurve as factorSpreadedHazardRateCurve{withGenTermStructure*`DefaultProbabilityTermStructure',withQuote*`GenQuote q',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#}+{#fun qlFactorSpreadedHazardRateCurve as factorSpreadedHazardRateCurve{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withQuote*`GenQuote q',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#}  -- |Flat hazard-rate curve with either a fixed or evaluation-date-relative reference point. flatHazardRate :: Reference -> GenQuote q -> DayCounter -> IO DefaultProbabilityTermStructure@@ -69,68 +75,83 @@ {#fun qlFlatHazardRate as flatHazardRateFixed{withDay*`Day',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#}  -- |a curve whose survival probability is another curve's, multiplied by a spread factor-{#fun qlSpreadedHazardRateCurve as spreadedHazardRateCurve{withGenTermStructure*`DefaultProbabilityTermStructure',withQuote*`GenQuote q',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#}+{#fun qlSpreadedHazardRateCurve as spreadedHazardRateCurve{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withQuote*`GenQuote q',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#} -{#fun qlDefaultProbabilityTermStructureDefaultProbability as defaultProbabilityAtDateRaw{withGenTermStructure*`DefaultProbabilityTermStructure',withDay*`Day',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultProbability as defaultProbabilityAtDateRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureHazardRate1 as hazardRateAtTimeRaw{withGenTermStructure*`DefaultProbabilityTermStructure',`Double',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureHazardRate1 as hazardRateAtTimeRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureHazardRate as hazardRateAtDateRaw{withGenTermStructure*`DefaultProbabilityTermStructure',withDay*`Day',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureHazardRate as hazardRateAtDateRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureSurvivalProbability1 as survivalProbabilityAtTimeRaw{withGenTermStructure*`DefaultProbabilityTermStructure',`Double',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureSurvivalProbability1 as survivalProbabilityAtTimeRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureSurvivalProbability as survivalProbabilityAtDateRaw{withGenTermStructure*`DefaultProbabilityTermStructure',withDay*`Day',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureSurvivalProbability as survivalProbabilityAtDateRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureDefaultDensity1 as defaultDensityAtTimeRaw{withGenTermStructure*`DefaultProbabilityTermStructure',`Double',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultDensity1 as defaultDensityAtTimeRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureDefaultDensity as defaultDensityAtDateRaw{withGenTermStructure*`DefaultProbabilityTermStructure',withDay*`Day',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultDensity as defaultDensityAtDateRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureDefaultProbability1 as defaultProbabilityAtTimeRaw{withGenTermStructure*`DefaultProbabilityTermStructure',`Double',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultProbability1 as defaultProbabilityAtTimeRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureDefaultProbability2 as defaultProbabilityBetweenDatesRaw{withGenTermStructure*`DefaultProbabilityTermStructure',withDay*`Day',withDay*`Day',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultProbability2 as defaultProbabilityBetweenDatesRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',withDay*`Day',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#} -{#fun qlDefaultProbabilityTermStructureDefaultProbability3 as defaultProbabilityBetweenTimesRaw{withGenTermStructure*`DefaultProbabilityTermStructure',`Double',`Double',`Bool' -- ^extrapolate+{#fun qlDefaultProbabilityTermStructureDefaultProbability3 as defaultProbabilityBetweenTimesRaw{withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d',`Double',`Double',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Hazard rate at a date or year fraction, with annual frequency and continuous compounding.-hazardRate :: DefaultProbabilityTermStructure -> TermPoint -> Bool -> IO Double+hazardRate :: GenDefaultProbabilityTermStructure d -> TermPoint -> Bool -> IO Double hazardRate curve point = case point of   DatePoint d -> hazardRateAtDateRaw curve d   TimePoint t -> hazardRateAtTimeRaw curve t  -- |Survival probability from the reference point to a date or year fraction.-survivalProbability :: DefaultProbabilityTermStructure -> TermPoint -> Bool -> IO Double+survivalProbability :: GenDefaultProbabilityTermStructure d -> TermPoint -> Bool -> IO Double survivalProbability curve point = case point of   DatePoint d -> survivalProbabilityAtDateRaw curve d   TimePoint t -> survivalProbabilityAtTimeRaw curve t  -- |Default density at a date or year fraction.-defaultDensity :: DefaultProbabilityTermStructure -> TermPoint -> Bool -> IO Double+defaultDensity :: GenDefaultProbabilityTermStructure d -> TermPoint -> Bool -> IO Double defaultDensity curve point = case point of   DatePoint d -> defaultDensityAtDateRaw curve d   TimePoint t -> defaultDensityAtTimeRaw curve t  -- |Default probability from the reference point to a date or year fraction.-defaultProbability :: DefaultProbabilityTermStructure -> TermPoint -> Bool -> IO Double+defaultProbability :: GenDefaultProbabilityTermStructure d -> TermPoint -> Bool -> IO Double defaultProbability curve point = case point of   DatePoint d -> defaultProbabilityAtDateRaw curve d   TimePoint t -> defaultProbabilityAtTimeRaw curve t  -- |Default probability over a same-representation date or year-fraction interval.-defaultProbabilityBetween :: DefaultProbabilityTermStructure -> TermInterval -> Bool -> IO Double+defaultProbabilityBetween :: GenDefaultProbabilityTermStructure d -> TermInterval -> Bool -> IO Double defaultProbabilityBetween curve interval = case interval of   DateInterval d1 d2 -> defaultProbabilityBetweenDatesRaw curve d1 d2   TimeInterval t1 t2 -> defaultProbabilityBetweenTimesRaw curve t1 t2 +{#fun qlAffineHazardRateCurveConditionalSurvivalProbability as conditionalSurvivalProbabilityAtDatesRaw{withAffineHazardRateCurve*`AffineHazardRateCurve',withDay*`Day',withDay*`Day',`Double',`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++{#fun qlAffineHazardRateCurveConditionalSurvivalProbability1 as conditionalSurvivalProbabilityAtTimesRaw{withAffineHazardRateCurve*`AffineHazardRateCurve',`Double',`Double',`Double',`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Probability of survival to the interval's later point, conditional on survival to its earlier+-- point and on the stochastic hazard-rate component realizing @yVal@ there -- see+-- 'ql/experimental/credit/onefactoraffinesurvival.hpp'.+conditionalSurvivalProbability :: AffineHazardRateCurve -> TermInterval -> Double -- ^yVal+  -> Bool -> IO Double+conditionalSurvivalProbability curve interval yVal = case interval of+  DateInterval d1 d2 -> conditionalSurvivalProbabilityAtDatesRaw curve d1 d2 yVal+  TimeInterval t1 t2 -> conditionalSurvivalProbabilityAtTimesRaw curve t1 t2 yVal+ -- |bootstrap helper for a CDS quoted by running spread {#fun qlSpreadCdsHelper as spreadCdsHelper{withQuote*`GenQuote q' -- ^runningSpread   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^tenor@@ -144,6 +165,7 @@   ,withDayCounter*`DayCounter' -- ^lastPeriodDayCounter   ,`Bool' -- ^rebatesAccrual   ,`PricingModel' -- ^model+  ,withMaybeDay*`Maybe Day' -- ^tradeDate (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityHelper'peekDefaultProbabilityHelper*#}  -- |the upfront must be quoted in fractional units.@@ -161,6 +183,7 @@   ,withDayCounter*`DayCounter' -- ^lastPeriodDayCounter   ,`Bool' -- ^rebatesAccrual   ,`PricingModel' -- ^model+  ,withMaybeDay*`Maybe Day' -- ^tradeDate (1.44; QuantLib 1.43 requires 'Nothing')   ,preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityHelper'peekDefaultProbabilityHelper*#}  -- |The fair running-spread/upfront quote implied by the helper's current market data and pricing@@ -169,6 +192,12 @@ {#fun qlDefaultProbabilityHelperImpliedQuote as impliedQuote{withDefaultProbabilityHelper*`DefaultProbabilityHelper'   ,preErrorCheck-`String'errorCheck*-}->`Double'#} +-- |The quote that would make the helper reprice exactly on the given default-probability curve:+-- a par spread or upfront read with the helper's own conventions on any credit curve.+{#fun qlDefaultProbabilityHelperImpliedQuoteOn as impliedQuoteOn{withDefaultProbabilityHelper*`DefaultProbabilityHelper'+  ,withDefaultProbabilityTermStructure*`GenDefaultProbabilityTermStructure d'+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}+ interpolatedDefaultDensityCurve :: NonEmpty (Day, Double) -> DayCounter -> Calendar -> [(Day, GenQuote q)] -- ^jumps   -> Interpolation -> Bool -> IO DefaultProbabilityTermStructure interpolatedDefaultDensityCurve d dc c q i ex = do@@ -189,6 +218,19 @@  -- |default-probability term structure built by interpolating hazard rates at given dates {#fun qlInterpolatedHazardRateCurve{withDayArray*`[Day]'&,withDoubleArray*`[Double]'&,withDayCounter*`DayCounter',withCalendar*`Calendar',withQuoteArray*`[GenQuote q]'&,withDayArray*`[Day]'&,`Int',`Int',`Int',`Bool',preErrorCheck-`String'errorCheck*-}->`DefaultProbabilityTermStructure'peekDefaultProbabilityTermStructure*#}++-- |Hazard-rate curve interpolated deterministically between nodes, combined with a one-factor+-- affine short-rate model's stochastic discount mechanics -- see+-- 'ql/experimental/credit/interpolatedaffinehazardratecurve.hpp'.+interpolatedAffineHazardRateCurve :: NonEmpty (Day, Double) -> DayCounter -> GenOneFactorAffineModel om -> Calendar -> [(Day, GenQuote q)] -- ^jumps+  -> Interpolation+  -> Bool -- ^extrapolate past the curve's max date+  -> IO AffineHazardRateCurve+interpolatedAffineHazardRateCurve d dc m c q i ex =+  uncurryNested (qlInterpolatedAffineHazardRateCurve dd dq dc m c qq qd) (qlInterpolation i) ex+  where {(qd, qq) = unzip q; (dd, dq) = unzip (toList d)}++{#fun qlInterpolatedAffineHazardRateCurve{withDayArray*`[Day]'&,withDoubleArray*`[Double]'&,withDayCounter*`DayCounter',withOneFactorAffineModel*`GenOneFactorAffineModel om',withCalendar*`Calendar',withQuoteArray*`[GenQuote q]'&,withDayArray*`[Day]'&,`Int',`Int',`Int',`Bool',preErrorCheck-`String'errorCheck*-}->`AffineHazardRateCurve'peekAffineHazardRateCurve*#}  interpolatedSurvivalProbabilityCurve :: NonEmpty (Day, Double) -> DayCounter -> Calendar -> [(Day, GenQuote q)] -- ^jumps   -> Interpolation -> Bool -> IO DefaultProbabilityTermStructure

@@ -6,6 +6,9 @@   , ZeroCouponInflationSwapHelper   , YearOnYearInflationSwapHelper   , CPIInterpolationType(..) -- ^re-exported from "QuantLib.Internal.Common"+  , InflationSwapPeriod(..)+    -- ** Seasonality+  , Seasonality(..)      -- * Constructors     -- ** Helpers@@ -16,15 +19,18 @@   , piecewiseZeroInflationCurve   , piecewiseYoyInflationCurve   , interpolatedYoyInflationCurve+  , interpolatedZeroInflationCurve      -- * Inspectors   , HasHelperUnderlying(..)   , zeroRate   , yoyRate+  , zeroCouponInflationSwapImpliedQuoteOn+  , yearOnYearInflationSwapImpliedQuoteOn   ) where import QuantLib.Internal import QuantLib.Internal.Type-{#import QuantLib.Time.Schedule#}(Frequency)+{#import QuantLib.Time.Schedule#}(Frequency(..)) import QuantLib.Internal.Common import QuantLib.TermStructure(HasHelperUnderlying(..)) import Data.List.NonEmpty(NonEmpty, toList)@@ -37,40 +43,107 @@ #include "ql.h"  {#pointer *Calendar foreign -> CCalendar nocode#}-{#pointer *QlQuote as Quote foreign -> CQuote' nocode#}-{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlZeroInflationTermStructure as ZeroInflationTermStructure foreign -> CZeroInflationTermStructure' nocode#} {#pointer *QlYoYInflationTermStructure as YoYInflationTermStructure foreign -> CYoYInflationTermStructure' nocode#} {#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#} {#pointer *QlYoYInflationIndex as YoYInflationIndex foreign -> CYoYInflationIndex' nocode#} {#pointer *QlZeroCouponInflationSwapHelper as ZeroCouponInflationSwapHelper foreign -> CZeroCouponInflationSwapHelper nocode#} {#pointer *QlYearOnYearInflationSwapHelper as YearOnYearInflationSwapHelper foreign -> CYearOnYearInflationSwapHelper nocode#}-{#pointer *QlZeroCouponInflationSwap as ZeroCouponInflationSwap foreign -> CZeroCouponInflationSwap' nocode#}-{#pointer *QlYearOnYearInflationSwap as YearOnYearInflationSwap foreign -> CYearOnYearInflationSwap' nocode#} {#pointer *QlBondHelper as BondHelper foreign -> CBondHelper' nocode#} --- |Bootstrap helper for a zero-coupon inflation swap, at the given (observation lag, maturity).-{#fun qlZeroCouponInflationSwapHelper as zeroCouponInflationSwapHelper{withQuote*`GenQuote q' -- ^quote+-- |Which dates an inflation swap helper's swap runs between. 'InflationSwapToMaturity' starts on+-- the evaluation date and moves with it; 'InflationSwapBetweenDates' is fixed. The fixed form also+-- takes its observation-interpolation weight from the start date rather than the maturity.+data InflationSwapPeriod+  = InflationSwapToMaturity+      !Day -- ^maturity+  | InflationSwapBetweenDates+      !Day -- ^startDate+      !Day -- ^endDate++-- |Bootstrap helper for a zero-coupon inflation swap, at the given observation lag and period.+zeroCouponInflationSwapHelper :: GenQuote q -- ^quote+  -> (Word, TimeUnit) -- ^swapObsLag+  -> InflationSwapPeriod+  -> Calendar+  -> BusinessDayConvention -- ^paymentConvention+  -> DayCounter+  -> GenZeroInflationIndex zidx+  -> CPIInterpolationType -- ^observationInterpolation+  -> PillarChoice -- ^pillar+  -> Maybe Day -- ^customPillarDate+  -> IO ZeroCouponInflationSwapHelper+zeroCouponInflationSwapHelper quote lag period cal conv dc zii interp pillar customPillarDate = case period of+  InflationSwapToMaturity m -> zeroCouponInflationSwapHelperRaw quote lag m cal conv dc zii interp pillar customPillarDate+  InflationSwapBetweenDates s e ->+    zeroCouponInflationSwapHelperBetweenDatesRaw quote lag s e cal conv dc zii interp pillar customPillarDate++-- |Bootstrap helper for a year-on-year inflation swap. Unlike 'zeroCouponInflationSwapHelper',+-- also needs the nominal discount curve (the YoY swap's fixed/floating legs discount off it).+yearOnYearInflationSwapHelper :: GenQuote q -- ^quote+  -> (Word, TimeUnit) -- ^swapObsLag+  -> InflationSwapPeriod+  -> Calendar+  -> BusinessDayConvention -- ^paymentConvention+  -> DayCounter+  -> GenYoYInflationIndex yidx+  -> CPIInterpolationType -- ^observationInterpolation+  -> GenYieldTermStructure y -- ^nominalTermStructure+  -> PillarChoice -- ^pillar+  -> Maybe Day -- ^customPillarDate+  -> IO YearOnYearInflationSwapHelper+yearOnYearInflationSwapHelper quote lag period cal conv dc yii interp nominal pillar customPillarDate = case period of+  InflationSwapToMaturity m -> yearOnYearInflationSwapHelperRaw quote lag m cal conv dc yii interp nominal pillar customPillarDate+  InflationSwapBetweenDates s e ->+    yearOnYearInflationSwapHelperBetweenDatesRaw quote lag s e cal conv dc yii interp nominal pillar customPillarDate++-- Raw inflation swap helper bindings; one per 'InflationSwapPeriod' constructor for each helper.+{#fun qlZeroCouponInflationSwapHelper as zeroCouponInflationSwapHelperRaw{withQuote*`GenQuote q' -- ^quote   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag   ,withDay*`Day' -- ^maturity   ,withCalendar*`Calendar'   ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,`PillarChoice' -- ^pillar   ,withMaybeDay*`Maybe Day' -- ^customPillarDate   ,preErrorCheck-`String'errorCheck*-}->`ZeroCouponInflationSwapHelper'peekZeroCouponInflationSwapHelper*#} --- |Bootstrap helper for a year-on-year inflation swap. Unlike 'zeroCouponInflationSwapHelper',--- also needs the nominal discount curve (the YoY swap's fixed/floating legs discount off it).-{#fun qlYearOnYearInflationSwapHelper as yearOnYearInflationSwapHelper{withQuote*`GenQuote q' -- ^quote+{#fun qlZeroCouponInflationSwapHelper2 as zeroCouponInflationSwapHelperBetweenDatesRaw{withQuote*`GenQuote q' -- ^quote   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag+  ,withDay*`Day' -- ^startDate+  ,withDay*`Day' -- ^endDate+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention+  ,withDayCounter*`DayCounter'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'+  ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation+  ,`PillarChoice' -- ^pillar+  ,withMaybeDay*`Maybe Day' -- ^customPillarDate+  ,preErrorCheck-`String'errorCheck*-}->`ZeroCouponInflationSwapHelper'peekZeroCouponInflationSwapHelper*#}++{#fun qlYearOnYearInflationSwapHelper2 as yearOnYearInflationSwapHelperBetweenDatesRaw{withQuote*`GenQuote q' -- ^quote+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag+  ,withDay*`Day' -- ^startDate+  ,withDay*`Day' -- ^endDate+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention+  ,withDayCounter*`DayCounter'+  ,withYoYInflationIndex*`GenYoYInflationIndex yidx'+  ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,`PillarChoice' -- ^pillar+  ,withMaybeDay*`Maybe Day' -- ^customPillarDate+  ,preErrorCheck-`String'errorCheck*-}->`YearOnYearInflationSwapHelper'peekYearOnYearInflationSwapHelper*#}++{#fun qlYearOnYearInflationSwapHelper as yearOnYearInflationSwapHelperRaw{withQuote*`GenQuote q' -- ^quote+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag   ,withDay*`Day' -- ^maturity   ,withCalendar*`Calendar'   ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'-  ,withYoYInflationIndex*`YoYInflationIndex'+  ,withYoYInflationIndex*`GenYoYInflationIndex yidx'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure   ,`PillarChoice' -- ^pillar@@ -84,7 +157,7 @@   ,`Double' -- ^faceAmount   ,`Double' -- ^baseCPI   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag-  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,withZeroInflationIndex*`GenZeroInflationIndex zidx'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,withSchedule*`Schedule',withNonEmptyDoubleArray*`NonEmpty Double'& -- ^coupons   ,withDayCounter*`DayCounter' -- ^accrualDayCounter@@ -97,12 +170,14 @@ -- between the bootstrapped nodes with the given 'Interpolation'. piecewiseZeroInflationCurve :: Day -- ^referenceDate   -> Day -- ^baseDate-  -> Frequency -> DayCounter -> NonEmpty ZeroCouponInflationSwapHelper -> Interpolation+  -> Frequency -> DayCounter -> NonEmpty ZeroCouponInflationSwapHelper -> Maybe Seasonality -> Interpolation   -> IO ZeroInflationTermStructure-piecewiseZeroInflationCurve r b f dc h i = uncurryNested (qlPiecewiseZeroInflationCurve r b f dc (toList h)) (qlInterpolation i)+piecewiseZeroInflationCurve r b f dc h s i = seasonalityArgs r s $ \sk sd sf sfs ->+  uncurryNested (qlPiecewiseZeroInflationCurve r b f dc (toList h) sk sd sf sfs) (qlInterpolation i)  {#fun qlPiecewiseZeroInflationCurve{withDay*`Day',withDay*`Day',`Frequency',withDayCounter*`DayCounter'   ,withZeroCouponInflationSwapHelperArray*`[ZeroCouponInflationSwapHelper]'&+  ,`Int',withDay*`Day',`Frequency',withDoubleArray*`[Double]'&   ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`ZeroInflationTermStructure'peekZeroInflationTermStructure*#}  -- |Bootstraps a year-on-year inflation term structure piecewise from a set of helpers,@@ -110,12 +185,14 @@ piecewiseYoyInflationCurve :: Day -- ^referenceDate   -> Day -- ^baseDate   -> Double -- ^baseYoYRate-  -> Frequency -> DayCounter -> NonEmpty YearOnYearInflationSwapHelper -> Interpolation+  -> Frequency -> DayCounter -> NonEmpty YearOnYearInflationSwapHelper -> Maybe Seasonality -> Interpolation   -> IO YoYInflationTermStructure-piecewiseYoyInflationCurve r b y f dc h i = uncurryNested (qlPiecewiseYoYInflationCurve r b y f dc (toList h)) (qlInterpolation i)+piecewiseYoyInflationCurve r b y f dc h s i = seasonalityArgs r s $ \sk sd sf sfs ->+  uncurryNested (qlPiecewiseYoYInflationCurve r b y f dc (toList h) sk sd sf sfs) (qlInterpolation i)  {#fun qlPiecewiseYoYInflationCurve{withDay*`Day',withDay*`Day',`Double',`Frequency',withDayCounter*`DayCounter'   ,withYearOnYearInflationSwapHelperArray*`[YearOnYearInflationSwapHelper]'&+  ,`Int',withDay*`Day',`Frequency',withDoubleArray*`[Double]'&   ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`YoYInflationTermStructure'peekYoYInflationTermStructure*#}  -- |A YoY-inflation curve interpolating directly between given (date, rate) nodes, unlike@@ -124,17 +201,57 @@ -- node is the curve's own base date\/rate. interpolatedYoyInflationCurve :: Day -- ^referenceDate   -> NonEmpty (Day, Double) -- ^dates, rates-  -> Frequency -> DayCounter -> Interpolation+  -> Frequency -> DayCounter -> Maybe Seasonality -> Interpolation   -> IO YoYInflationTermStructure-interpolatedYoyInflationCurve r dr f dc i = uncurryNested (qlInterpolatedYoYInflationCurve r ds rs f dc) (qlInterpolation i)+interpolatedYoyInflationCurve r dr f dc s i = seasonalityArgs r s $ \sk sd sf sfs ->+  uncurryNested (qlInterpolatedYoYInflationCurve r ds rs f dc sk sd sf sfs) (qlInterpolation i)   where (ds, rs) = unzip (toList dr) {#fun qlInterpolatedYoYInflationCurve{withDay*`Day',withDayArray*`[Day]'&,withDoubleArrayRaw*`[Double]'   ,`Frequency',withDayCounter*`DayCounter'+  ,`Int',withDay*`Day',`Frequency',withDoubleArray*`[Double]'&   ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`YoYInflationTermStructure'peekYoYInflationTermStructure*#} +-- |A zero-coupon inflation curve interpolating directly between given (date, rate) nodes. The+-- first node is the curve's base date.+interpolatedZeroInflationCurve :: Day -- ^referenceDate+  -> NonEmpty (Day, Double) -- ^dates, rates+  -> Frequency -> DayCounter -> Maybe Seasonality -> Interpolation+  -> IO ZeroInflationTermStructure+interpolatedZeroInflationCurve r dr f dc s i = seasonalityArgs r s $ \sk sd sf sfs ->+  uncurryNested (qlInterpolatedZeroInflationCurve r ds rs f dc sk sd sf sfs) (qlInterpolation i)+  where (ds, rs) = unzip (toList dr)+{#fun qlInterpolatedZeroInflationCurve{withDay*`Day',withDayArray*`[Day]'&,withDoubleArrayRaw*`[Double]'+  ,`Frequency',withDayCounter*`DayCounter'+  ,`Int',withDay*`Day',`Frequency',withDoubleArray*`[Double]'&+  ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`ZeroInflationTermStructure'peekZeroInflationTermStructure*#}++-- |Multiplicative price seasonality applied by an inflation curve's zero and year-on-year rates.+-- Factors repeat every whole multiple of a year and are normalized to the curve's base date;+-- multi-year factors inconsistent at whole years around that date make construction throw.+data Seasonality+  = MultiplicativePriceSeasonality !Day !Frequency ![Double] -- ^seasonalityBaseDate, frequency, factors+  | KerkhofSeasonality !Day ![Double] -- ^seasonalityBaseDate, monthly factors++-- Flattens an optional seasonality into the shims' kind, base date, frequency and factors.+seasonalityArgs :: Day -> Maybe Seasonality -> (Int -> Day -> Frequency -> [Double] -> r) -> r+seasonalityArgs d s k = case s of+  Nothing -> k (-1) d NoFrequency []+  Just (MultiplicativePriceSeasonality b f fs) -> k 0 b f fs+  Just (KerkhofSeasonality b fs) -> k 1 b Monthly fs+ -- |Zero-coupon inflation rate implied by the curve. {#fun qlZeroInflationTermStructureZeroRate as zeroRate{withGenTermStructure*`ZeroInflationTermStructure',withDay*`Day',`Bool' -- ^extrapolate   ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The swap rate that would make a zero-coupon inflation swap helper reprice exactly on the given+-- zero-inflation curve, bootstrapped from it or not.+{#fun qlZeroCouponInflationSwapHelperImpliedQuoteOn as zeroCouponInflationSwapImpliedQuoteOn{withZeroCouponInflationSwapHelper*`ZeroCouponInflationSwapHelper'+  ,withGenTermStructure*`ZeroInflationTermStructure',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The swap rate that would make a year-on-year inflation swap helper reprice exactly on the given+-- year-on-year curve.+{#fun qlYearOnYearInflationSwapHelperImpliedQuoteOn as yearOnYearInflationSwapImpliedQuoteOn{withYearOnYearInflationSwapHelper*`YearOnYearInflationSwapHelper'+  ,withGenTermStructure*`YoYInflationTermStructure',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Year-on-year inflation rate implied by the curve. {#fun qlYoYInflationTermStructureYoYRate as yoyRate{withGenTermStructure*`YoYInflationTermStructure',withDay*`Day',`Bool' -- ^extrapolate