hasquant 0.5.0.2 → 0.6.0.0

raw patch · 67 files changed

+8993/−1355 lines, 67 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• QuantLib/CashFlow.chs +63/−23
• QuantLib/Commodity.chs +344/−0
• QuantLib/Currency.chs +5/−4
• QuantLib/Index/Commodity.chs +56/−0
• QuantLib/Index/Equity.chs +4/−18
• QuantLib/Index/InterestRate.chs +9/−7
• QuantLib/Instrument.chs +6/−63
• QuantLib/Instrument/Bond.chs +22/−22
• QuantLib/Instrument/Credit.chs +3/−4
• QuantLib/Instrument/Energy.chs +405/−0
• QuantLib/Instrument/Forward.chs +3/−3
• QuantLib/Instrument/InflationCapFloor.chs +83/−0
• QuantLib/Instrument/Option.chs +40/−1
• QuantLib/Instrument/Swap.chs +424/−34
• QuantLib/Internal.hs +58/−4
• QuantLib/Internal/Common.chs +972/−0
• QuantLib/Internal/Enum.chs +0/−853
• QuantLib/Internal/Type.hs +747/−36
• QuantLib/Math.chs +1/−1
• QuantLib/Model.chs +55/−17
• QuantLib/PricingEngine.chs +164/−3
• QuantLib/Quote.chs +1/−1
• QuantLib/TermStructure/Commodity.chs +157/−0
• QuantLib/TermStructure/Credit.chs +4/−4
• QuantLib/TermStructure/Inflation.chs +20/−5
• QuantLib/TermStructure/InflationVolatility.chs +297/−0
• QuantLib/TermStructure/Volatility.chs +280/−25
• QuantLib/TermStructure/Yield.chs +29/−26
• QuantLib/Time/Calendar.chs +4/−6
• QuantLib/Time/Date.chs +1/−1
• QuantLib/Time/Schedule.chs +12/−6
• README.md +6/−8
• cbits/qlEnumC2HS.h +29/−0
• cbits/qlEnumObjects.h +9/−0
• cbits/qlInstrument.cpp +664/−50
• cbits/qlInstrument.h +195/−12
• cbits/qlMisc.cpp +190/−11
• cbits/qlMisc.h +76/−6
• cbits/qlPricingEngine.cpp +100/−11
• cbits/qlPricingEngine.h +28/−5
• cbits/qlPricingEngineAux.cpp +14/−0
• cbits/qlPricingEngineAux.h +1/−0
• cbits/qlTermStructure.cpp +796/−49
• cbits/qlTermStructure.h +200/−10
• cbits/qlTermStructureAux.cpp +109/−6
• cbits/qlTermStructureAux.h +16/−0
• cbits/qlTypesC2HS.h +38/−0
• cbits/qlaux.h +199/−0
• hasquant.cabal +23/−5
• test/example/QuantLib/Example/AsianOption.hs +79/−0
• test/example/QuantLib/Example/BermudanSwaption.hs +2/−1
• test/example/QuantLib/Example/ForwardOption.hs +120/−0
• test/example/QuantLib/Example/Gaussian1dModels.hs +260/−0
• test/example/QuantLib/Example/InflationInstruments.hs +1/−1
• test/example/QuantLib/Example/ShortRateModels.hs +12/−9
• test/hspec/QuantLib/Spec/Commodity.hs +196/−0
• test/hspec/QuantLib/Spec/DatesAndSchedule.hs +49/−1
• test/hspec/QuantLib/Spec/Examples.hs +105/−1
• test/hspec/QuantLib/Spec/Index/Commodity.hs +48/−0
• test/hspec/QuantLib/Spec/Instrument/Energy.hs +152/−0
• test/hspec/QuantLib/Spec/Instrument/InflationCapFloor.hs +281/−0
• test/hspec/QuantLib/Spec/Instrument/Option.hs +173/−0
• test/hspec/QuantLib/Spec/TermStructure.hs +160/−2
• test/hspec/QuantLib/Spec/TermStructure/Commodity.hs +142/−0
• test/hspec/QuantLib/Spec/TermStructure/InflationVolatility.hs +233/−0
• test/main/QuantLib/MainTest.hs +14/−0

@@ -1,3 +1,7 @@+## 0.6.0.0 (2026)++Rethought multiple inheritance for secondary interfaces (`AffineModel`, `Gaussian1dModel`): instead of a second `Upcastable` node, each leaf now gets a standalone, eagerly-materialized upcast (e.g. `hullWhiteAsAffineModel`). This traded a pure wrap at the call site for an explicit `IO`-sequenced conversion, so a few call sites that used to be pure functions are now `IO` actions — a small, deliberate cost for one fewer hand-rolled sum type per interface. Also generalized several accessor return types one `AnyOf` layer deeper (`SwaptionHelper`, `FixedVsFloatingSwap`) to keep them cast-free, and added a further batch of bindings: Gaussian1d model instruments/engines, YoY/CPI inflation vol surfaces and cap/floors, commodities, cross-currency swaps, and BlackAtmVolCurve/SabrVolSurface/OptionletStripper2.+ ## 0.5.0.2 (2026)  Support for RelinkableHandle has finally landed. As it turned out the current model is a perfect fit for it: term structures, quotes, and vol surfaces now relink uniformly, so building on top of a live quote or curve propagates updates correctly. Also removed all remaining `dynamic_cast` usage from the C++ shim in favor of dedicated typed bindings, and added a batch of further instrument/engine bindings (SABR vol cubes, Heston FD engines, CDS/counterparty engines, amortizing bonds, exchange rates, CMS legs, and more).

@@ -76,6 +76,11 @@   , rangeAccrualLeg   , cpiLeg   , yoyInflationLeg+  , YoYInflationCouponPricer+  , blackYoYInflationCouponPricer+  , unitDisplacedBlackYoYInflationCouponPricer+  , bachelierYoYInflationCouponPricer+  , setYoYInflationCouponPricer   , ZeroInflationCashFlow   , zeroInflationCashFlow   , zeroInflationCashFlowAmount@@ -111,10 +116,9 @@ import QuantLib.Internal {#import QuantLib.InterestRate#}(Compounding) {#import QuantLib.Time.Schedule#}(Frequency)-{#import QuantLib.Time.Calendar#}(BusinessDayConvention(..)) import QuantLib.Time.Calendar(calendar, CalendarConstructor(..)) import QuantLib.Internal.Type-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Syntax(deriveOptionsRecord) import Data.Maybe(fromMaybe) @@ -124,6 +128,7 @@  #include "ql.h" +{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *CouponLeg foreign -> CCouponLeg' nocode#} {#pointer *QlQuote as Quote foreign -> CQuote' nocode#}@@ -477,14 +482,14 @@ -- |Build a leg of average-BMA coupons. {#fun qlAverageBMALeg as averageBMALeg{withSchedule*`Schedule',withBMAIndex*`BMAIndex'   ,withDoubleArray*`[Double]'& -- ^notionals-  ,withDayCounter*`DayCounter',`BusinessDayConvention',withDoubleArray*`[Double]'& -- ^gearings+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention',withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Build a leg of fixed-rate coupons. {#fun qlFixedRateLeg as fixedRateLeg{withSchedule*`Schedule',withDoubleArray*`[Double]'& -- ^notionals   ,withInterestRateArray*`[InterestRate]'& -- ^couponRates-  ,`BusinessDayConvention' -- ^paymentAdjustment+  ,fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withDayCounter*`DayCounter' -- ^firstPeriodDayCounter   ,withCalendar*`Calendar' -- ^paymentCalendar   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}@@ -516,7 +521,7 @@  -- |Raw binding for 'iborLeg'\/'iborLegFull': builds a leg of capped\/floored Ibor-rate coupons. {#fun qlIborLeg as iborLeg_{withSchedule*`Schedule',withIborIndex*`GenIborIndex ibor',withDoubleArray*`[Double]'& -- ^notionals-  ,withDayCounter*`DayCounter',`BusinessDayConvention' -- ^paymentAdjustment+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withIntArray*`[Word]'&  -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -528,9 +533,9 @@   ,withCalendar*`Calendar' -- ^paymentCalendar   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth-  ,`BusinessDayConvention' -- ^fixingConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixingConvention   ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#} @@ -557,7 +562,7 @@  -- |Raw binding for 'cmsLeg'\/'cmsLegFull': builds a leg of capped\/floored CMS-rate coupons. {#fun qlCmsLeg as cmsLeg_{withSchedule*`Schedule',withSwapIndex*`GenSwapIndex sidx',withDoubleArray*`[Double]'& -- ^notionals-  ,withDayCounter*`DayCounter',`BusinessDayConvention' -- ^paymentAdjustment+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withIntArray*`[Word]'&  -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -567,53 +572,62 @@   ,`Bool' -- ^zeroPayments   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth-  ,`BusinessDayConvention' -- ^fixingConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixingConvention   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Build a leg of overnight-index coupons. {#fun qlOvernightLeg as overnightLeg{withSchedule*`Schedule',withOvernightIborIndex*`OvernightIborIndex',withDoubleArray*`[Double]'& -- ^notionals'-  ,withDayCounter*`DayCounter',`BusinessDayConvention',withDoubleArray*`[Double]'& -- ^gearings+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention',withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Build a leg of range-accrual floating-rate coupons. {#fun qlRangeAccrualLeg as rangeAccrualLeg{withSchedule*`Schedule',withIborIndex*`GenIborIndex ibor',withDoubleArray*`[Double]'& -- ^notionals-  ,withDayCounter*`DayCounter',`BusinessDayConvention',withIntArray*`[Word]'& -- ^fixingDays+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention',withIntArray*`[Word]'& -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads   ,withDoubleArray*`[Double]'& -- ^lowerTriggers   ,withDoubleArray*`[Double]'& -- ^upperTriggers   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^observationTenor-  ,`BusinessDayConvention',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}+  ,fromEnumC`BusinessDayConvention',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Fixed-rate coupons scaled by the ratio of a 'ZeroInflationIndex' fixing to /baseCPI/--- (a 'CPICoupon' leg -- caps/floors are not exposed, see README.md's TODO).+-- (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'   ,`Double' -- ^baseCPI   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,withDoubleArray*`[Double]'& -- ^notionals   ,withDoubleArray*`[Double]'& -- ^fixedRates   ,withDayCounter*`DayCounter' -- ^paymentDayCounter-  ,`BusinessDayConvention' -- ^paymentAdjustment+  ,fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withCalendar*`Calendar' -- ^paymentCalendar   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,`Bool' -- ^subtractInflationNominal   ,preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#} --- |Year-on-year inflation-linked coupons (a 'YoYInflationCoupon' leg -- caps/floors are not--- exposed, see README.md's TODO).+-- |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.npv'\/'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. {#fun qlYoYInflationLeg as yoyInflationLeg{withSchedule*`Schedule',withCalendar*`Calendar'   ,withYoYInflationIndex*`YoYInflationIndex'   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,fromEnumC`CPIInterpolationType' -- ^interpolation   ,withDoubleArray*`[Double]'& -- ^notionals   ,withDayCounter*`DayCounter' -- ^paymentDayCounter-  ,`BusinessDayConvention' -- ^paymentAdjustment+  ,fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withIntArray*`[Word]'& -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads+  ,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#}@@ -710,6 +724,8 @@  {#pointer *QlFloatingRateCouponPricer as FloatingRateCouponPricer foreign -> CFloatingRateCouponPricer nocode#} {#pointer *QlSmileSection as SmileSection foreign -> CSmileSection nocode#}+{#pointer *QlYoYOptionletVolatilitySurface as YoYOptionletVolatilitySurface foreign -> CYoYOptionletVolatilitySurface' nocode#}+{#pointer *QlYoYInflationCouponPricer as YoYInflationCouponPricer foreign -> CYoYInflationCouponPricer nocode#}  -- |Black-formula pricer for capped/floored Ibor coupons {#fun qlBlackIborCouponPricer as blackIborCouponPricer{withOptionletVolatilityStructure*`GenOptionletVolatilityStructure ov'@@ -726,6 +742,28 @@   ,`Bool' -- ^byCallSpread   ,preErrorCheck-`String'errorCheck*-}->`FloatingRateCouponPricer'peekFloatingRateCouponPricer*#} +-- |Black-formula pricer for capped\/floored 'yoyInflationLeg' coupons.+{#fun qlBlackYoYInflationCouponPricer as blackYoYInflationCouponPricer{withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface'+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCouponPricer'peekYoYInflationCouponPricer*#}++-- |Unit-Displaced-Black-formula pricer for capped\/floored 'yoyInflationLeg' coupons.+{#fun qlUnitDisplacedBlackYoYInflationCouponPricer as unitDisplacedBlackYoYInflationCouponPricer{withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface'+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCouponPricer'peekYoYInflationCouponPricer*#}++-- |Bachelier-formula pricer for capped\/floored 'yoyInflationLeg' coupons.+{#fun qlBachelierYoYInflationCouponPricer as bachelierYoYInflationCouponPricer{withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface'+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCouponPricer'peekYoYInflationCouponPricer*#}++-- |Set the pricer of every 'QuantLib.Instrument.InflationCapFloor.YoYInflationCapFloor'-ready+-- 'YoYInflationCoupon'\/'CappedFlooredYoYInflationCoupon' in /leg/. Required before pricing (via+-- 'QuantLib.CashFlow.npv' or an 'QuantLib.Instrument.setPricingEngine'd instrument built on the+-- leg) any 'yoyInflationLeg' built with non-empty caps\/floors -- 'yoyInflationLeg' auto-attaches+-- a default (non-vol) pricer only when caps and floors are both empty.+{#fun qlSetYoYInflationCouponPricer as setYoYInflationCouponPricer{withLeg*`GenLeg l',withYoYInflationCouponPricer*`YoYInflationCouponPricer',preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |Set the pricer of every floating-rate coupon in /leg/. {#fun qlQuantLibSetCouponPricer as setCouponPricer{withLeg*`GenLeg l',withFloatingRateCouponPricer*`FloatingRateCouponPricer',preErrorCheck-`String'errorCheck*-}->`()'#} @@ -782,17 +820,19 @@     (maybe False (const True) bounds) lowerBound upperBound   where     (strategyTag, param) = case strat of-      LinearTsrRateBound        -> (0 :: Int, 0)-      LinearTsrVegaRatio p      -> (1, p)-      LinearTsrPriceThreshold p -> (2, p)-      LinearTsrBSStdDevs p      -> (3, p)+      LinearTsrRateBound        -> (fromEnum LinearTsrPricerRateBound, 0)+      LinearTsrVegaRatio p      -> (fromEnum LinearTsrPricerVegaRatio, p)+      LinearTsrPriceThreshold p -> (fromEnum LinearTsrPricerPriceThreshold, p)+      LinearTsrBSStdDevs p      -> (fromEnum LinearTsrPricerBSStdDevs, p)     (lowerBound, upperBound) = fromMaybe (0, 0) bounds +{#enum LinearTsrPricerStrategyType as LinearTsrPricerStrategyTag {} deriving (Show, Eq)#}+ -- |Raw binding for 'linearTsrPricer', taking the 'LinearTsrPricerSettings' unpacked into a -- strategy tag\/parameter and an explicit-bounds flag. {#fun qlLinearTsrPricer as linearTsrPricer_{withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv',withQuote*`GenQuote q' -- ^meanReversion   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^couponDiscountCurve-  ,fromIntegral`Int' -- ^strategy tag: 0=RateBound, 1=VegaRatio, 2=PriceThreshold, 3=BSStdDevs+  ,fromIntegral`Int' -- ^strategy tag, see 'LinearTsrPricerStrategyTag'   ,`Double' -- ^strategy-specific parameter (unused for RateBound)   ,`Bool' -- ^haveBounds   ,`Double' -- ^lowerBound (ignored unless haveBounds)

@@ -0,0 +1,344 @@+module QuantLib.Commodity+  (+    CommodityType+  , commodityType+  , nullCommodityType+  , commodityTypeCode+  , commodityTypeName+  , commodityTypeEmpty++  , UnitOfMeasure+  , UnitOfMeasureType(..)+  , unitOfMeasure+  , unitOfMeasureName+  , unitOfMeasureCode+  , unitOfMeasureType+  , unitOfMeasureEmpty+  , lotUnitOfMeasure+  , barrelUnitOfMeasure+  , mtUnitOfMeasure+  , mbUnitOfMeasure+  , gallonUnitOfMeasure+  , litreUnitOfMeasure+  , kilolitreUnitOfMeasure+  , tokyoKilolitreUnitOfMeasure++  , PaymentTerm+  , PaymentTermEventType(..)+  , paymentTerm+  , paymentTermName+  , paymentTermEventType+  , paymentTermOffsetDays+  , paymentTermCalendar+  , paymentTermEmpty+  , paymentTermGetPaymentDate++  , Quantity+  , roundedQuantity+  , closeQuantity+  , closeEnoughQuantity++  , CommodityUnitCost++  , DateInterval+  , isDateBetween+  , intersection++  , PricingPeriod+  , pricingPeriodStartDate+  , pricingPeriodEndDate+  , pricingPeriodPaymentDate+  , pricingPeriodQuantity+  , PricingPeriods+  , pricingPeriod++  , UnitOfMeasureConversion+  , UnitOfMeasureConversionType(..)+  , unitOfMeasureConversion+  , unitOfMeasureConversionSource+  , unitOfMeasureConversionTarget+  , unitOfMeasureConversionCommodityType+  , unitOfMeasureConversionType+  , unitOfMeasureConversionFactor+  , unitOfMeasureConversionCode+  , convertQuantity+  , chainUnitOfMeasureConversion++  , lookupUomConversion+  , addUomConversion+  , clearUomConversions++  , commoditySettingsCurrency+  , setCommoditySettingsCurrency+  , commoditySettingsUnitOfMeasure+  , setCommoditySettingsUnitOfMeasure+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type+import QuantLib.Internal.Common+import Foreign.Marshal.Alloc(alloca)++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *Currency foreign -> CCurrency nocode#}+{#pointer *CommodityType foreign -> CCommodityType nocode#}+{#pointer *UnitOfMeasure foreign -> CUnitOfMeasure nocode#}+{#pointer *PaymentTerm foreign -> CPaymentTerm nocode#}+{#pointer *UnitOfMeasureConversion foreign -> CUnitOfMeasureConversion nocode#}++{#enum UnitOfMeasureConversionType{} deriving(Show, Eq)#}++-- |Construct a custom commodity type identified by its code (e.g. \"HO\") and descriptive name+-- (e.g. \"Heating Oil\"). QuantLib has no fixed enum of commodity types -- every instance is+-- user-registered by code, the same way a custom 'QuantLib.Currency.currency'' is.+{#fun qlCommodityType as commodityType{`String' -- ^code+  ,`String' -- ^name+  ,preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}++-- |The fixed placeholder commodity type QuantLib itself uses where no real commodity type+-- applies (e.g. in unit-of-measure-only conversions).+{#fun qlNullCommodityType as nullCommodityType{preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}++-- |The commodity code, e.g. \"HO\".+{#fun pure qlCommodityTypeCode as commodityTypeCode{withCommodityType*`CommodityType'}->`String'peekDynString*#}++-- |The descriptive name, e.g. \"Heating Oil\".+{#fun pure qlCommodityTypeName as commodityTypeName{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'#}++-- |Construct a custom unit of measure from its descriptive name (e.g. \"Barrels\"), code (e.g.+-- \"BBL\"), and type (mass/volume/energy/quantity).+{#fun qlUnitOfMeasure as unitOfMeasure{`String' -- ^name+  ,`String' -- ^code+  ,fromEnumC`UnitOfMeasureType'+  ,preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |The descriptive name, e.g. \"Barrels\".+{#fun pure qlUnitOfMeasureName as unitOfMeasureName{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}++-- |The code, e.g. \"BBL\", \"MT\".+{#fun pure qlUnitOfMeasureCode as unitOfMeasureCode{withUnitOfMeasure*`UnitOfMeasure'}->`String'peekDynString*#}++-- |The unit's type (mass/volume/energy/quantity).+{#fun pure qlUnitOfMeasureUnitType as unitOfMeasureType{withUnitOfMeasure*`UnitOfMeasure'}->`UnitOfMeasureType'toEnumC#}++-- |Whether this is a usable instance (as opposed to one built via a default constructor).+{#fun pure qlUnitOfMeasureEmpty as unitOfMeasureEmpty{withUnitOfMeasure*`UnitOfMeasure'}->`Bool'#}++-- |The lot, a dimensionless 'UnitOfMeasure::Quantity' unit.+{#fun qlLotUnitOfMeasure as lotUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Barrels (BBL), the base petroleum volume unit.+{#fun qlBarrelUnitOfMeasure as barrelUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Metric tonnes (MT).+{#fun qlMTUnitOfMeasure as mtUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Thousand barrels (MB).+{#fun qlMBUnitOfMeasure as mbUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |US gallons.+{#fun qlGallonUnitOfMeasure as gallonUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Litres.+{#fun qlLitreUnitOfMeasure as litreUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Kilolitres.+{#fun qlKilolitreUnitOfMeasure as kilolitreUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}+-- |Tokyo kilolitres.+{#fun qlTokyoKilolitreUnitOfMeasure as tokyoKilolitreUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |Construct a payment term: a named offset (in calendar-adjusted days) from either the trade+-- date or the pricing-period end date.+{#fun qlPaymentTerm as paymentTerm{`String' -- ^name+  ,fromEnumC`PaymentTermEventType'+  ,`Int' -- ^offsetDays+  ,withCalendar*`Calendar'+  ,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*#}++-- |Whether the offset is measured from the trade date or the pricing date.+{#fun pure qlPaymentTermEventType_ as paymentTermEventType{withPaymentTerm*`PaymentTerm'}->`PaymentTermEventType'toEnumC#}++-- |The number of (calendar-adjusted) offset days.+{#fun pure qlPaymentTermOffsetDays as paymentTermOffsetDays{withPaymentTerm*`PaymentTerm'}->`Int'#}++-- |The calendar used to adjust the payment date.+{#fun qlPaymentTermCalendar as paymentTermCalendar{withPaymentTerm*`PaymentTerm',preErrorCheck-`String'errorCheck*-}->`Calendar'peekCalendar*#}++-- |Whether this is a usable instance (as opposed to one built via a default constructor).+{#fun pure qlPaymentTermEmpty as paymentTermEmpty{withPaymentTerm*`PaymentTerm'}->`Bool'#}++-- |Applies the term's offset (and calendar adjustment) to a trade or pricing-period-end date to+-- get the actual payment date.+{#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.+type Quantity = (CommodityType, UnitOfMeasure, Double)++{#fun pure qlQuantityRoundedAmount as quantityRoundedAmount{withUnitOfMeasure*`UnitOfMeasure',`Double'}->`Double'#}++-- |Round a quantity's amount per its unit of measure's rounding convention. The commodity type and+-- unit of measure are unaffected by rounding, so they're carried straight through in Haskell+-- rather than round-tripped through the C++ call.+roundedQuantity :: Quantity -> Quantity+roundedQuantity (ct, uom, amount) = (ct, uom, quantityRoundedAmount uom amount)++{#fun qlQuantityClose as qlQuantityClose_+  {withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,`Int',preErrorCheck-`String'errorCheck*-}->`Bool'#}++-- |Whether two quantities are close to within @n@ ULPs (default 42 upstream), after converting+-- the second to the first's unit of measure if their units differ (which throws unless a+-- conversion is reachable -- see 'lookupUomConversion').+closeQuantity :: Quantity -> Quantity -> Int -> IO Bool+closeQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityClose_ ct1 uom1 amt1 ct2 uom2 amt2 n++{#fun qlQuantityCloseEnough as qlQuantityCloseEnough_+  {withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,`Int',preErrorCheck-`String'errorCheck*-}->`Bool'#}++-- |As 'closeQuantity', but using QuantLib's relative (rather than absolute) closeness test.+closeEnoughQuantity :: Quantity -> Quantity -> Int -> IO Bool+closeEnoughQuantity (ct1, uom1, amt1) (ct2, uom2, amt2) n = qlQuantityCloseEnough_ ct1 uom1 amt1 ct2 uom2 amt2 n++-- |A commodity's unit cost: a cash amount (a @(Double, Currency)@ pair, standing in for+-- QuantLib's @Money@) per 'UnitOfMeasure'. A plain tuple, like 'Quantity' -- it carries no+-- calculation of its own upstream.+type CommodityUnitCost = (Double, Currency, UnitOfMeasure)++-- |A date range, inclusive of both ends. No C++ call is needed for either operation below --+-- 'Day' (from @Data.Time.Calendar@) already has the 'Ord' instance QuantLib's own comparisons rely+-- on, so both are plain Haskell functions rather than shim calls.+type DateInterval = (Day, Day)++-- |Whether a date falls within the interval, optionally excluding either end.+isDateBetween :: DateInterval+              -> Day -- ^date+              -> Bool -- ^includeFirst+              -> Bool -- ^includeLast+              -> Bool+isDateBetween (startDate, endDate) date includeFirst includeLast =+  (if includeFirst then date >= startDate else date > startDate) &&+  (if includeLast then date <= endDate else date < endDate)++-- |The overlap of two date intervals, or 'Nothing' if they don't overlap at all (upstream returns+-- a default-constructed, both-dates-null 'DateInterval' in this case; a 'Maybe' is the natural+-- Haskell equivalent).+intersection :: DateInterval -> DateInterval -> Maybe DateInterval+intersection (s1, e1) (s2, e2)+  | (s1 < s2 && e1 < s2) || (s1 > e2 && e1 > e2) = Nothing+  | otherwise = Just (max s1 s2, min e1 e2)++-- |A 'DateInterval' over which a fixed 'Quantity' of a commodity is priced, paid on+-- 'pricingPeriodPaymentDate'. Unlike 'Quantity'\/'CommodityUnitCost', this is a real record+-- rather than a tuple, per the user's explicit choice -- it's used as a named unit across every+-- energy-swap constructor (Stage 6), where a flat tuple would be unreadable positionally.+data PricingPeriod = PricingPeriod+  { pricingPeriodStartDate :: Day+  , pricingPeriodEndDate :: Day+  , pricingPeriodPaymentDate :: Day+  , pricingPeriodQuantity :: Quantity+  } deriving (Show, Eq)++type PricingPeriods = [PricingPeriod]++-- |Construct a 'PricingPeriod', enforcing upstream's @DateInterval@ invariant that the end date+-- is not before the start date.+pricingPeriod :: Day -> Day -> Day -> Quantity -> PricingPeriod+pricingPeriod startDate endDate+  | endDate < startDate = error "pricingPeriod: end date must be >= start date"+  | otherwise = PricingPeriod startDate endDate++-- |Construct a conversion factor between two units of measure for a given commodity type: a unit+-- of @source@ is worth @conversionFactor@ units of @target@.+{#fun qlUnitOfMeasureConversion as unitOfMeasureConversion+  {withCommodityType*`CommodityType'+  ,withUnitOfMeasure*`UnitOfMeasure' -- ^source+  ,withUnitOfMeasure*`UnitOfMeasure' -- ^target+  ,`Double' -- ^conversionFactor+  ,preErrorCheck-`String'errorCheck*-}->`UnitOfMeasureConversion'peekUnitOfMeasureConversion*#}++-- |The source unit of measure.+{#fun qlUnitOfMeasureConversionSource as unitOfMeasureConversionSource{withUnitOfMeasureConversion*`UnitOfMeasureConversion',preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |The target unit of measure.+{#fun qlUnitOfMeasureConversionTarget as unitOfMeasureConversionTarget{withUnitOfMeasureConversion*`UnitOfMeasureConversion',preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |The commodity type this conversion applies to.+{#fun qlUnitOfMeasureConversionCommodityType as unitOfMeasureConversionCommodityType{withUnitOfMeasureConversion*`UnitOfMeasureConversion',preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}++-- |Whether the conversion was given directly, or derived by chaining two other conversions.+{#fun pure qlUnitOfMeasureConversionType_ as unitOfMeasureConversionType{withUnitOfMeasureConversion*`UnitOfMeasureConversion'}->`UnitOfMeasureConversionType'#}++-- |The conversion factor: a unit of the source is worth this many units of the target.+{#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*#}++{#fun qlUnitOfMeasureConversionConvert as qlUnitOfMeasureConversionConvert_+  {withUnitOfMeasureConversion*`UnitOfMeasureConversion'+  ,withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,alloca-`CommodityType'peekCommodityTypePtr*+  ,alloca-`UnitOfMeasure'peekUnitOfMeasurePtr*+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Apply the conversion factor to a quantity, converting it from the conversion's source to its+-- target unit of measure (or vice versa). Throws if the quantity's unit of measure is on neither+-- side of the conversion.+convertQuantity :: UnitOfMeasureConversion -> Quantity -> IO Quantity+convertQuantity conv (ct, uom, amount) = do+  (amount', ct', uom') <- qlUnitOfMeasureConversionConvert_ conv ct uom amount+  pure (ct', uom', amount')++-- |Combine two conversions sharing a common unit of measure into a derived conversion between+-- their other two units. Throws if the conversions don't share a common unit.+{#fun qlUnitOfMeasureConversionChain as chainUnitOfMeasureConversion+  {withUnitOfMeasureConversion*`UnitOfMeasureConversion'+  ,withUnitOfMeasureConversion*`UnitOfMeasureConversion'+  ,preErrorCheck-`String'errorCheck*-}->`UnitOfMeasureConversion'peekUnitOfMeasureConversion*#}++-- |Look up a (possibly derived, via triangulation) conversion between two units of measure for a+-- given commodity type. Throws if none can be found. Pre-populated with a set of known petroleum+-- conversion factors even before any 'addUomConversion' call.+{#fun qlUnitOfMeasureConversionManagerLookup as lookupUomConversion+  {withCommodityType*`CommodityType'+  ,withUnitOfMeasure*`UnitOfMeasure' -- ^source+  ,withUnitOfMeasure*`UnitOfMeasure' -- ^target+  ,`UnitOfMeasureConversionType'+  ,preErrorCheck-`String'errorCheck*-}->`UnitOfMeasureConversion'peekUnitOfMeasureConversion*#}++-- |Register a conversion with the global unit-of-measure conversion repository, replacing any+-- existing conversion between the same commodity type and pair of units.+{#fun qlUnitOfMeasureConversionManagerAdd as addUomConversion{withUnitOfMeasureConversion*`UnitOfMeasureConversion'}->`()'#}++-- |Reset the unit-of-measure conversion repository back to its built-in set of known petroleum+-- conversion factors, discarding anything added via 'addUomConversion'.+{#fun qlUnitOfMeasureConversionManagerClear as clearUomConversions{}->`()'#}++-- |The global commodity currency setting (defaults to USD).+{#fun qlCommoditySettingsCurrency as commoditySettingsCurrency{preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}++-- |Set the global commodity currency setting.+{#fun qlCommoditySettingsSetCurrency as setCommoditySettingsCurrency{withCurrency*`Currency'}->`()'#}++-- |The global commodity unit-of-measure setting (defaults to barrels).+{#fun qlCommoditySettingsUnitOfMeasure as commoditySettingsUnitOfMeasure{preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |Set the global commodity unit-of-measure setting.+{#fun qlCommoditySettingsSetUnitOfMeasure as setCommoditySettingsUnitOfMeasure{withUnitOfMeasure*`UnitOfMeasure'}->`()'#}++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -28,8 +28,7 @@   ) where import QuantLib.Internal import QuantLib.Internal.Type-import QuantLib.Internal.Enum-import QuantLib.Time.Date(Day)+import QuantLib.Internal.Common import Foreign.Marshal.Alloc(alloca)  #include "qlTypesC2HS.h"@@ -83,6 +82,7 @@   {withCurrency*`Currency' -- ^source   ,withCurrency*`Currency' -- ^target   ,`Double' -- ^rate+  ,preErrorCheck-`String'errorCheck*-   }->`ExchangeRate'peekExchangeRate*#}  -- |The rate itself: a unit of the source currency is worth this many units of the target.@@ -111,7 +111,8 @@ -- |Register an exchange rate with the global exchange-rate repository, valid between the given -- dates (inclusive). Use 'minDate'/'maxDate' for an always-valid rate. {#fun qlExchangeRateManagerAdd as addExchangeRate-  {withExchangeRate*`ExchangeRate', withDay*`Day', withDay*`Day'}->`()'#}+  {withExchangeRate*`ExchangeRate', withDay*`Day', withDay*`Day'+  ,preErrorCheck-`String'errorCheck*-}->`()'#}  -- |Look up a (possibly derived) exchange rate between two currencies at a given date (or the -- current evaluation date if 'Nothing'). Throws if no rate can be found. Pre-populated with a@@ -133,7 +134,7 @@ {#fun qlMoneySettingsSetConversionType as setMoneyConversionType{`MoneyConversionType'}->`()'#}  -- |The global base currency used by 'MoneyConversionType' base-currency conversion, if set.-{#fun qlMoneySettingsBaseCurrency as moneyBaseCurrency{}->`Maybe Currency'peekMaybeCurrency*#}+{#fun qlMoneySettingsBaseCurrency as moneyBaseCurrency{preErrorCheck-`String'errorCheck*-}->`Maybe Currency'peekMaybeCurrency*#}  -- |Set the global base currency used by 'MoneyConversionType' base-currency conversion. {#fun qlMoneySettingsSetBaseCurrency as setMoneyBaseCurrency{withCurrency*`Currency'}->`()'#}

@@ -0,0 +1,56 @@+module QuantLib.Index.Commodity+  (+    CommodityIndex++  , commodityIndex++  , commodityIndexForwardPrice+  , commodityIndexLastQuoteDate+  , commodityIndexEmpty+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *Currency foreign -> CCurrency nocode#}+{#pointer *CommodityType foreign -> CCommodityType nocode#}+{#pointer *UnitOfMeasure foreign -> CUnitOfMeasure nocode#}+{#pointer *QlCommodityCurve as CommodityCurve foreign -> CCommodityCurve' nocode#}+{#pointer *QlCommodityIndex as CommodityIndex foreign -> CCommodityIndex' nocode#}++-- |A named commodity index, whose fixings forecast from an optional forward 'CommodityCurve'+-- (or fall back to a stored historical fixing when none is given -- add one via+-- 'QuantLib.Index.addFixing'). Upstream's constructor also takes an+-- @ExchangeContracts@\/nearby-offset pair for rolling onto nearby exchange contracts; this binds+-- only the no-rolling case (a null @exchangeContracts@ and offset 0), the same scope this module's+-- 'QuantLib.TermStructure.Commodity.CommodityCurve' already narrowed 'commodityCurvePrice' to.+-- No inspector is bound for commodity type\/currency\/unit of measure\/lot quantity\/forward+-- curve: each is a plain, never-mutated echo of this constructor's own argument -- the caller+-- already holds whatever it passed in, so a getter would tell it nothing new.+{#fun qlCommodityIndex as commodityIndex+  {`String' -- ^name+  ,withCommodityType*`CommodityType'+  ,withCurrency*`Currency'+  ,withUnitOfMeasure*`UnitOfMeasure'+  ,withCalendar*`Calendar'+  ,`Double' -- ^lotQuantity+  ,withMaybeCommodityCurve*`Maybe CommodityCurve' -- ^forwardCurve+  ,preErrorCheck-`String'errorCheck*-}->`CommodityIndex'peekCommodityIndex*#}++-- |The forecast forward price for a date, from the forward curve.+{#fun qlCommodityIndexForwardPrice as commodityIndexForwardPrice{withCommodityIndex*`CommodityIndex',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The most recent date with a stored historical fixing. Throws if none has been added yet --+-- check 'commodityIndexEmpty' first if that's a possibility.+{#fun qlCommodityIndexLastQuoteDate as commodityIndexLastQuoteDate{withCommodityIndex*`CommodityIndex',preErrorCheck-`String'errorCheck*-}->`Day'toDay#}++-- |Whether this index has any stored historical fixings.+{#fun pure qlCommodityIndexEmpty as commodityIndexEmpty{withCommodityIndex*`CommodityIndex'}->`Bool'#}++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -3,11 +3,6 @@     EquityIndex    , equityIndex--  , currency-  , equityInterestRateCurve-  , equityDividendCurve-  , spot   ) where import QuantLib.Internal import QuantLib.Internal.Type@@ -28,7 +23,10 @@ -- |A named equity total-return index, forecasting future fixings from an -- optional risk-free interest rate curve and dividend curve, and an optional -- spot 'QuantLib.Quote.Quote' -- today's fixing is used when no spot is given.--- Historical fixings are added via 'QuantLib.Index.addFixing'.+-- Historical fixings are added via 'QuantLib.Index.addFixing'. No inspector is bound for+-- currency\/interest curve\/dividend curve\/spot: each is a plain, never-mutated echo of this+-- constructor's own argument, same shape as the currency\/interest\/dividend\/spot fields on+-- 'QuantLib.Index.Commodity.CommodityIndex' -- the caller already holds whatever it passed in. {#fun qlEquityIndex as equityIndex{`String' -- ^name   ,withCalendar*`Calendar' -- ^fixingCalendar   ,withCurrency*`Currency'@@ -36,17 +34,5 @@   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y2)' -- ^dividend   ,withMaybeQuote*`Maybe (GenQuote q)' -- ^spot   ,preErrorCheck-`String'errorCheck*-}->`EquityIndex'peekEquityIndex*#}---- |The index currency.-{#fun qlEquityIndexCurrency as currency{withEquityIndex*`EquityIndex',preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}---- |The risk-free interest rate curve used to forecast this index's future fixings.-{#fun qlEquityIndexInterestRateCurve as equityInterestRateCurve{withEquityIndex*`EquityIndex',preErrorCheck-`String'errorCheck*-}->`YieldTermStructure'peekYieldTermStructure*#}---- |The dividend curve used to forecast this index's future fixings.-{#fun qlEquityIndexDividendCurve as equityDividendCurve{withEquityIndex*`EquityIndex',preErrorCheck-`String'errorCheck*-}->`YieldTermStructure'peekYieldTermStructure*#}---- |The index's spot quote; when empty, forecasting falls back to today's fixing.-{#fun qlEquityIndexSpot as spot{withEquityIndex*`EquityIndex',preErrorCheck-`String'errorCheck*-}->`Quote'peekQuote*#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -62,8 +62,7 @@   ) where import QuantLib.Internal import QuantLib.Internal.Syntax-{#import QuantLib.Time.Schedule#}(TimeUnit(..))-{#import QuantLib.Time.Calendar#}(BusinessDayConvention)+import QuantLib.Internal.Common import QuantLib.Internal.Type -- Plain (non-c2hs) import: QuantLib.CashFlow is later in exposed-modules than -- this file, so a {#import#} here would need its .chi before it exists.@@ -78,6 +77,9 @@ #include "ql.h"  {#pointer *Currency foreign -> CCurrency nocode#}+{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *DayCounter foreign -> CDayCounter nocode#}+{#pointer *Schedule foreign -> CSchedule nocode#}  {#pointer *QlInterestRateIndex as InterestRateIndex foreign -> CInterestRateIndex' nocode#} {#pointer *QlBMAIndex as BMAIndex foreign -> CBMAIndex' nocode#}@@ -284,14 +286,14 @@ -- |Creates a swap-rate index whose forwarding and discounting both come from the underlying ibor index's curve. {#fun qlSwapIndex as swapIndex{`String',fromEnumQuantity`(Int,TimeUnit)'&,fromIntegral`Word' -- ^settlementDays   ,withCurrency*`Currency',withCalendar*`Calendar',fromEnumQuantity`(Int,TimeUnit)'& -- ^fixedLegTenor-  ,`BusinessDayConvention',withDayCounter*`DayCounter',withIborIndex*`GenIborIndex ibor',preErrorCheck-`String'errorCheck*-}->`SwapIndex'peekSwapIndex*#}+  ,fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter',withIborIndex*`GenIborIndex ibor',preErrorCheck-`String'errorCheck*-}->`SwapIndex'peekSwapIndex*#}  -- |Creates a swap-rate index with a discounting curve distinct from the forwarding curve of the underlying ibor index. {#fun qlSwapIndex1 as swapIndex'{`String' -- ^familyName   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^settlementDays   ,withCurrency*`Currency',withCalendar*`Calendar',fromEnumQuantity`(Int,TimeUnit)'& -- ^fixedLegTenor-  ,`BusinessDayConvention' -- ^fixedLegConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixedLegConvention   ,withDayCounter*`DayCounter' -- ^fixedLegDayCounter   ,withIborIndex*`GenIborIndex ibor',withYieldTermStructure*`GenYieldTermStructure y',preErrorCheck-`String'errorCheck*-}->`SwapIndex'peekSwapIndex*#} @@ -299,7 +301,7 @@ {#fun qlIborIndex{`String' -- ^familyName   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^settlementDays-  ,withCurrency*`Currency',withCalendar*`Calendar',`BusinessDayConvention'+  ,withCurrency*`Currency',withCalendar*`Calendar',fromEnumC`BusinessDayConvention'   ,`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`IborIndex'peekIborIndex*#} @@ -320,7 +322,7 @@   ,withCurrency*`Currency',withCalendar*`Calendar' -- ^fixingCalendar   ,withCalendar*`Calendar' -- ^valueCalendar   ,withCalendar*`Calendar' -- ^maturityCalendar-  ,`BusinessDayConvention'+  ,fromEnumC`BusinessDayConvention'   ,`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`IborIndex'peekIborIndex*#} @@ -332,7 +334,7 @@   ,withCurrency*`Currency',withCalendar*`Calendar',withDayCounter*`DayCounter',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`OvernightIborIndex'peekOvernightIborIndex*#}  -- |Returns the business day convention used to adjust the index's value/maturity dates.-{#fun pure qlIborIndexBusinessDayConvention as businessDayConvention{withIborIndex*`GenIborIndex ibor'}->`BusinessDayConvention'#}+{#fun pure qlIborIndexBusinessDayConvention as businessDayConvention{withIborIndex*`GenIborIndex ibor'}->`BusinessDayConvention'toEnumC#}  -- |Returns whether the index's date calculations roll to the end of the month. {#fun pure qlIborIndexEndOfMonth as endOfMonth{withIborIndex*`GenIborIndex ibor'}->`Bool'#}

@@ -29,13 +29,8 @@   , setPricingEngine   ) where import QuantLib.Internal-import QuantLib.Internal.Type hiding (ptr)-import QuantLib.Internal.Enum-import Foreign.Ptr(Ptr, castPtr)-import Foreign.C.String(CString, peekCString)-import Foreign.C.Types(CUInt, CInt, CDouble)-import Foreign.Storable(Storable(..))-import Foreign.Marshal.Array(peekArray)+import QuantLib.Internal.Type hiding(ptr)+import QuantLib.Internal.Common  #include "qlTypesC2HS.h" #include "qlEnumC2HS.h"@@ -68,63 +63,11 @@ -- |returns the date the net present value refers to. {#fun qlInstrumentValuationDate as valuationDate{withInstrument*`GenInstrument i',preErrorCheck-`String'errorCheck*-}->`Day'toDay#} --- |One value from QuantLib's `Instrument::additionalResults()` map. QuantLib stores the map as--- `ext::any`, so this Haskell view picks three concrete shapes -- `Real` (`Double`), `std::string`--- (`String`), `std::vector<Real>` (`[Double]`) -- plus an `UnsupportedVal` fallback recording the--- value's C++ RTTI type name, so no key is ever silently dropped or mislabelled.-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) #}---- |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'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 ())`.+-- |Re-registers `struct QlAdditionalResult*` with c2hs as `RawResultPtr` (the type is defined in+-- `QuantLib.Internal.Common`, `nocode` here too) -- c2hs's pointer-type table is per-file, so+-- without this the `{#fun#}` below infers the out-parameter as the opaque `Ptr (Ptr ())` instead+-- of `Ptr RawResultPtr`, which fails to typecheck against `peekAdditionalResults`'s signature. {#pointer *QlAdditionalResult as RawResultPtr nocode#}-type RawResultPtr = Ptr RawResult---- |One raw `QlAdditionalResult` entry, peeked field-by-field via c2hs `{#get#}` hooks. Its--- `Storable` instance (`sizeOf`/`alignment` from `{#sizeof#}`/`{#alignof#}`, both read straight--- from the C struct layout, not hand-computed) is what lets `peekStructArray`--- (`QuantLib.Internal`) walk the C array via a plain `peekArray`, rather than hand-rolled pointer--- arithmetic.-data RawResult = RawResult-  { rKey :: CString, rType :: CInt, rDval :: CDouble-  , rSval :: CString, rVarr :: Ptr CDouble, rVlen :: CUInt }--instance Storable RawResult where-  sizeOf _ = {#sizeof QlAdditionalResult #}-  alignment _ = {#alignof QlAdditionalResult #}-  peek p = RawResult <$> {#get QlAdditionalResult.key #} p-                      <*> {#get QlAdditionalResult.type #} p-                      <*> {#get QlAdditionalResult.dval #} p-                      <*> {#get QlAdditionalResult.sval #} p-                      <*> {#get QlAdditionalResult.varr #} p-                      <*> {#get QlAdditionalResult.vlen #} p-  poke = error "RawResult is peek-only (read from C, never constructed in Haskell)"---- |Convert one raw entry into its keyed Haskell value. `sval`/`varr` are only read for the--- discriminant that owns them; their buffers are released in bulk afterwards, by--- `qlFreeAdditionalResults`, not per-field here.-convertResult :: RawResult -> IO (String, AdditionalResultVal)-convertResult r = do-  key <- peekCString (rKey r)-  val <- case toEnum (fromIntegral (rType r)) of-    AdditionalResultDouble -> return (RealVal (realToFrac (rDval r)))-    AdditionalResultString -> StringVal <$> peekCString (rSval r)-    AdditionalResultDoubleVector -> RealVectorVal . map realToFrac-                                       <$> peekArray (fromIntegral (rVlen r)) (rVarr r)-    AdditionalResultUnknown -> UnsupportedVal <$> peekCString (rSval r)-  return (key, val)---- |Peek the C array of `QlAdditionalResult` into a keyed list, then release the whole array (keys,--- `sval`/`varr` buffers, and the array itself) in one `qlFreeAdditionalResults` call.-peekAdditionalResults :: Ptr CUInt -> Ptr RawResultPtr -> IO [(String, AdditionalResultVal)]-peekAdditionalResults = peekStructArray convertResult (\l p -> qlFreeAdditionalResults l (castPtr p))  -- |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;

@@ -85,12 +85,11 @@   , convertibleZeroCouponBond   ) where import QuantLib.Internal-{#import QuantLib.Time.Calendar#}(BusinessDayConvention(..)) import QuantLib.Internal.Type {#import QuantLib.Time.Schedule#}(Frequency) {#import QuantLib.CashFlow#}(DurationType) {#import QuantLib.InterestRate#}(Compounding)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Syntax(deriveOptionsRecord) import QuantLib.Time.Calendar(calendar, CalendarConstructor(..)) import Data.Maybe(fromMaybe)@@ -101,6 +100,7 @@  #include "ql.h" +{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *QlQuote as Quote foreign -> CQuote nocode#} {#pointer *QlCallability foreign -> CQlCallability nocode#}@@ -166,7 +166,7 @@   ,preErrorCheck-`String'errorCheck*-}->`Bond'peekBond*#}  -- |Returns the maturity date of the bond-{#fun pure qlBondMaturityDate as maturityDate{withBond*`GenBond b'}->`Maybe Day' toMaybeDay#}+{#fun qlBondMaturityDate as maturityDate{withBond*`GenBond b',preErrorCheck-`String'errorCheck*-}->`Maybe Day' toMaybeDay#}  -- |generic compounding and frequency InterestRate coupons {#fun qlFixedRateBond as fixedRateBond{fromIntegral`Word' -- ^settlementDays@@ -174,13 +174,13 @@   ,withSchedule*`Schedule' -- ^schedule   ,withDoubleArray*`[Double]'& -- ^coupons   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,`Double' -- ^redemption   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,withCalendar*`Calendar' -- ^paymentCalendar   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,withDayCounter*`DayCounter' -- ^firstPeriodDayCounter   ,preErrorCheck-`String'errorCheck*-}->`FixedRateBond'peekFixedRateBond*#}@@ -192,11 +192,11 @@   ,withSchedule*`Schedule' -- ^schedule   ,withDoubleArray*`[Double]'& -- ^coupons   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,withDoubleArray*`[Double]'& -- ^redemptions   ,fromIntegral`Int' -- ^paymentLag@@ -228,12 +228,12 @@   ,withSchedule*`Schedule'   ,withDoubleArray*`[Double]'& -- ^coupons   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,withCalendar*`Calendar' -- ^paymentCalendar   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,preErrorCheck-`String'errorCheck*-}->`CPIBond'peekCPIBond*#} @@ -242,7 +242,7 @@   ,withCalendar*`Calendar'   ,`Double' -- ^faceAmount   ,withDay*`Day' -- ^maturityDate-  ,`BusinessDayConvention'+  ,fromEnumC`BusinessDayConvention'   ,`Double' -- ^redemption   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,preErrorCheck-`String'errorCheck*-}->`Bond'peekBond*#}@@ -253,7 +253,7 @@   ,withSchedule*`Schedule' -- ^schedule   ,withIborIndex*`GenIborIndex ibor'   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention'+  ,fromEnumC`BusinessDayConvention'   ,fromIntegral`Word' -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -264,9 +264,9 @@   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth-  ,`BusinessDayConvention' -- ^fixingConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixingConvention   ,preErrorCheck-`String'errorCheck*-}->`Bond'peekBond*#}  -- |CMS-rate bond@@ -275,7 +275,7 @@   ,withSchedule*`Schedule' -- ^schedule   ,withSwapIndex*`GenSwapIndex sidx'   ,withDayCounter*`DayCounter' -- ^paymentDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -294,7 +294,7 @@   ,withSchedule*`Schedule' -- ^schedule   ,withSwapIndex*`GenSwapIndex sidx'   ,withDayCounter*`DayCounter' -- ^paymentDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -327,7 +327,7 @@   ,withSchedule*`Schedule' -- ^schedule   ,withIborIndex*`GenIborIndex ibor'   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^fixingDays   ,withDoubleArray*`[Double]'& -- ^gearings   ,withDoubleArray*`[Double]'& -- ^spreads@@ -337,7 +337,7 @@   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,withDoubleArray*`[Double]'& -- ^redemptions   ,fromIntegral`Int' -- ^paymentLag@@ -520,13 +520,13 @@ {#fun qlCallableFixedRateBond as callableFixedRateBond{fromIntegral`Word' -- ^settlementDays   ,`Double' -- ^faceAmount   ,withSchedule*`Schedule',withDoubleArray*`[Double]'& -- ^coupons-  ,withDayCounter*`DayCounter',`BusinessDayConvention'+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention'   ,`Double' -- ^redemption   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,withCallabilityArray*`[Callability]'&   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,preErrorCheck-`String'errorCheck*-}->`CallableBond'peekCallableBond*#} @@ -534,7 +534,7 @@ {#fun qlCallableZeroCouponBond as callableZeroCouponBond{fromIntegral`Word' -- ^settlementDays   ,`Double' -- ^faceAmount   ,withCalendar*`Calendar',withDay*`Day' -- ^maturityDate-  ,withDayCounter*`DayCounter',`BusinessDayConvention'+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention'   ,`Double' -- ^redemption   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,withCallabilityArray*`[Callability]'&,preErrorCheck-`String'errorCheck*-}->`CallableBond'peekCallableBond*#}@@ -548,7 +548,7 @@   ,withDayCounter*`DayCounter',withSchedule*`Schedule',`Double' -- ^redemption   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,preErrorCheck-`String'errorCheck*-}->`ConvertibleBond'peekConvertibleBond*#} @@ -562,7 +562,7 @@   ,withDayCounter*`DayCounter',withSchedule*`Schedule',`Double' -- ^redemption   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^exCouponPeriod   ,withCalendar*`Calendar' -- ^exCouponCalendar-  ,`BusinessDayConvention' -- ^exCouponConvention+  ,fromEnumC`BusinessDayConvention' -- ^exCouponConvention   ,`Bool' -- ^exCouponEndOfMonth   ,preErrorCheck-`String'errorCheck*-}->`ConvertibleBond'peekConvertibleBond*#} 

@@ -23,10 +23,9 @@   , upfrontNPV   ) where import QuantLib.Internal-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Type {#import QuantLib.Instrument#}(PricingModel)-{#import QuantLib.Time.Calendar#}(BusinessDayConvention)  #include "qlTypesC2HS.h" #include "qlEnumC2HS.h"@@ -52,7 +51,7 @@ -- side Whether the protection is bought or sold. notional Notional value spread Running spread in fractional units. schedule Coupon schedule. paymentConvention Business-day convention for payment-date adjustment. dayCounter Day-count convention for accrual. settlesAccrual Whether or not the accrued coupon is due in the event of a default. paysAtDefaultTime If set to true, any payments triggered by a default event are due at default time. If set to false, they are due at the end of the accrual period. protectionStart The first date where a default event will trigger the contract. {#fun qlCreditDefaultSwap as creditDefaultSwap{`ProtectionSide',`Double' -- ^notional   ,`Double' -- ^spread-  ,withSchedule*`Schedule',`BusinessDayConvention',withDayCounter*`DayCounter',`Bool' -- ^settlesAccrual+  ,withSchedule*`Schedule',fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter',`Bool' -- ^settlesAccrual   ,`Bool' -- ^paysAtDefaultTime   ,withMaybeDay*`Maybe Day' -- ^protectionStart   ,withClaim*`Claim'@@ -67,7 +66,7 @@ {#fun qlCreditDefaultSwap1 as creditDefaultSwap'{`ProtectionSide',`Double' -- ^notional   ,`Double' -- ^upfront   ,`Double' -- ^spread-  ,withSchedule*`Schedule',`BusinessDayConvention',withDayCounter*`DayCounter',`Bool' -- ^settlesAccrual+  ,withSchedule*`Schedule',fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter',`Bool' -- ^settlesAccrual   ,`Bool' -- ^paysAtDefaultTime   ,withMaybeDay*`Maybe Day' -- ^protectionStart   ,withMaybeDay*`Maybe Day' -- ^upfrontDate

@@ -0,0 +1,405 @@+module QuantLib.Instrument.Energy+  (+    SecondaryCosts+  , SecondaryCostAmounts+  , PricingErrorLevel(..)+  , PricingError(..)+  , PricingErrors+  , EnergyDailyPosition(..)+  , EnergyDailyPositions+  , CommodityCashFlow+  , CommodityCashFlows++  , commodityCashFlowDate+  , commodityCashFlowDiscountedAmount+  , commodityCashFlowUndiscountedAmount+  , commodityCashFlowDiscountedPaymentAmount+  , commodityCashFlowUndiscountedPaymentAmount+  , commodityCashFlowDiscountFactor+  , commodityCashFlowPaymentDiscountFactor+  , commodityCashFlowFinalized++  , addPricingError+  , secondaryCostAmounts+  , pricingErrors++  , quantity++  , EnergyFuture+  , energyFuture++  , EnergySwap+  , dailyPositions+  , paymentCashFlows++  , EnergyVanillaSwap+  , energyVanillaSwap++  , EnergyBasisSwap+  , energyBasisSwap++  , DeliverySchedule(..)+  , QuantityPeriodicity(..)+  , createPricingPeriods+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type+import QuantLib.Internal.Common+import QuantLib.Commodity+import Foreign.Marshal.Alloc(alloca)+import Foreign.Marshal.Utils(fromBool)++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *Currency foreign -> CCurrency nocode#}+{#pointer *CommodityType foreign -> CCommodityType nocode#}+{#pointer *UnitOfMeasure foreign -> CUnitOfMeasure nocode#}+{#pointer *PaymentTerm foreign -> CPaymentTerm nocode#}+{#pointer *QlCommodityIndex as CommodityIndex foreign -> CCommodityIndex' nocode#}+{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}+{#pointer *QlCommodity as Commodity foreign -> CCommodity' nocode#}+{#pointer *QlEnergyCommodity as EnergyCommodity foreign -> CEnergyCommodity' nocode#}+{#pointer *QlEnergyFuture as EnergyFuture foreign -> CEnergyFuture' nocode#}+{#pointer *QlEnergySwap as EnergySwap foreign -> CEnergySwap' nocode#}+{#pointer *QlEnergyVanillaSwap as EnergyVanillaSwap foreign -> CEnergyVanillaSwap' nocode#}+{#pointer *QlEnergyBasisSwap as EnergyBasisSwap foreign -> CEnergyBasisSwap' nocode#}+{#pointer *QlCommodityCashFlow as CommodityCashFlow foreign -> CCommodityCashFlow nocode#}++-- |QuantLib's @map<string, ext::any>@, used with exactly two concrete alternatives across the+-- module (@CommodityUnitCost@\/@Money@, confirmed from @energycommodity.cpp@'s two @any_cast@+-- branches) -- bound as a real 2-variant sum rather than a generic @any@. Passed optionally to+-- every energy-instrument constructor below; @[]@ stands in for upstream's null @shared_ptr@.+type SecondaryCosts = [(String, Either CommodityUnitCost (Double, Currency))]++-- |The computed, currency-resolved output of 'SecondaryCosts' -- @Commodity::secondaryCostAmounts()@,+-- a @map<string, Money>@.+type SecondaryCostAmounts = [(String, (Double, Currency))]++-- |A single entry of 'PricingErrors' -- @tradeId@ is never set by any constructor path that+-- reaches 'addPricingError' (upstream's own call sites all default it to empty), so it isn't+-- bound.+data PricingError = PricingError+  { pricingErrorLevel :: PricingErrorLevel+  , pricingErrorMessage :: String+  , pricingErrorDetail :: String+  } deriving (Show, Eq)++type PricingErrors = [PricingError]++-- |One day's position detail from an 'EnergySwap' leaf's @dailyPositions()@ -- a flat record+-- rather than a @(Day, ...)@ pair, since 'edpDate' already carries the map key.+data EnergyDailyPosition = EnergyDailyPosition+  { edpDate :: Day+  , edpQuantityAmount :: Double+  , edpPayLegPrice :: Double+  , edpReceiveLegPrice :: Double+  , edpRiskDelta :: Double+  , edpUnrealized :: Bool+  } deriving (Show, Eq)++type EnergyDailyPositions = [EnergyDailyPosition]++type CommodityCashFlows = [CommodityCashFlow]++-- |The cash flow's date -- also the @paymentCashFlows()@ map's own key, so it isn't duplicated as+-- a separate tuple field alongside the list of 'CommodityCashFlow's.+{#fun pure qlCommodityCashFlowDate as commodityCashFlowDate{withCommodityCashFlow*`CommodityCashFlow'}->`Day'toDay#}++-- |The discounted amount, in the global commodity base currency ('QuantLib.Commodity.commoditySettingsCurrency').+--+-- Not 'pure': the shim's own @ret(new Currency(...))@ is a 'bad_alloc'-only throw point, and letting+-- a C++ exception unwind across the FFI boundary from an 'unsafePerformIO'-backed pure binding is+-- undefined behavior, so this needs the same 'char **e'\/'preErrorCheck' error channel as any other+-- throwing call.+{#fun qlCommodityCashFlowDiscountedAmount as commodityCashFlowDiscountedAmount{withCommodityCashFlow*`CommodityCashFlow',alloca-`Currency'peekCurrencyPtr*,preErrorCheck-`String'errorCheck*-}->`Double'#}+-- |As 'commodityCashFlowDiscountedAmount', without the discount factor applied.+{#fun qlCommodityCashFlowUndiscountedAmount as commodityCashFlowUndiscountedAmount{withCommodityCashFlow*`CommodityCashFlow',alloca-`Currency'peekCurrencyPtr*,preErrorCheck-`String'errorCheck*-}->`Double'#}+-- |The discounted amount, in the payment (leg) currency.+{#fun qlCommodityCashFlowDiscountedPaymentAmount as commodityCashFlowDiscountedPaymentAmount{withCommodityCashFlow*`CommodityCashFlow',alloca-`Currency'peekCurrencyPtr*,preErrorCheck-`String'errorCheck*-}->`Double'#}+-- |As 'commodityCashFlowDiscountedPaymentAmount', without the discount factor applied.+{#fun qlCommodityCashFlowUndiscountedPaymentAmount as commodityCashFlowUndiscountedPaymentAmount{withCommodityCashFlow*`CommodityCashFlow',alloca-`Currency'peekCurrencyPtr*,preErrorCheck-`String'errorCheck*-}->`Double'#}+-- |The discount factor applied to the base-currency amount.+{#fun pure qlCommodityCashFlowDiscountFactor as commodityCashFlowDiscountFactor{withCommodityCashFlow*`CommodityCashFlow'}->`Double'#}+-- |The discount factor applied to the payment-currency amount.+{#fun pure qlCommodityCashFlowPaymentDiscountFactor as commodityCashFlowPaymentDiscountFactor{withCommodityCashFlow*`CommodityCashFlow'}->`Double'#}+-- |Whether this cash flow's payment date has already occurred as of the evaluation date.+{#fun pure qlCommodityCashFlowFinalized as commodityCashFlowFinalized{withCommodityCashFlow*`CommodityCashFlow'}->`Bool'#}++-- |Record a pricing diagnostic against a 'Commodity'\/'EnergyCommodity' leaf (any of 'EnergyFuture',+-- 'EnergyVanillaSwap', 'EnergyBasisSwap'), retrievable afterwards via 'pricingErrors'. Mirrors+-- upstream's own default empty @detail@ with a plain @\"\"@ argument.+{#fun qlCommodityAddPricingError as addPricingError+  {withCommodity*`GenCommodity c'+  ,fromEnumC`PricingErrorLevel'+  ,`String'+  ,`String'}->`()'#}++{#fun qlCommoditySecondaryCostAmounts as qlCommoditySecondaryCostAmounts_+  {withCommodity*`GenCommodity c'+  ,preArray-`[String]'&peekCStringArray*+  ,preArray-`[Double]'&peekDoubleArray*+  ,preArray-`[Currency]'&peekCurrencyArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |The currency-resolved secondary costs computed during the most recent pricing+-- (@performCalculations()@) of this 'Commodity'\/'EnergyCommodity' leaf -- a plain member read, not+-- itself a pricing trigger, so call 'QuantLib.Instrument.npv' first if it hasn't been priced yet.+secondaryCostAmounts :: GenCommodity c -> IO SecondaryCostAmounts+secondaryCostAmounts o = do+  (keys, amts, ccys) <- qlCommoditySecondaryCostAmounts_ o+  pure $ zip keys (zip amts ccys)++{#fun qlCommodityPricingErrors as qlCommodityPricingErrors_+  {withCommodity*`GenCommodity c'+  ,preArray-`[PricingErrorLevel]'&peekPricingErrorLevelArray*+  ,preArray-`[String]'&peekCStringArray*+  ,preArray-`[String]'&peekCStringArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Every pricing diagnostic recorded so far (via upstream's own internal calls, or via+-- 'addPricingError') against this 'Commodity'\/'EnergyCommodity' leaf.+pricingErrors :: GenCommodity c -> IO PricingErrors+pricingErrors o = do+  (levels, errs, details) <- qlCommodityPricingErrors_ o+  pure $ zipWith3 PricingError levels errs details++{#fun qlEnergyCommodityQuantity as qlEnergyCommodityQuantity_+  {withEnergyCommodity*`GenEnergyCommodity e'+  ,alloca-`CommodityType'peekCommodityTypePtr*+  ,alloca-`UnitOfMeasure'peekUnitOfMeasurePtr*+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The commodity quantity of this 'EnergyCommodity' leaf -- either the plain quantity given at+-- construction ('EnergyFuture') or the sum across every 'PricingPeriod' ('EnergySwap' and its+-- leaves, a real computed sum -- see @energyswap.cpp@). One binding covers both, dispatched+-- virtually on the C++ side.+quantity :: GenEnergyCommodity e -> IO Quantity+quantity o = do+  (amt, ct, uom) <- qlEnergyCommodityQuantity_ o+  pure (ct, uom, amt)++-- |Construct an energy future: a single mark-to-market position against a 'CommodityIndex',+-- struck at a fixed 'CommodityUnitCost' trade price. @buySell@ is a signed multiplier (@1@ to buy,+-- @-1@ to sell), matching upstream's own @Integer buySell@ (not a @Bool@). @tradePrice@\/@index@+-- are not bound as getters -- both are plain, never-mutated echoes of these same constructor+-- arguments (per CLAUDE.md's trivial-getter rule); use 'quantity' for the one genuinely-shared+-- accessor.+energyFuture :: Int -- ^buySell+             -> Quantity+             -> CommodityUnitCost -- ^tradePrice+             -> CommodityIndex+             -> CommodityType+             -> SecondaryCosts+             -> IO EnergyFuture+energyFuture buySell (qCt, qUom, qAmt) (tpAmt, tpCcy, tpUom) index cmdType secCosts =+  qlEnergyFuture_ buySell qCt qUom qAmt tpAmt tpCcy tpUom index cmdType+    scKeys scIsUnitCost scAmts scCcys scUoms+  where (scKeys, scIsUnitCost, scAmts, scCcys, scUoms) = secondaryCostsFields secCosts++{#fun qlEnergyFuture as qlEnergyFuture_+  {`Int'+  ,withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,`Double',withCurrency*`Currency',withUnitOfMeasure*`UnitOfMeasure'+  ,withCommodityIndex*`CommodityIndex'+  ,withCommodityType*`CommodityType'+  ,withStringArray*`[String]'&+  ,withBoolArray*`[Bool]'&+  ,withDoubleArray*`[Double]'&+  ,withCurrencyArray*`[Currency]'&+  ,withMaybeUnitOfMeasureArray*`[Maybe UnitOfMeasure]'&+  ,preErrorCheck-`String'errorCheck*-}->`EnergyFuture'peekEnergyFuture*#}++{#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*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |The per-day pricing breakdown computed during this 'EnergySwap' leaf's most recent+-- @performCalculations()@ -- populated only after pricing (call 'QuantLib.Instrument.npv' first).+dailyPositions :: GenEnergySwap s -> IO EnergyDailyPositions+dailyPositions s = do+  (dates, qtyAmts, payPrices, recvPrices, riskDeltas, unrealized) <- qlEnergySwapDailyPositions_ s+  pure $ zipWith6 EnergyDailyPosition dates qtyAmts payPrices recvPrices riskDeltas unrealized++-- |The realized\/unrealized payment cash flows computed during this 'EnergySwap' leaf's most+-- recent @performCalculations()@ -- populated only after pricing.+{#fun qlEnergySwapPaymentCashFlows as paymentCashFlows+  {withEnergySwap*`GenEnergySwap s'+  ,preArray-`[CommodityCashFlow]'&peekCommodityCashFlowArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Split a 'SecondaryCosts' list into the five parallel arrays every energy-instrument+-- constructor's C shim consumes it as (keys, is-a-'CommodityUnitCost'-flag, amounts, currencies,+-- units-of-measure -- 'Nothing' for a plain 'Money' entry).+secondaryCostsFields :: SecondaryCosts -> ([String], [Bool], [Double], [Currency], [Maybe UnitOfMeasure])+secondaryCostsFields entries =+  ( map fst entries+  , map (either (const True) (const False) . snd) entries+  , map (either (\(a,_,_) -> a) fst . snd) entries+  , map (either (\(_,c,_) -> c) snd . snd) entries+  , map (either (\(_,_,u) -> Just u) (const Nothing) . snd) entries+  )++-- |Split a 'PricingPeriods' list into the six parallel arrays every energy-swap constructor's C+-- shim consumes it as (start dates, end dates, payment dates, quantity commodity types, quantity+-- units of measure, quantity amounts).+pricingPeriodsFields :: PricingPeriods -> ([Day], [Day], [Day], [CommodityType], [UnitOfMeasure], [Double])+pricingPeriodsFields pps =+  ( map pricingPeriodStartDate pps+  , map pricingPeriodEndDate pps+  , map pricingPeriodPaymentDate pps+  , map (\(t,_,_) -> t) qtys+  , map (\(_,u,_) -> u) qtys+  , map (\(_,_,a) -> a) qtys+  )+  where qtys = map pricingPeriodQuantity pps++-- |Construct a vanilla energy swap: fixed 'CommodityUnitCost' price against a floating+-- 'CommodityIndex' quote, over one or more 'PricingPeriod's. @payer@ selects which leg (fixed or+-- floating) is paid. @payReceive@\/@fixedPrice@\/@fixedPriceUnitOfMeasure@\/@index@ are not bound+-- as getters -- all are plain, never-mutated echoes of this constructor's own arguments (per+-- CLAUDE.md's trivial-getter rule; @payReceive@ specifically is just @if payer then 1 else 0@,+-- reproducible with no C++ call at all).+energyVanillaSwap :: Bool -- ^payer+                  -> Calendar+                  -> (Double, Currency) -- ^fixedPrice+                  -> UnitOfMeasure -- ^fixedPriceUnitOfMeasure+                  -> CommodityIndex+                  -> Currency -- ^payCurrency+                  -> Currency -- ^receiveCurrency+                  -> PricingPeriods+                  -> CommodityType+                  -> SecondaryCosts+                  -> GenYieldTermStructure y1 -- ^payLegTermStructure+                  -> GenYieldTermStructure y2 -- ^receiveLegTermStructure+                  -> GenYieldTermStructure y3 -- ^discountTermStructure+                  -> IO EnergyVanillaSwap+energyVanillaSwap payer calendar (fpAmt, fpCcy) fpUom index payCcy receiveCcy pps cmdType secCosts+                  payLegTS receiveLegTS discountTS =+  qlEnergyVanillaSwap_ payer calendar fpAmt fpCcy fpUom index payCcy receiveCcy+    ppStarts ppEnds ppPays ppTypes ppUoms ppAmts+    cmdType scKeys scIsUnitCost scAmts scCcys scUoms+    payLegTS receiveLegTS discountTS+  where+    (ppStarts, ppEnds, ppPays, ppTypes, ppUoms, ppAmts) = pricingPeriodsFields pps+    (scKeys, scIsUnitCost, scAmts, scCcys, scUoms) = secondaryCostsFields secCosts++{#fun qlEnergyVanillaSwap as qlEnergyVanillaSwap_+  {fromBool`Bool'+  ,withCalendar*`Calendar'+  ,`Double',withCurrency*`Currency'+  ,withUnitOfMeasure*`UnitOfMeasure'+  ,withCommodityIndex*`CommodityIndex'+  ,withCurrency*`Currency'+  ,withCurrency*`Currency'+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withCommodityTypeArray*`[CommodityType]'&+  ,withUnitOfMeasureArray*`[UnitOfMeasure]'&+  ,withDoubleArray*`[Double]'&+  ,withCommodityType*`CommodityType'+  ,withStringArray*`[String]'&+  ,withBoolArray*`[Bool]'&+  ,withDoubleArray*`[Double]'&+  ,withCurrencyArray*`[Currency]'&+  ,withMaybeUnitOfMeasureArray*`[Maybe UnitOfMeasure]'&+  ,withYieldTermStructure*`GenYieldTermStructure y1'+  ,withYieldTermStructure*`GenYieldTermStructure y2'+  ,withYieldTermStructure*`GenYieldTermStructure y3'+  ,preErrorCheck-`String'errorCheck*-}->`EnergyVanillaSwap'peekEnergyVanillaSwap*#}++-- |Construct an energy basis swap: two floating 'CommodityIndex' legs (pay\/receive), one of them+-- offset by a fixed 'CommodityUnitCost' basis, over one or more 'PricingPeriod's. @spreadToPayLeg@+-- selects which leg the basis is added to. @payIndex@\/@receiveIndex@\/@basis@ are not bound as+-- getters -- all are plain, never-mutated echoes of this constructor's own arguments.+energyBasisSwap :: Calendar+                -> CommodityIndex -- ^spreadIndex+                -> CommodityIndex -- ^payIndex+                -> CommodityIndex -- ^receiveIndex+                -> Bool -- ^spreadToPayLeg+                -> Currency -- ^payCurrency+                -> Currency -- ^receiveCurrency+                -> PricingPeriods+                -> CommodityUnitCost -- ^basis+                -> CommodityType+                -> SecondaryCosts+                -> GenYieldTermStructure y1 -- ^payLegTermStructure+                -> GenYieldTermStructure y2 -- ^receiveLegTermStructure+                -> GenYieldTermStructure y3 -- ^discountTermStructure+                -> IO EnergyBasisSwap+energyBasisSwap calendar spreadIndex payIndex receiveIndex spreadToPayLeg payCcy receiveCcy pps+                (basisAmt, basisCcy, basisUom) cmdType secCosts payLegTS receiveLegTS discountTS =+  qlEnergyBasisSwap_ calendar spreadIndex payIndex receiveIndex spreadToPayLeg payCcy receiveCcy+    ppStarts ppEnds ppPays ppTypes ppUoms ppAmts+    basisAmt basisCcy basisUom+    cmdType scKeys scIsUnitCost scAmts scCcys scUoms+    payLegTS receiveLegTS discountTS+  where+    (ppStarts, ppEnds, ppPays, ppTypes, ppUoms, ppAmts) = pricingPeriodsFields pps+    (scKeys, scIsUnitCost, scAmts, scCcys, scUoms) = secondaryCostsFields secCosts++{#fun qlEnergyBasisSwap as qlEnergyBasisSwap_+  {withCalendar*`Calendar'+  ,withCommodityIndex*`CommodityIndex'+  ,withCommodityIndex*`CommodityIndex'+  ,withCommodityIndex*`CommodityIndex'+  ,fromBool`Bool'+  ,withCurrency*`Currency'+  ,withCurrency*`Currency'+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withCommodityTypeArray*`[CommodityType]'&+  ,withUnitOfMeasureArray*`[UnitOfMeasure]'&+  ,withDoubleArray*`[Double]'&+  ,`Double',withCurrency*`Currency',withUnitOfMeasure*`UnitOfMeasure'+  ,withCommodityType*`CommodityType'+  ,withStringArray*`[String]'&+  ,withBoolArray*`[Bool]'&+  ,withDoubleArray*`[Double]'&+  ,withCurrencyArray*`[Currency]'&+  ,withMaybeUnitOfMeasureArray*`[Maybe UnitOfMeasure]'&+  ,withYieldTermStructure*`GenYieldTermStructure y1'+  ,withYieldTermStructure*`GenYieldTermStructure y2'+  ,withYieldTermStructure*`GenYieldTermStructure y3'+  ,preErrorCheck-`String'errorCheck*-}->`EnergyBasisSwap'peekEnergyBasisSwap*#}++{#fun qlCreatePricingPeriods as qlCreatePricingPeriods_+  {withDay*`Day'+  ,withDay*`Day'+  ,withCommodityType*`CommodityType',withUnitOfMeasure*`UnitOfMeasure',`Double'+  ,fromEnumC`DeliverySchedule'+  ,fromEnumC`QuantityPeriodicity'+  ,withPaymentTerm*`PaymentTerm'+  ,preArray-`[Day]'&peekDayArray*+  ,preArray-`[Day]'&peekDayArray*+  ,preArray-`[Day]'&peekDayArray*+  ,preArray-`[CommodityType]'&peekCommodityTypeArray*+  ,preArray-`[UnitOfMeasure]'&peekUnitOfMeasureArray*+  ,preArray-`[Double]'&peekDoubleArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Split @[startDate, endDate)@ into 'PricingPeriod's of the given quantity, per a+-- 'DeliverySchedule'\/'QuantityPeriodicity'\/'PaymentTerm' combination --+-- @CommodityPricingHelper::createPricingPeriods@. Upstream only actually implements two+-- combinations ('Monthly' with 'PerMonth', 'Daily' with 'PerDay'); every other 'DeliverySchedule'+-- silently returns @[]@ (no periods, no error -- checked directly against+-- @commoditypricinghelpers.cpp@, not assumed from the header).+createPricingPeriods :: Day -> Day -> Quantity -> DeliverySchedule -> QuantityPeriodicity -> PaymentTerm -> IO PricingPeriods+createPricingPeriods startDate endDate (ct, uom, amt) deliverySchedule qtyPeriodicity pmtTerm = do+  (starts, ends, pays, types, uoms, amts) <-+    qlCreatePricingPeriods_ startDate endDate ct uom amt deliverySchedule qtyPeriodicity pmtTerm+  pure $ zipWith6 (\s e p t u a -> pricingPeriod s e p (t, u, a)) starts ends pays types uoms amts++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -25,8 +25,7 @@   , npvTargetCurrency   ) where import QuantLib.Internal-{#import QuantLib.Instrument#}-{#import QuantLib.Time.Calendar#}(BusinessDayConvention)+import QuantLib.Internal.Common import QuantLib.Internal.Type {#import QuantLib.InterestRate#} @@ -36,6 +35,7 @@  #include "ql.h" +{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *QlBond as Bond foreign -> CBond' nocode#} {#pointer *QlForward as Forward foreign -> CForward' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}@@ -60,7 +60,7 @@   ,withDay*`Day' -- ^maturityDate   ,fromEnumC`PositionType',`Double' -- ^strike   ,fromIntegral`Word' -- ^settlementDays-  ,withDayCounter*`DayCounter',withCalendar*`Calendar',`BusinessDayConvention',withBond*`GenBond b',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y1)' -- ^discountCurve+  ,withDayCounter*`DayCounter',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withBond*`GenBond b',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y1)' -- ^discountCurve   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y2)' -- ^incomeDiscountCurve   ,preErrorCheck-`String'errorCheck*-}->`BondForward'peekBondForward*#} 

@@ -0,0 +1,83 @@+module QuantLib.Instrument.InflationCapFloor+  (+    YoYInflationCapFloor+  , yoyInflationCap+  , yoyInflationCollar+  , yoyInflationFloor+  , yoyInflationCapFloorAtmRate+  , yoyInflationCapFloorOptionlet++  , CPICapFloor+  , cpiCapFloor+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type+import QuantLib.Internal.Common++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#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#}++-- |Constructs a YoY-inflation cap: pays the excess of the YoY leg's rate over each exercise+-- rate, if positive. Unlike a nominal cap, the first optionlet is live (YoY inflation sets in+-- arrears, so there is no reason to omit it -- see upstream's own note on+-- 'YoYInflationCapFloor').+{#fun qlYoYInflationCap as yoyInflationCap{withLeg*`GenLeg l' -- ^yoyLeg+  ,withDoubleArray*`[Double]'& -- ^exerciseRates+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCapFloor'peekYoYInflationCapFloor*#}++-- |Constructs a YoY-inflation collar: a cap struck at the cap rates combined with a floor+-- struck at the floor rates.+{#fun qlYoYInflationCollar as yoyInflationCollar{withLeg*`GenLeg l' -- ^yoyLeg+  ,withDoubleArray*`[Double]'& -- ^capRates+  ,withDoubleArray*`[Double]'& -- ^floorRates+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCapFloor'peekYoYInflationCapFloor*#}++-- |Constructs a YoY-inflation floor: pays the excess of each exercise rate over the YoY leg's+-- rate, if positive.+{#fun qlYoYInflationFloor as yoyInflationFloor{withLeg*`GenLeg l' -- ^yoyLeg+  ,withDoubleArray*`[Double]'& -- ^exerciseRates+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCapFloor'peekYoYInflationCapFloor*#}++-- |The fair (at-the-money) rate for the cap\/floor's underlying YoY leg, discounted on the+-- given curve.+{#fun qlYoYInflationCapFloorAtmRate as yoyInflationCapFloorAtmRate{withGenInstrument*`YoYInflationCapFloor'+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^discountCurve+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Returns the n-th optionlet as a new YoYInflationCapFloor with only one cash flow.+{#fun qlYoYInflationCapFloorOptionlet as yoyInflationCapFloorOptionlet{withGenInstrument*`YoYInflationCapFloor'+  ,fromIntegral`Word' -- ^n+  ,preErrorCheck-`String'errorCheck*-}->`YoYInflationCapFloor'peekYoYInflationCapFloor*#}++-- |A CPI cap or floor: a single cumulative option on cumulative inflation up to maturity+-- (@CPI(T)\/CPI(0)@), not a strip of optionlets like 'YoYInflationCapFloor' -- similar in shape+-- to a ZCIIS option. No implied-volatility inspector: pricing goes purely through+-- 'QuantLib.PricingEngine.interpolatingCPICapFloorEngine' off a market price surface, there is+-- no vol-driven engine for it in QL 1.43.+{#fun qlCPICapFloor as cpiCapFloor{fromEnumC`OptionType'+  ,`Double' -- ^nominal+  ,withDay*`Day' -- ^startDate+  ,`Double' -- ^baseCPI+  ,withDay*`Day' -- ^maturity+  ,withCalendar*`Calendar' -- ^fixCalendar+  ,fromEnumC`BusinessDayConvention' -- ^fixConvention+  ,withCalendar*`Calendar' -- ^payCalendar+  ,fromEnumC`BusinessDayConvention' -- ^payConvention+  ,`Double' -- ^strike+  ,withZeroInflationIndex*`ZeroInflationIndex'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag+  ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation+  ,preErrorCheck-`String'errorCheck*-}->`CPICapFloor'peekCPICapFloor*#}++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -13,6 +13,7 @@   , QuantoBarrierOption   , QuantoForwardVanillaOption   , QuantoVanillaOption+  , SoftBarrierOption   , VanillaOption    , ExerciseType(..)@@ -40,6 +41,8 @@   , partialTimeBarrierOption   , doubleBarrierOption   , doubleBarrierOptionImpliedVolatility+  , softBarrierOption+  , softBarrierOptionImpliedVolatility   , forwardVanillaOption   , compoundOption   , delta1@@ -47,6 +50,9 @@   , gamma1   , gamma2   , margrabeOption+  , simpleChooserOption+  , twoAssetCorrelationOption+  , writerExtensibleOption    , multiAssetOption   , deltaForward@@ -84,13 +90,14 @@ import QuantLib.Internal {#import QuantLib.Instrument#}(AverageType, BarrierType, DoubleBarrierType, PartialBarrierRange) import QuantLib.Internal.Type-import QuantLib.Internal.Enum+import QuantLib.Internal.Common  {#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#}+{#pointer *QlSoftBarrierOption as SoftBarrierOption foreign -> CSoftBarrierOption' nocode#} {#pointer *QlMargrabeOption as MargrabeOption foreign -> CMargrabeOption' nocode#} {#pointer *QlMultiAssetOption as MultiAssetOption foreign -> CMultiAssetOption' nocode#} {#pointer *QlOneAssetOption as OneAssetOption foreign -> COneAssetOption' nocode#}@@ -140,6 +147,20 @@   ,`Double' -- ^rebate   ,withStrikedPayoff*`StrikedPayoff',withExercise*`Exercise',preErrorCheck-`String'errorCheck*-}->`DoubleBarrierOption'peekDoubleBarrierOption*#} +-- |Soft barrier option on a single asset: knocked in/out proportionally over a barrier range [barrierLo, barrierHi], rather than in full at a single hard barrier. European exercise only.+{#fun qlSoftBarrierOption as softBarrierOption{`BarrierType',`Double' -- ^barrierLo+  ,`Double' -- ^barrierHi+  ,withStrikedPayoff*`StrikedPayoff',withExercise*`Exercise',preErrorCheck-`String'errorCheck*-}->`SoftBarrierOption'peekSoftBarrierOption*#}++-- |Implied Black-Scholes volatility that reproduces the given price for a SoftBarrierOption; see VanillaOption's implied-volatility for the caveats on reliability.+{#fun qlSoftBarrierOptionImpliedVolatility as softBarrierOptionImpliedVolatility{withSoftBarrierOption*`SoftBarrierOption',`Double' -- ^price+  ,withGeneralizedBlackScholesProcess*`GenGeneralizedBlackScholesProcess gbs'+  ,`Double' -- ^accuracy+  ,fromIntegral`Word' -- ^maxEvaluations+  ,`Double' -- ^minVol+  ,`Double' -- ^maxVol+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}+ -- |Forward-starting (strike-resetting) version of a vanilla option. {#fun qlForwardVanillaOption as forwardVanillaOption{`Double' -- ^moneyness   ,withDay*`Day' -- ^resetDate@@ -152,6 +173,18 @@   ,withExercise*`Exercise' -- ^daughterExercise   ,preErrorCheck-`String'errorCheck*-}->`OneAssetOption'peekOneAssetOption*#} +-- |Simple chooser option on a single asset: the holder chooses, on the choosing date, whether the option is a call or a put; both share the same strike and exercise date.+{#fun qlSimpleChooserOption as simpleChooserOption{withDay*`Day' -- ^choosingDate+  ,`Double' -- ^strike+  ,withExercise*`Exercise',preErrorCheck-`String'errorCheck*-}->`OneAssetOption'peekOneAssetOption*#}++-- |Writer-extensible option on a single asset: if out of the money at the first exercise, it is extended to a second exercise with an amended payoff.+{#fun qlWriterExtensibleOption as writerExtensibleOption{withPlainVanillaPayoff*`PlainVanillaPayoff' -- ^payoff1+  ,withExercise*`Exercise' -- ^exercise1+  ,withPlainVanillaPayoff*`PlainVanillaPayoff' -- ^payoff2+  ,withExercise*`Exercise' -- ^exercise2+  ,preErrorCheck-`String'errorCheck*-}->`OneAssetOption'peekOneAssetOption*#}+ -- |Sensitivity of a MargrabeOption's value to the price of the first asset. {#fun qlMargrabeOptionDelta1 as delta1{withMargrabeOption*`MargrabeOption',preErrorCheck-`String'errorCheck*-}->`Double'#} @@ -183,6 +216,12 @@  -- |Base construction for an option on multiple assets. {#fun qlMultiAssetOption as multiAssetOption{withPayoff*`Payoff',withExercise*`Exercise',preErrorCheck-`String'errorCheck*-}->`MultiAssetOption'peekMultiAssetOption*#}++-- |Two-asset correlation option: pays a payoff based on the second asset's value against strike2 at exercise, but only if the first asset is also in the money against strike1; otherwise pays 0.+{#fun qlTwoAssetCorrelationOption as twoAssetCorrelationOption{fromEnumC`OptionType' -- ^type+  ,`Double' -- ^strike1+  ,`Double' -- ^strike2+  ,withExercise*`Exercise',preErrorCheck-`String'errorCheck*-}->`MultiAssetOption'peekMultiAssetOption*#}  -- |Probability of the option expiring in-the-money in a cash-or-nothing sense. {#fun qlOneAssetOptionItmCashProbability as itmCashProbability{withOneAssetOption*`GenOneAssetOption oo',preErrorCheck-`String'errorCheck*-}->`Double'#}

@@ -1,9 +1,15 @@ {-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TemplateHaskell #-} module QuantLib.Instrument.Swap   (     Swaption+  , NonstandardSwaption   , Swap+  , FixedVsFloatingSwap   , VanillaSwap+  , NonstandardSwap+  , FloatFloatSwap+  , FloatFloatSwaption   , AssetSwap   , OvernightIndexedSwap   , BMASwap@@ -14,6 +20,9 @@   , EquityTotalReturnSwap   , VarianceSwap   , VarianceOption+  , ConstNotionalCrossCurrencySwap+  , ConstNotionalCrossCurrencyBasisSwap+  , ConstNotionalCrossCurrencyFixedVsFloatingSwap    , asSwap @@ -21,11 +30,25 @@   , SwapType(..)   , SwaptionPriceType(..)   , CPIInterpolationType(..)+  , CalibrationBasketType(..)+  , FloatFloatSwapOpts(..)+  , defaultFloatFloatSwapOpts+  , FloatFloatSwapVaryingOpts(..)+  , defaultFloatFloatSwapVaryingOpts+  , ConstNotionalCrossCurrencyBasisSwapOpts(..)+  , defaultConstNotionalCrossCurrencyBasisSwapOpts    , swap'   , swap   , bmaSwap   , vanillaSwap+  , nonstandardSwapFromVanilla+  , nonstandardSwap+  , nonstandardSwap'+  , floatFloatSwap+  , floatFloatSwap'+  , fairSpread1+  , fairSpread2   , makeVanillaSwap   , makeCms   , zeroCouponInflationSwap@@ -56,6 +79,19 @@   , startDate   , startDiscounts +  -- ConstNotionalCrossCurrencySwap family+  , constNotionalCrossCurrencySwap+  , constNotionalCrossCurrencySwap'+  , legCurrency+  , inCcyLegBPS+  , inCcyLegNPV+  , npvDateDiscounts+  , constNotionalCrossCurrencyBasisSwap+  , fairPaySpread+  , fairRecSpread+  , constNotionalCrossCurrencyFixedVsFloatingSwap+  , xccyFairRate+   , bmaLeg   , bmaLegBPS   , bmaLegNPV@@ -67,6 +103,11 @@   , liborLegNPV    , swaption+  , nonstandardSwaptionFromSwaption+  , nonstandardSwaption+  , floatFloatSwaption+  , calibrationBasket+  , floatFloatSwaptionCalibrationBasket    -- AssetSwap   , assetSwap@@ -92,14 +133,15 @@   , HasSpread(..)   ) where import Data.Maybe(fromMaybe)+import QuantLib.Internal.Syntax(deriveOptionsRecord) import QuantLib.Internal {#import QuantLib.Instrument#} {#import QuantLib.InterestRate#}(VolatilityType)-{#import QuantLib.CashFlow#}(RateAveragingType)+{#import QuantLib.CashFlow#}(RateAveragingType(..)) import QuantLib.CashFlow(cmsLeg, iborLeg)-{#import QuantLib.Time.Calendar#}(BusinessDayConvention(..), adjust, advance)+{#import QuantLib.Time.Calendar#}(adjust, advance) import QuantLib.Internal.Type-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Time.Schedule(schedule, DateGenerationRule(..)) import QuantLib.Time.Date(addPeriod) import QuantLib.Settings(evaluationDate)@@ -131,7 +173,13 @@ {#pointer *Leg foreign -> CLeg' nocode#} {#pointer *QlSwaption as Swaption foreign -> CSwaption' nocode#} {#pointer *QlSwap as Swap foreign -> CSwap' nocode#}+{#pointer *QlFixedVsFloatingSwap as FixedVsFloatingSwap foreign -> CFixedVsFloatingSwap' nocode#} {#pointer *QlVanillaSwap as VanillaSwap foreign -> CVanillaSwap' nocode#}+{#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#}@@ -141,7 +189,76 @@ {#pointer *QlZeroCouponSwap as ZeroCouponSwap foreign -> CZeroCouponSwap' nocode#} {#pointer *QlEquityTotalReturnSwap as EquityTotalReturnSwap foreign -> CEquityTotalReturnSwap' nocode#} {#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#} +-- 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+-- (not one shared) since the scalar ctor's gearing/spread/cappedRate/flooredRate are plain+-- Double/Maybe Double while the vector ctor's are [Double]. This splice must stay textually+-- before every {#fun#}-generated binding in this file -- see OISRateHelperOpts in+-- QuantLib/TermStructure/Yield.chs for why (c2hs always appends its raw foreign-import stubs at+-- 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).+$(deriveOptionsRecord "FloatFloatSwapOpts" []+  [ ("ffsIntermediateCapitalExchange", [t|Bool|], [|False|])+  , ("ffsFinalCapitalExchange", [t|Bool|], [|False|])+  , ("ffsGearing1", [t|Double|], [|1.0|])+  , ("ffsSpread1", [t|Double|], [|0.0|])+  , ("ffsCappedRate1", [t|Maybe Double|], [|Nothing|])+  , ("ffsFlooredRate1", [t|Maybe Double|], [|Nothing|])+  , ("ffsGearing2", [t|Double|], [|1.0|])+  , ("ffsSpread2", [t|Double|], [|0.0|])+  , ("ffsCappedRate2", [t|Maybe Double|], [|Nothing|])+  , ("ffsFlooredRate2", [t|Maybe Double|], [|Nothing|])+  , ("ffsPaymentConvention1", [t|Maybe BusinessDayConvention|], [|Nothing|])+  , ("ffsPaymentConvention2", [t|Maybe BusinessDayConvention|], [|Nothing|])+  ])+$(deriveOptionsRecord "FloatFloatSwapVaryingOpts" []+  [ ("ffsvIntermediateCapitalExchange", [t|Bool|], [|False|])+  , ("ffsvFinalCapitalExchange", [t|Bool|], [|False|])+  , ("ffsvGearing1", [t|[Double]|], [|[]|])+  , ("ffsvSpread1", [t|[Double]|], [|[]|])+  , ("ffsvCappedRate1", [t|[Double]|], [|[]|])+  , ("ffsvFlooredRate1", [t|[Double]|], [|[]|])+  , ("ffsvGearing2", [t|[Double]|], [|[]|])+  , ("ffsvSpread2", [t|[Double]|], [|[]|])+  , ("ffsvCappedRate2", [t|[Double]|], [|[]|])+  , ("ffsvFlooredRate2", [t|[Double]|], [|[]|])+  , ("ffsvPaymentConvention1", [t|Maybe BusinessDayConvention|], [|Nothing|])+  , ("ffsvPaymentConvention2", [t|Maybe BusinessDayConvention|], [|Nothing|])+  ])++-- ConstNotionalCrossCurrencyBasisSwapOpts bundles ConstNotionalCrossCurrencyBasisSwap's 13+-- trailing defaulted params (per-leg OIS-only payment lag, compound-spread, lookback,+-- observation shift, lockout, averaging method, plus a shared telescopicValueDates), past the+-- options-record threshold -- see FloatFloatSwapOpts above for why this splice must stay+-- textually before every {#fun#} in this file. ConstNotionalCrossCurrencyFixedVsFloatingSwap's+-- constructor has only 6 trailing defaults (under the threshold), so it's widened in place+-- instead -- see 'constNotionalCrossCurrencyFixedVsFloatingSwap' below.+$(deriveOptionsRecord "ConstNotionalCrossCurrencyBasisSwapOpts" []+  [ ("cccbsPayPaymentLag", [t|Int|], [|0|])+  , ("cccbsRecPaymentLag", [t|Int|], [|0|])+  , ("cccbsPayCompoundSpread", [t|Bool|], [|False|])+  , ("cccbsPayLookbackDays", [t|Maybe Word|], [|Nothing|])+  , ("cccbsPayObservationShift", [t|Bool|], [|False|])+  , ("cccbsPayLockoutDays", [t|Word|], [|0|])+  , ("cccbsPayAveragingMethod", [t|RateAveragingType|], [|AveragingCompound|])+  , ("cccbsRecCompoundSpread", [t|Bool|], [|False|])+  , ("cccbsRecLookbackDays", [t|Maybe Word|], [|Nothing|])+  , ("cccbsRecObservationShift", [t|Bool|], [|False|])+  , ("cccbsRecLockoutDays", [t|Word|], [|0|])+  , ("cccbsRecAveragingMethod", [t|RateAveragingType|], [|AveragingCompound|])+  , ("cccbsTelescopicValueDates", [t|Bool|], [|False|])+  ])+ -- |implied volatility {#fun qlSwaptionImpliedVolatility as impliedVolatility{withSwaption*`Swaption',`Double' -- ^price   ,withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^guess@@ -183,6 +300,126 @@   ,fromMaybeBool`Maybe Bool' -- ^useIndexedCoupons   ,preErrorCheck-`String'errorCheck*-}->`VanillaSwap'peekVanillaSwap*#} +-- |Converts an existing 'FixedVsFloatingSwap' (e.g. a 'VanillaSwap') into a 'NonstandardSwap'+-- (upstream's own conversion constructor, @NonstandardSwap(const FixedVsFloatingSwap&)@).+{#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 'nonstandardSwap'' for a per-period gearing\/spread.+{#fun qlNonstandardSwap as nonstandardSwap{`SwapType'+  ,withDoubleArray*`[Double]'& -- ^fixedNominal+  ,withDoubleArray*`[Double]'& -- ^floatingNominal+  ,withSchedule*`Schedule' -- ^fixedSchedule+  ,withDoubleArray*`[Double]'& -- ^fixedRate+  ,withDayCounter*`DayCounter' -- ^fixedDayCount+  ,withSchedule*`Schedule' -- ^floatingSchedule+  ,withIborIndex*`GenIborIndex ibor'+  ,`Double' -- ^gearing+  ,`Double' -- ^spread+  ,withDayCounter*`DayCounter' -- ^floatingDayCount+  ,`Bool' -- ^intermediateCapitalExchange+  ,`Bool' -- ^finalCapitalExchange+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention+  ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwap'peekNonstandardSwap*#}++-- |As 'nonstandardSwap', but with a per-period gearing and spread instead of one shared value.+{#fun qlNonstandardSwap2 as nonstandardSwap'{`SwapType'+  ,withDoubleArray*`[Double]'& -- ^fixedNominal+  ,withDoubleArray*`[Double]'& -- ^floatingNominal+  ,withSchedule*`Schedule' -- ^fixedSchedule+  ,withDoubleArray*`[Double]'& -- ^fixedRate+  ,withDayCounter*`DayCounter' -- ^fixedDayCount+  ,withSchedule*`Schedule' -- ^floatingSchedule+  ,withIborIndex*`GenIborIndex ibor'+  ,withDoubleArray*`[Double]'& -- ^gearing+  ,withDoubleArray*`[Double]'& -- ^spread+  ,withDayCounter*`DayCounter' -- ^floatingDayCount+  ,`Bool' -- ^intermediateCapitalExchange+  ,`Bool' -- ^finalCapitalExchange+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention+  ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwap'peekNonstandardSwap*#}++-- |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\/+-- spread\/cap\/floor per leg, capital exchange, payment conventions); override only what's+-- needed via record-update syntax on 'defaultFloatFloatSwapOpts'. See 'floatFloatSwap'' for the+-- per-period-nominal overload.+floatFloatSwap :: SwapType -> Double -> Double -> Schedule -> GenInterestRateIndex ridx1+  -> DayCounter -> Schedule -> GenInterestRateIndex ridx2 -> DayCounter -> FloatFloatSwapOpts+  -> IO FloatFloatSwap+floatFloatSwap ty nominal1 nominal2 schedule1 index1 dayCount1 schedule2 index2 dayCount2 opts =+  floatFloatSwap_ ty nominal1 nominal2 schedule1 index1 dayCount1 schedule2 index2 dayCount2+    (ffsIntermediateCapitalExchange opts) (ffsFinalCapitalExchange opts)+    (ffsGearing1 opts) (ffsSpread1 opts) (ffsCappedRate1 opts) (ffsFlooredRate1 opts)+    (ffsGearing2 opts) (ffsSpread2 opts) (ffsCappedRate2 opts) (ffsFlooredRate2 opts)+    (ffsPaymentConvention1 opts) (ffsPaymentConvention2 opts)++{#fun qlFloatFloatSwap as floatFloatSwap_{`SwapType'+  ,`Double' -- ^nominal1+  ,`Double' -- ^nominal2+  ,withSchedule*`Schedule' -- ^schedule1+  ,withInterestRateIndex*`GenInterestRateIndex ridx1'+  ,withDayCounter*`DayCounter' -- ^dayCount1+  ,withSchedule*`Schedule' -- ^schedule2+  ,withInterestRateIndex*`GenInterestRateIndex ridx2'+  ,withDayCounter*`DayCounter' -- ^dayCount2+  ,`Bool' -- ^intermediateCapitalExchange+  ,`Bool' -- ^finalCapitalExchange+  ,`Double' -- ^gearing1+  ,`Double' -- ^spread1+  ,fromMaybeDouble`Maybe Double' -- ^cappedRate1+  ,fromMaybeDouble`Maybe Double' -- ^flooredRate1+  ,`Double' -- ^gearing2+  ,`Double' -- ^spread2+  ,fromMaybeDouble`Maybe Double' -- ^cappedRate2+  ,fromMaybeDouble`Maybe Double' -- ^flooredRate2+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention1+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention2+  ,preErrorCheck-`String'errorCheck*-}->`FloatFloatSwap'peekFloatFloatSwap*#}++-- |As 'floatFloatSwap', but with a per-period nominal on each leg instead of a single flat value+-- (full coverage; not used by the upstream example).+floatFloatSwap' :: SwapType -> [Double] -> [Double] -> Schedule -> GenInterestRateIndex ridx1+  -> DayCounter -> Schedule -> GenInterestRateIndex ridx2 -> DayCounter+  -> FloatFloatSwapVaryingOpts -> IO FloatFloatSwap+floatFloatSwap' ty nominal1 nominal2 schedule1 index1 dayCount1 schedule2 index2 dayCount2 opts =+  floatFloatSwap2_ ty nominal1 nominal2 schedule1 index1 dayCount1 schedule2 index2 dayCount2+    (ffsvIntermediateCapitalExchange opts) (ffsvFinalCapitalExchange opts)+    (ffsvGearing1 opts) (ffsvSpread1 opts) (ffsvCappedRate1 opts) (ffsvFlooredRate1 opts)+    (ffsvGearing2 opts) (ffsvSpread2 opts) (ffsvCappedRate2 opts) (ffsvFlooredRate2 opts)+    (ffsvPaymentConvention1 opts) (ffsvPaymentConvention2 opts)++{#fun qlFloatFloatSwap2 as floatFloatSwap2_{`SwapType'+  ,withDoubleArray*`[Double]'& -- ^nominal1+  ,withDoubleArray*`[Double]'& -- ^nominal2+  ,withSchedule*`Schedule' -- ^schedule1+  ,withInterestRateIndex*`GenInterestRateIndex ridx1'+  ,withDayCounter*`DayCounter' -- ^dayCount1+  ,withSchedule*`Schedule' -- ^schedule2+  ,withInterestRateIndex*`GenInterestRateIndex ridx2'+  ,withDayCounter*`DayCounter' -- ^dayCount2+  ,`Bool' -- ^intermediateCapitalExchange+  ,`Bool' -- ^finalCapitalExchange+  ,withDoubleArray*`[Double]'& -- ^gearing1+  ,withDoubleArray*`[Double]'& -- ^spread1+  ,withDoubleArray*`[Double]'& -- ^cappedRate1+  ,withDoubleArray*`[Double]'& -- ^flooredRate1+  ,withDoubleArray*`[Double]'& -- ^gearing2+  ,withDoubleArray*`[Double]'& -- ^spread2+  ,withDoubleArray*`[Double]'& -- ^cappedRate2+  ,withDoubleArray*`[Double]'& -- ^flooredRate2+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention1+  ,fromMaybeEnum`Maybe BusinessDayConvention' -- ^paymentConvention2+  ,preErrorCheck-`String'errorCheck*-}->`FloatFloatSwap'peekFloatFloatSwap*#}++-- |The spread on leg 1 that would make the swap's NPV zero.+{#fun qlFloatFloatSwapFairSpread1 as fairSpread1{withFloatFloatSwap*`FloatFloatSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The spread on leg 2 that would make the swap's NPV zero.+{#fun qlFloatFloatSwapFairSpread2 as fairSpread2{withFloatFloatSwap*`FloatFloatSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+ -- | Haskell equivalent of QuantLib's fluent @MakeVanillaSwap@ builder -- a -- single function with 'Maybe'-wrapped optional parameters instead of -- chained @.with*@ calls, covering the subset of @makevanillaswap.hpp@'s@@ -330,9 +567,162 @@ -- |Discount factor at leg j's start date. {#fun qlSwapStartDiscounts as startDiscounts{withSwap*`GenSwap s',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#} +-- ConstNotionalCrossCurrencySwap+-- |Constructs a cross-currency swap from two legs and their currencies; the first leg is paid, the second received.+{#fun qlConstNotionalCrossCurrencySwap as constNotionalCrossCurrencySwap{withLeg*`GenLeg l1'+  ,withCurrency*`Currency' -- ^firstLegCcy+  ,withLeg*`GenLeg l2'+  ,withCurrency*`Currency' -- ^secondLegCcy+  ,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencySwap'peekConstNotionalCrossCurrencySwap*#}++-- |Multi-leg constructor.+constNotionalCrossCurrencySwap' :: [(Leg, Bool)] -- ^(legs, payer)+  -> [Currency] -> IO ConstNotionalCrossCurrencySwap+constNotionalCrossCurrencySwap' legsPayer = qlConstNotionalCrossCurrencySwap1 legs payer+  where (legs, payer) = unzip legsPayer+{#fun qlConstNotionalCrossCurrencySwap1{withLegArray*`[Leg]'&,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*#}++-- |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'#}++-- |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'#}++-- |Discount factor at the instrument's NPV date, for leg j.+{#fun qlConstNotionalCrossCurrencySwapNpvDateDiscounts as npvDateDiscounts{withConstNotionalCrossCurrencySwap*`GenConstNotionalCrossCurrencySwap x',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- ConstNotionalCrossCurrencyBasisSwap+-- |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,+-- 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+-- 'defaultConstNotionalCrossCurrencyBasisSwapOpts'.+constNotionalCrossCurrencyBasisSwap :: Double -> Currency -> Schedule -> GenIborIndex ibor1 -> Double -> Double+  -> Double -> Currency -> Schedule -> GenIborIndex ibor2 -> Double -> Double+  -> ConstNotionalCrossCurrencyBasisSwapOpts -> IO ConstNotionalCrossCurrencyBasisSwap+constNotionalCrossCurrencyBasisSwap payNominal payCurrency paySchedule payIndex paySpread payGearing+    recNominal recCurrency recSchedule recIndex recSpread recGearing opts =+  constNotionalCrossCurrencyBasisSwap_ payNominal payCurrency paySchedule payIndex paySpread payGearing+    recNominal recCurrency recSchedule recIndex recSpread recGearing+    (cccbsPayPaymentLag opts) (cccbsRecPaymentLag opts)+    (cccbsPayCompoundSpread opts) (cccbsPayLookbackDays opts) (cccbsPayObservationShift opts)+    (cccbsPayLockoutDays opts) (cccbsPayAveragingMethod opts)+    (cccbsRecCompoundSpread opts) (cccbsRecLookbackDays opts) (cccbsRecObservationShift opts)+    (cccbsRecLockoutDays opts) (cccbsRecAveragingMethod opts)+    (cccbsTelescopicValueDates opts)++{#fun qlConstNotionalCrossCurrencyBasisSwap as constNotionalCrossCurrencyBasisSwap_{`Double' -- ^payNominal+  ,withCurrency*`Currency' -- ^payCurrency+  ,withSchedule*`Schedule' -- ^paySchedule+  ,withIborIndex*`GenIborIndex ibor1' -- ^payIndex+  ,`Double' -- ^paySpread+  ,`Double' -- ^payGearing+  ,`Double' -- ^recNominal+  ,withCurrency*`Currency' -- ^recCurrency+  ,withSchedule*`Schedule' -- ^recSchedule+  ,withIborIndex*`GenIborIndex ibor2' -- ^recIndex+  ,`Double' -- ^recSpread+  ,`Double' -- ^recGearing+  ,fromIntegral`Int' -- ^payPaymentLag+  ,fromIntegral`Int' -- ^recPaymentLag+  ,`Bool' -- ^payCompoundSpread+  ,fromMaybeInt`Maybe Word' -- ^payLookbackDays+  ,`Bool' -- ^payObservationShift+  ,fromIntegral`Word' -- ^payLockoutDays+  ,`RateAveragingType' -- ^payAveragingMethod+  ,`Bool' -- ^recCompoundSpread+  ,fromMaybeInt`Maybe Word' -- ^recLookbackDays+  ,`Bool' -- ^recObservationShift+  ,fromIntegral`Word' -- ^recLockoutDays+  ,`RateAveragingType' -- ^recAveragingMethod+  ,`Bool' -- ^telescopicValueDates+  ,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'#}++-- |The receive-leg spread that would make the swap's NPV zero.+{#fun qlConstNotionalCrossCurrencyBasisSwapFairRecSpread as fairRecSpread{withConstNotionalCrossCurrencyBasisSwap*`ConstNotionalCrossCurrencyBasisSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- ConstNotionalCrossCurrencyFixedVsFloatingSwap+-- |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+-- constructor is a required argument here (only 6 trailing defaults, under the options-record+-- threshold -- see 'ConstNotionalCrossCurrencyBasisSwapOpts' above) -- pass @False@\/@False@\/+-- 'Nothing'\/@False@\/@0@\/'AveragingCompound' to reproduce upstream's own defaults; the+-- OIS-only ones are ignored for a plain Ibor 'floatIndex'.+{#fun qlConstNotionalCrossCurrencyFixedVsFloatingSwap as constNotionalCrossCurrencyFixedVsFloatingSwap{`SwapType'+  ,`Double' -- ^fixedNominal+  ,withCurrency*`Currency' -- ^fixedCurrency+  ,withSchedule*`Schedule' -- ^fixedSchedule+  ,`Double' -- ^fixedRate+  ,withDayCounter*`DayCounter' -- ^fixedDayCount+  ,fromEnumC`BusinessDayConvention' -- ^fixedPaymentBdc+  ,fromIntegral`Word' -- ^fixedPaymentLag+  ,withCalendar*`Calendar' -- ^fixedPaymentCalendar+  ,`Double' -- ^floatNominal+  ,withCurrency*`Currency' -- ^floatCurrency+  ,withSchedule*`Schedule' -- ^floatSchedule+  ,withIborIndex*`GenIborIndex ibor' -- ^floatIndex+  ,`Double' -- ^floatSpread+  ,fromEnumC`BusinessDayConvention' -- ^floatPaymentBdc+  ,fromIntegral`Word' -- ^floatPaymentLag+  ,withCalendar*`Calendar' -- ^floatPaymentCalendar+  ,`Bool' -- ^telescopicValueDates+  ,`Bool' -- ^floatCompoundSpread+  ,fromMaybeInt`Maybe Word' -- ^floatLookbackDays+  ,`Bool' -- ^floatObservationShift+  ,fromIntegral`Word' -- ^floatLockoutDays+  ,`RateAveragingType' -- ^floatAveragingMethod+  ,preErrorCheck-`String'errorCheck*-}->`ConstNotionalCrossCurrencyFixedVsFloatingSwap'peekConstNotionalCrossCurrencyFixedVsFloatingSwap*#}++-- |The fixed rate that would make the swap's NPV zero. Named distinctly from 'fairRate' -- that+-- name belongs to the 'HasFixedLeg' class, which this type doesn't implement (upstream gives it+-- no fixedLeg\/fixedLegBPS\/fixedLegNPV getters); 'fairSpread' (via 'HasSpread') is available.+{#fun qlConstNotionalCrossCurrencyFixedVsFloatingSwapFairRate as xccyFairRate{withConstNotionalCrossCurrencyFixedVsFloatingSwap*`ConstNotionalCrossCurrencyFixedVsFloatingSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}++instance HasSpread ConstNotionalCrossCurrencyFixedVsFloatingSwap where+  fairSpread = qlConstNotionalCrossCurrencyFixedVsFloatingSwapFairSpread+{#fun qlConstNotionalCrossCurrencyFixedVsFloatingSwapFairSpread{withConstNotionalCrossCurrencyFixedVsFloatingSwap*`ConstNotionalCrossCurrencyFixedVsFloatingSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+ -- |An option on a 'VanillaSwap'.-{#fun qlSwaption as swaption{withVanillaSwap*`VanillaSwap',withExercise*`Exercise',`SettlementType',`SettlementMethod',preErrorCheck-`String'errorCheck*-}->`Swaption'peekSwaption*#}+{#fun qlSwaption as swaption{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',withExercise*`Exercise',`SettlementType',`SettlementMethod',preErrorCheck-`String'errorCheck*-}->`Swaption'peekSwaption*#} +-- |Converts an existing 'Swaption' into a 'NonstandardSwaption' (upstream's own conversion+-- constructor).+{#fun qlNonstandardSwaption1 as nonstandardSwaptionFromSwaption{withSwaption*`Swaption'+  ,preErrorCheck-`String'errorCheck*-}->`NonstandardSwaption'peekNonstandardSwaption*#}++-- |An option on a 'NonstandardSwap'.+{#fun qlNonstandardSwaption as nonstandardSwaption{withNonstandardSwap*`NonstandardSwap',withExercise*`Exercise',`SettlementType',`SettlementMethod',preErrorCheck-`String'errorCheck*-}->`NonstandardSwaption'peekNonstandardSwaption*#}++-- |Auto-generates a basket of plain 'Swaption's used to calibrate a model to price a+-- 'NonstandardSwaption' -- either ATM swaptions adapted to the exercise dates ('Naive') or+-- swaptions whose maturity\/strike\/nominal match the underlying's NPV, delta and gamma at each+-- exercise date ('MaturityStrikeByDeltaGamma').+{#fun qlNonstandardSwaptionCalibrationBasket as calibrationBasket{withNonstandardSwaption*`NonstandardSwaption'+  ,withSwapIndex*`GenSwapIndex sidx' -- ^standardSwapBase+  ,withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv' -- ^swaptionVolatility+  ,fromEnumC`CalibrationBasketType'+  ,preArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |An option on a 'FloatFloatSwap'.+{#fun qlFloatFloatSwaption as floatFloatSwaption{withFloatFloatSwap*`FloatFloatSwap',withExercise*`Exercise',`SettlementType',`SettlementMethod',preErrorCheck-`String'errorCheck*-}->`FloatFloatSwaption'peekFloatFloatSwaption*#}++-- |As 'calibrationBasket', for a 'FloatFloatSwaption'.+{#fun qlFloatFloatSwaptionCalibrationBasket as floatFloatSwaptionCalibrationBasket{withFloatFloatSwaption*`FloatFloatSwaption'+  ,withSwapIndex*`GenSwapIndex sidx' -- ^standardSwapBase+  ,withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv' -- ^swaptionVolatility+  ,fromEnumC`CalibrationBasketType'+  ,preArray-`[BlackCalibrationHelper]'&peekBlackCalibrationHelperArray*+  ,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- AssetSwap -- |Bullet bond vs Libor swap (par or market asset swap, per /parAssetSwap/). {#fun qlAssetSwap as assetSwap{`Bool' -- ^payBondCoupon@@ -352,7 +742,7 @@   ,withDayCounter*`DayCounter' -- ^fixedDC   ,withOvernightIborIndex*`OvernightIborIndex',`Double' -- ^spread   ,fromIntegral`Int' -- ^paymentLag-  ,`BusinessDayConvention' -- ^paymentAdjustment+  ,fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withCalendar*`Calendar' -- ^paymentCalendar   ,`Bool' -- ^telescopicValueDates   ,`RateAveragingType' -- ^averagingMethod@@ -368,7 +758,7 @@   ,withDayCounter*`DayCounter' -- ^fixedDC   ,withOvernightIborIndex*`OvernightIborIndex',`Double' -- ^spread   ,fromIntegral`Int' -- ^paymentLag-  ,`BusinessDayConvention' -- ^paymentAdjustment+  ,fromEnumC`BusinessDayConvention' -- ^paymentAdjustment   ,withCalendar*`Calendar' -- ^paymentCalendar   ,`Bool' -- ^telescopicValueDates   ,`RateAveragingType' -- ^averagingMethod@@ -451,7 +841,7 @@   ,withDay*`Day' -- ^startDate   ,withDay*`Day' -- ^maturity   ,withCalendar*`Calendar'-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'   ,`Double' -- ^fixedRate   ,withZeroInflationIndex*`ZeroInflationIndex'@@ -459,7 +849,7 @@   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,`Bool' -- ^adjustInfObsDates   ,withCalendar*`Calendar' -- ^infCalendar-  ,`BusinessDayConvention' -- ^infConvention+  ,fromEnumC`BusinessDayConvention' -- ^infConvention   ,preErrorCheck-`String'errorCheck*-}->`ZeroCouponInflationSwap'peekZeroCouponInflationSwap*#}  -- |The fixed rate that would make the swap's NPV zero.@@ -478,7 +868,7 @@   ,`Double' -- ^spread   ,withDayCounter*`DayCounter' -- ^yoyDayCount   ,withCalendar*`Calendar' -- ^paymentCalendar-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,preErrorCheck-`String'errorCheck*-}->`YearOnYearInflationSwap'peekYearOnYearInflationSwap*#}  -- |The fixed rate that would make the swap's NPV zero.@@ -496,14 +886,14 @@   ,`Double' -- ^spread   ,withDayCounter*`DayCounter' -- ^floatDayCount   ,withSchedule*`Schedule' -- ^floatSchedule-  ,`BusinessDayConvention' -- ^floatRoll+  ,fromEnumC`BusinessDayConvention' -- ^floatRoll   ,fromIntegral`Word' -- ^fixingDays   ,withIborIndex*`GenIborIndex ibor' -- ^floatIndex   ,`Double' -- ^fixedRate   ,`Double' -- ^baseCPI   ,withDayCounter*`DayCounter' -- ^fixedDayCount   ,withSchedule*`Schedule' -- ^fixedSchedule-  ,`BusinessDayConvention' -- ^fixedRoll+  ,fromEnumC`BusinessDayConvention' -- ^fixedRoll   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag   ,withZeroInflationIndex*`ZeroInflationIndex' -- ^fixedIndex   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation@@ -522,7 +912,7 @@   ,withDay*`Day' -- ^maturityDate   ,`Double' -- ^fixedPayment   ,withIborIndex*`GenIborIndex ibor',withCalendar*`Calendar' -- ^paymentCalendar-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^paymentDelay   ,preErrorCheck-`String'errorCheck*-}->`ZeroCouponSwap'peekZeroCouponSwap*#} @@ -533,7 +923,7 @@   ,`Double' -- ^fixedRate   ,withDayCounter*`DayCounter' -- ^fixedDayCounter   ,withIborIndex*`GenIborIndex ibor',withCalendar*`Calendar' -- ^paymentCalendar-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^paymentDelay   ,preErrorCheck-`String'errorCheck*-}->`ZeroCouponSwap'peekZeroCouponSwap*#} @@ -553,7 +943,7 @@   ,`Double' -- ^margin   ,`Double' -- ^gearing   ,withCalendar*`Calendar' -- ^paymentCalendar-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^paymentDelay   ,preErrorCheck-`String'errorCheck*-}->`EquityTotalReturnSwap'peekEquityTotalReturnSwap*#} @@ -567,7 +957,7 @@   ,`Double' -- ^margin   ,`Double' -- ^gearing   ,withCalendar*`Calendar' -- ^paymentCalendar-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,fromIntegral`Word' -- ^paymentDelay   ,preErrorCheck-`String'errorCheck*-}->`EquityTotalReturnSwap'peekEquityTotalReturnSwap*#} @@ -590,16 +980,16 @@   fixedLeg = qlOvernightIndexedSwapFixedLeg   fixedLegBPS = qlOvernightIndexedSwapFixedLegBPS   fixedLegNPV = qlOvernightIndexedSwapFixedLegNPV-instance HasFixedLeg VanillaSwap where-  fairRate = qlVanillaSwapFairRate-  fixedLeg = qlVanillaSwapFixedLeg-  fixedLegBPS = qlVanillaSwapFixedLegBPS-  fixedLegNPV = qlVanillaSwapFixedLegNPV+instance HasFixedLeg (GenFixedVsFloatingSwap f) where+  fairRate = qlFixedVsFloatingSwapFairRate+  fixedLeg = qlFixedVsFloatingSwapFixedLeg+  fixedLegBPS = qlFixedVsFloatingSwapFixedLegBPS+  fixedLegNPV = qlFixedVsFloatingSwapFixedLegNPV  class HasSpread a where   fairSpread :: a -> IO Double-instance HasSpread VanillaSwap where-  fairSpread = qlVanillaSwapFairSpread+instance HasSpread (GenFixedVsFloatingSwap f) where+  fairSpread = qlFixedVsFloatingSwapFairSpread instance HasSpread OvernightIndexedSwap where   fairSpread = qlOvernightIndexedSwapFairSpread instance HasSpread AssetSwap where@@ -615,32 +1005,32 @@   floatingLeg :: a -> IO Leg   floatingLegBPS :: a -> IO Double   floatingLegNPV :: a -> IO Double-instance HasFloatingLeg VanillaSwap where-  floatingLeg = qlVanillaSwapFloatingLeg-  floatingLegBPS = qlVanillaSwapFloatingLegBPS-  floatingLegNPV = qlVanillaSwapFloatingLegNPV+instance HasFloatingLeg (GenFixedVsFloatingSwap f) where+  floatingLeg = qlFixedVsFloatingSwapFloatingLeg+  floatingLegBPS = qlFixedVsFloatingSwapFloatingLegBPS+  floatingLegNPV = qlFixedVsFloatingSwapFloatingLegNPV instance HasFloatingLeg AssetSwap where   floatingLeg = qlAssetSwapFloatingLeg   floatingLegBPS = qlAssetSwapFloatingLegBPS   floatingLegNPV = qlAssetSwapFloatingLegNPV  -- |The spread that would make the swap's NPV zero.-{#fun qlVanillaSwapFairSpread{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlFixedVsFloatingSwapFairSpread{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The spread that would make the swap's NPV zero. {#fun qlAssetSwapFairSpread{withAssetSwap*`AssetSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The fixed rate that would make the swap's NPV zero.-{#fun qlVanillaSwapFairRate{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlFixedVsFloatingSwapFairRate{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The fixed leg's cash flows.-{#fun qlVanillaSwapFixedLeg{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}+{#fun qlFixedVsFloatingSwapFixedLeg{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Basis-point sensitivity of the fixed leg.-{#fun qlVanillaSwapFixedLegBPS{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlFixedVsFloatingSwapFixedLegBPS{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |NPV of the fixed leg.-{#fun qlVanillaSwapFixedLegNPV{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#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'#}@@ -661,13 +1051,13 @@ {#fun qlCreditDefaultSwapFairSpread{withGenInstrument*`CreditDefaultSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The floating leg's cash flows.-{#fun qlVanillaSwapFloatingLeg{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}+{#fun qlFixedVsFloatingSwapFloatingLeg{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}  -- |Basis-point sensitivity of the floating leg.-{#fun qlVanillaSwapFloatingLegBPS{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlFixedVsFloatingSwapFloatingLegBPS{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |NPV of the floating leg.-{#fun qlVanillaSwapFloatingLegNPV{withVanillaSwap*`VanillaSwap',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlFixedVsFloatingSwapFloatingLegNPV{withFixedVsFloatingSwap*`GenFixedVsFloatingSwap f',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |The floating leg's cash flows. {#fun qlAssetSwapFloatingLeg{withAssetSwap*`AssetSwap',preErrorCheck-`String'errorCheck*-}->`Leg'peekLeg*#}

@@ -24,11 +24,14 @@   , withNonEmptyDoubleArray   , withDoubleArrayRaw   , withDayPtr+  , withStringArray+  , peekCStringArray   , fromEnumQuantity   , toEnumQuantity   , fromEnumDouble   , toEnumDouble   , fromEnumC+  , toEnumC    , withDay   , toDay@@ -47,10 +50,13 @@   , qlFreeSavedSettings   , fromMaybeDouble   , fromMaybeEnum+  , fromMaybeEnumQuantity   , peekIntArray+  , peekIntArray'   , peekUIntArray   , peekWord   , peekStructArray+  , peekPtrArray   , Matrix(..)   , realMatrix   , objectMatrix@@ -58,15 +64,16 @@   , qlFreeAdditionalResults    , uncurryNested+  , zipWith6   ) where  import Foreign.C.Types(CUInt(..), CInt(..), CDouble(..))-import Foreign.C.String(CString, peekCString)-import Foreign.Ptr(Ptr, nullPtr)+import Foreign.C.String(CString, peekCString, withCString)+import Foreign.Ptr(Ptr, nullPtr, castPtr) import Foreign.ForeignPtr(FinalizerPtr, newForeignPtr) import Foreign.Marshal.Array(peekArray, withArray)-import Foreign.Marshal.Utils(with, toBool, fromBool)+import Foreign.Marshal.Utils(with, toBool, fromBool, withMany) import Foreign.Storable(peek, Storable) import Foreign.Marshal.Alloc(alloca) @@ -108,6 +115,11 @@ fromMaybeEnum :: Enum a => Maybe a -> CInt fromMaybeEnum = maybe (-1) (fromIntegral . fromEnum) +-- |'Nothing' emits the enum's -1 sentinel (same convention as 'fromMaybeEnum'), paired with a+-- placeholder quantity of 0 -- for enums like 'TimeUnit' that start at 0 and can't self-sentinel.+fromMaybeEnumQuantity :: Enum a => Maybe (Word, a) -> (CInt, CInt)+fromMaybeEnumQuantity = maybe (0, -1) fromEnumQuantity+ toMaybeBool :: CInt -> Maybe Bool toMaybeBool x = if x == -1 then Nothing else Just $ toBool x @@ -135,8 +147,9 @@ foreign import ccall safe "ql.h qlFreeUInts" qlFreeUInts :: Ptr CUInt -> IO () foreign import ccall safe "ql.h qlFreeDoubles" qlFreeDoubles :: Ptr CDouble -> IO () foreign import ccall safe "ql.h &qlFreeDoubles" qlFreeDoublesFin :: FinalizerPtr CDouble---foreign import ccall safe "ql.h qlFreePointerArray" qlFreePointerArray :: Ptr (Ptr ()) -> IO ()+foreign import ccall safe "ql.h qlFreePointerArray" qlFreePointerArray :: Ptr (Ptr ()) -> IO () foreign import ccall safe "ql.h qlFreeAdditionalResults" qlFreeAdditionalResults :: CUInt -> Ptr () -> IO ()+foreign import ccall safe "ql.h qlFreeStringArray" qlFreeStringArray :: CUInt -> Ptr CString -> IO () foreign import ccall safe "ql.h qlSavedSettings" qlSavedSettings :: IO (Ptr ()) foreign import ccall safe "ql.h qlFreeSavedSettings" qlFreeSavedSettings :: Ptr () -> IO () @@ -167,6 +180,12 @@ withDayPtr :: [Day] -> (Ptr CInt -> IO a) -> IO a withDayPtr x f = mapM toSerial x >>= (`withArray` f) +-- |An array of plain C strings, for a function taking a @std::vector<std::string>@-shaped+-- argument as a flat @(count, char**)@ pair (the input-side counterpart of 'peekCStringArray'+-- below) -- first needed for @SecondaryCosts@' string keys (@QuantLib.Instrument.Energy@).+withStringArray :: [String] -> ((CUInt, Ptr CString) -> IO b) -> IO b+withStringArray xs f = withMany withCString xs (\ps -> withArray ps (\p -> f (fromIntegral (length xs), p)))+ prePtr :: (Storable a) => (Ptr a -> IO b) -> IO b prePtr = alloca @@ -190,6 +209,18 @@ 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+ peekBoolArray :: Ptr CUInt -> Ptr (Ptr CInt) -> IO [Bool] peekBoolArray = peekIntArray' toBool @@ -223,6 +254,18 @@   results <- mapM convert raws   results <$ freeFn l p +-- |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)+ fromEnumQuantity :: (Enum a, Integral b, Integral c) => (b, a) -> (CInt, c) fromEnumQuantity (x, u) = (fromIntegral x, fromIntegral $ fromEnum u) @@ -303,7 +346,18 @@ fromEnumC :: (Enum a, Integral b) => a -> b fromEnumC = fromIntegral . fromEnum +-- output-direction counterpart to 'fromEnumC', for a {#fun#} returning a bare enum value+-- (not through a pointer out-param, see 'peekEnum' for that case) across the same module-dep boundary+toEnumC :: (Enum a, Integral b) => b -> a+toEnumC = toEnum . fromIntegral+ uncurryNested :: (a -> b -> c -> d) -> (a, (b, c)) -> d uncurryNested f (x, (y, z)) = f x y z++-- |'Prelude' only goes up to 'zipWith3'; this fills the gap for unpacking a C-side+-- structure-of-parallel-arrays result into one Haskell record/tuple per element.+zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]+zipWith6 f (a:as) (b:bs) (c:cs) (d:ds) (e:es) (g:gs) = f a b c d e g : zipWith6 f as bs cs ds es gs+zipWith6 _ _ _ _ _ _ _ = []  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -0,0 +1,972 @@+{-# LANGUAGE TemplateHaskell, StandaloneDeriving, EmptyDataDecls #-}+-- 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+  (+    qlInterpolation+  , qlInterpolation'+  , Approximation(..)+  , Interpolation(..)+  , Interpolation2D(..)++  , ExerciseType(..)+  , Exercise(..)+  , QlExercise+  , EuropeanExercise(..)+  , BermudanExercise(..)+  , QlEuropeanExercise+  , QlBermudanExercise+  , SwingExercise(..)+  , QlSwingExercise++  , OptionType(..)+  , PositionType(..)+  , BondPriceType(..)++  , StrikedPayoff(..)+  , PlainVanillaPayoff(..)+  , PercentageStrikePayoff(..)+  , QlPlainVanillaPayoff+  , QlPercentageStrikePayoff+  , QlStrikedTypePayoff+  , Payoff(..)+  , QlPayoff+  , BasketPayoff(..)+  , QlBasketPayoff+  , TypePayoff(..)+  , QlTypePayoff++  , CallabilityType(..)+  , Callability(..)+  , QlCallability++  , Claim(..)+  , QlClaim+  , withClaim++  , FittingMethod(..)+  , QlFittedBondDiscountCurveFittingMethod+  , withFittedBondDiscountCurveFittingMethod++  , FdmSchemeType(..)+  , FdmScheme(..)+  , QlFdmSchemeDesc+  , withFdmSchemeDesc++  , CPIInterpolationType(..)++  , Constraint(..)+  , QlConstraint+  , withConstraint+  , withMaybeConstraint+  , OptimizationMethod(..)+  , QlOptimizationMethod+  , withOptimizationMethod+  , EndCriteria(..)+  , QlEndCriteria+  , withEndCriteria++  , QlRounding+  , RoundingType(..)+  , Rounding(..)+  , withRounding+  , withMaybeRounding++  , withCallability+  , withCallabilityArray++  , QlLmVolatilityModel+  , LmVolatilityModel(..)+  , QlLmCorrelationModel+  , LmCorrelationModel(..)+  , withLmCorrelationModel+  , withLmVolatilityModel++  , TimeUnit(..)+  , BusinessDayConvention(..)++  , withEuropeanExercise+  , withSwingExercise+  , withBermudanExercise+  , withExercise+  , withPercentageStrikePayoff+  , withPlainVanillaPayoff+  , withStrikedPayoff+  , withTypePayoff+  , withBasketPayoff+  , withPayoff++  , strikedPayoff+  , percentageStrikePayoff+  , plainVanillaPayoff+  , swingExercise++  , CalibrationBasketType(..)++  , UnitOfMeasureType(..)+  , PaymentTermEventType(..)+  , PricingErrorLevel(..)+  , peekPricingErrorLevelArray+  , DeliverySchedule(..)+  , QuantityPeriodicity(..)++  , AdditionalResultType(..)+  , AdditionalResultVal(..)+  , RawResultPtr+  , RawResult(..)+  , convertResult+  , peekAdditionalResults+  ) where+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 QuantLib.Internal+import QuantLib.Internal.Type hiding(ptr)+import QuantLib.Internal.Syntax++#include "qlTypesC2HS.h"+#include "ql.h"++#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++-- this enum is not special, just used in many places and was put here to avoid cyclic dependencies+{#enum TimeUnit{} deriving(Show, Eq, Bounded)#}+-- moved from QuantLib.Time.Calendar, its "natural" home, for the same reason as TimeUnit above --+-- needed directly here for RebatedExercise's rebatePaymentConvention param. Like TimeUnit, every+-- cross-module use marshals through a manual fromEnumC/toEnumC/fromMaybeEnum function rather than+-- a bare c2hs backtick spec: a bare `` `BusinessDayConvention' `` needs the type's own module's+-- .chi already built, which this other-modules-listed module isn't guaranteed to have by the time+-- an early exposed-modules file (e.g. QuantLib.Time.Calendar itself) is processed.+{#enum BusinessDayConvention{} deriving(Show, Eq)#}+{#enum ApproximationType{} add prefix="Approximation__" deriving(Show, Eq)#}+{#enum InterpolationType{} add prefix="Interpolation" deriving(Show, Eq)#}+-- 2-D interpolators for a BlackVarianceSurface. Unlike InterpolationType/ApproximationType+-- above (merged into the public Interpolation ADT by deriveCrossEnum), this enum is itself the+-- public type: setInterpolation on a surface is a member template over a default-constructed+-- interpolator, so there is no approximator to pair it with. Declared here rather than in+-- QuantLib.TermStructure.Volatility for the usual cross-module {#import#} ordering reason.+{#enum Interpolation2D{} deriving (Show, Eq, Bounded)#}+{#enum ExerciseType{} add prefix = "ExerciseType" deriving (Show, Eq)#}+{#enum OptionType{} deriving (Show, Eq)#}+{#enum PositionType{} deriving (Show, Eq)#}+{#enum BondPriceType{} deriving (Show, Eq)#}+{#enum CallabilityType{} add prefix="Callability" deriving(Show, Eq)#}+{#enum FdmSchemeType{} deriving(Show, Eq)#}+{#enum RoundingType{} deriving (Show, Eq)#}+-- experimental/commodities: cross-cutting the same way TimeUnit is (UnitOfMeasureType is used by+-- both UnitOfMeasure itself and, in a later stage, CommodityPricingHelper/EnergyCommodity).+-- Quantity's C tag is renamed QuantityUnit in cbits/qlEnumC2HS.h to avoid colliding with the+-- Quantity class bound in QuantLib.Commodity.+{#enum UnitOfMeasureType{} deriving (Show, Eq, Bounded)#}+{#enum PaymentTermEventType{} deriving (Show, Eq, Bounded)#}+-- experimental/commodities/commodity.hpp (PricingError::Level) and+-- experimental/commodities/energycommodity.hpp (EnergyCommodity::DeliverySchedule,+-- EnergyCommodity::QuantityPeriodicity), homed here for the same cross-cutting reason as+-- UnitOfMeasureType above (used by both EnergyCommodity's leaf constructors and+-- CommodityPricingHelper::createPricingPeriods, both in QuantLib.Instrument.Energy -- a later+-- stage than this module).+{#enum PricingErrorLevel{} deriving (Show, Eq, 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.+{#enum DeliverySchedule{} add prefix = "Delivery" deriving (Show, Eq, Bounded)#}+{#enum QuantityPeriodicity{} deriving (Show, Eq, 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).+{#enum CPIInterpolationType{} deriving (Show, Eq, Bounded)#}+{#enum CalibrationBasketType{} deriving (Show, Eq, Bounded)#}++-- Payoff/Exercise pointer hierarchy: the Finalizable/Upcastable instances and raw phantom+-- tags (CPayoff' etc.) live in QuantLib.Internal.Type alongside every other class hierarchy;+-- these are just c2hs-local aliases so {#fun#} specs below can keep writing the bare `QlX'+-- names, resolving to a raw, unwrapped Ptr (no auto-generated foreign-pointer code) since+-- construction/upcasting is handled by hand in the with* functions further down.+type QlPayoff = Ptr CPayoff'+type QlBasketPayoff = Ptr CBasketPayoff'+type QlTypePayoff = Ptr CTypePayoff'+type QlStrikedTypePayoff = Ptr CStrikedTypePayoff'+type QlPercentageStrikePayoff = Ptr CPercentageStrikePayoff'+type QlPlainVanillaPayoff = Ptr CPlainVanillaPayoff'+type QlExercise = Ptr CExercise'+type QlEuropeanExercise = Ptr CEuropeanExercise'+type QlAmericanExercise = Ptr CAmericanExercise'+type QlSwingExercise = Ptr CSwingExercise'+type QlBermudanExercise = Ptr CBermudanExercise'+type QlRebatedExercise = Ptr CRebatedExercise'+-- identity peek function: c2hs {#fun#} return specs always need a named out-marshaller,+-- even when (as here) construction should just hand back the raw, un-wrapped pointer.+peekPtr :: Ptr a -> IO (Ptr a)+peekPtr = pure+{#pointer *QlPayoff nocode#}+{#pointer *QlBasketPayoff nocode#}+{#pointer *QlTypePayoff nocode#}+{#pointer *QlStrikedTypePayoff nocode#}+{#pointer *QlPercentageStrikePayoff nocode#}+{#pointer *QlPlainVanillaPayoff nocode#}+{#pointer *QlExercise nocode#}+{#pointer *QlEuropeanExercise nocode#}+{#pointer *QlAmericanExercise nocode#}+{#pointer *QlSwingExercise nocode#}+{#pointer *QlBermudanExercise nocode#}+{#pointer *QlRebatedExercise nocode#}+{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *QlCallability foreign -> CQlCallability nocode#}+{#pointer *OptimizationMethod as QlOptimizationMethod foreign -> COptimizationMethod nocode#}+{#pointer *EndCriteria as QlEndCriteria foreign -> CEndCriteria nocode#}+{#pointer *Constraint as QlConstraint foreign -> CConstraint nocode#}+{#pointer *FdmSchemeDesc as QlFdmSchemeDesc foreign -> CFdmSchemeDesc nocode#}+{#pointer *FittedBondDiscountCurveFittingMethod as QlFittedBondDiscountCurveFittingMethod foreign -> CFittedBondDiscountCurveFittingMethod nocode#}+{#pointer *QlClaim as Claim foreign -> CQlClaim nocode#}+{#pointer *QlBond as Bond foreign -> CBond' nocode#}+{#pointer *QlLmCorrelationModel foreign -> CLmCorrelationModel nocode#}+{#pointer *QlLmVolatilityModel foreign -> CLmVolatilityModel nocode#}+{#pointer *Rounding as QlRounding foreign -> CRounding nocode#}++-- 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+-- doesn't for the ApproximationType enum itself: these two type synonyms (and ApproximationExtra+-- below) must be declared textually *above* the deriveCrossEnum splice, since a TH splice can+-- only see top-level declarations that already exist earlier in the same module -- classifySub's+-- lookupTypeName would silently miss them (falling back to NoSub, dropping the Bool field) if+-- they were moved below the splice.+type NaturalSplineMonotonic = Bool+type ParabolicMonotonic = Bool++-- every Approximation case is driven by ApproximationType itself, so unlike+-- CalendarExtra/DayCounterExtra/IborExtra there are no non-enum-driven cases to add here+data ApproximationExtra++$(deriveCrossEnum CrossEnumSpec+    { crossTypeName = "Approximation"+    , crossMapperFn = "qlApproximation"+    , crossMainEnum = ''ApproximationType+    , crossSubSuffix = "Monotonic"+    , crossExtraType = ''ApproximationExtra+    })++deriving instance Show Approximation+deriving instance Eq Approximation++-- Remaining cpp<->hs lockstep, unlike CalendarConstructor/DayCounterConstructor/IborConstructor:+-- those own a full C-side array/table, so *every* lockstep edit needed for a new value stays+-- inside cbits/. Approximation/Interpolation instead get dispatched via symbolic switch-case on+-- the shared enum (cbits/qlTermStructure.cpp's setInterpolation, and ~18 duplicated+-- switch(interpolator){switch(approximator){...}} sites in cbits/qlTermStructureAux.cpp, one per+-- PiecewiseYieldCurve trait/interpolator instantiation). Adding a new ApproximationType/+-- InterpolationType value to cbits/qlEnumObjects.h is zero-touch here on the Haskell side+-- (deriveCrossEnum picks it up automatically, defaulting to a nullary constructor unless a+-- <Value>Monotonic marker is added above), but each cbits switch still needs a matching+-- `case hasquant::NewValue:` by hand -- a missed one isn't a compile error, just a runtime+-- QL_FAIL("Unsupported ..."), exactly the pre-existing gap Abcd fell into (see the comment next+-- to setInterpolation's default case in qlTermStructure.cpp).++qlInterpolation :: Interpolation -> (Int, (Int, Int))+qlInterpolation BackwardFlat = (fromEnum InterpolationBackwardFlat, (0, 0))+qlInterpolation ForwardFlat = (fromEnum InterpolationForwardFlat, (0, 0))+qlInterpolation Linear = (fromEnum InterpolationLinear, (0, 0))+qlInterpolation LogLinear = (fromEnum InterpolationLogLinear, (0, 0))+qlInterpolation (Cubic x) = (fromEnum InterpolationCubic, qlApproximation x)+qlInterpolation (LogCubic x) = (fromEnum InterpolationLogCubic, qlApproximation x)+qlInterpolation Abcd = (fromEnum InterpolationAbcd, (0, 0))++qlInterpolation' :: Maybe Interpolation -> (Int, (Int, Int))+qlInterpolation' Nothing = (fromIntegral qlNullInteger, (0, 0))+qlInterpolation' (Just i) = qlInterpolation i++data Interpolation =+  BackwardFlat+  | ForwardFlat+  | Linear+  | LogLinear+  | Cubic !Approximation+  | LogCubic !Approximation+  | Abcd+  deriving (Show, Eq)++data EuropeanExercise = EuropeanExercise Day+-- | Use 'swingExerice' to construct 'Exercise'+data SwingExercise =+    SwingListExercise ![(Day, Word)] -- ^(dates, seconds)+    | SwingIntervalExercise !Day !Day !Word -- ^stepSizeSecs+data BermudanExercise =+    BermudanExercise ![Day] !Bool+    | Swing SwingExercise++-- | > Exercise+-- >  American+-- >  Early+-- >  Vanilla+-- >  EuropeanExercise+-- >  BermudanExercise+-- >    SwingExercise+-- >  Rebated (wraps another Exercise)+data Exercise =+    American+      !(Maybe Day) -- ^earliestDate+      !Day -- ^latestDate+      !Bool -- ^paoffAtExpiry+    | Early !ExerciseType !Bool+    | Vanilla !ExerciseType+    | European !EuropeanExercise+    | Bermudan !BermudanExercise+    | Rebated+        !Exercise -- ^wrapped exercise+        !Double -- ^rebate+        !Word -- ^rebateSettlementDays+        !Calendar -- ^rebatePaymentCalendar+        !BusinessDayConvention -- ^rebatePaymentConvention++{#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*#}+{#fun qlBermudanExercise{withDayArray*`[Day]'&,`Bool',preErrorCheck-`String'errorCheck*-}->`QlBermudanExercise'peekPtr*#}+{#fun qlEarlyExercise{`ExerciseType',`Bool',preErrorCheck-`String'errorCheck*-}->`QlExercise'peekPtr*#}+{#fun qlEuropeanExercise{withDay*`Day',preErrorCheck-`String'errorCheck*-}->`QlEuropeanExercise'peekPtr*#}+{#fun qlSwingExercise{withDayArray*`[Day]'&,withIntArray*`[Word]'&,preErrorCheck-`String'errorCheck*-}->`QlSwingExercise'peekPtr*#}+{#fun qlSwingExercise1{withDay*`Day',withDay*`Day',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlSwingExercise'peekPtr*#}+{#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++withSwingExercise :: SwingExercise -> (QlSwingExercise -> IO a) -> IO a+withSwingExercise (SwingListExercise ds) f = uncurry qlSwingExercise (unzip ds) >>= newCastForeignPtr >>= flip withGenForeignPtr f+withSwingExercise (SwingIntervalExercise d1 d2 s) f = qlSwingExercise1 d1 d2 s >>= newCastForeignPtr >>= flip withGenForeignPtr f++withBermudanExercise :: BermudanExercise -> (QlBermudanExercise -> IO a) -> IO a+withBermudanExercise (BermudanExercise d p) f = qlBermudanExercise d p >>= newCastForeignPtr >>= flip withGenForeignPtr f+withBermudanExercise (Swing e) f = withSwingExercise e (\sp -> upcast sp >>= \bp -> f bp `finally` freeUpcast bp)++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)++-- | use 'percentageStrikePayoff' to construct 'Payoff'+data PercentageStrikePayoff = PercentageStrikePayoff+      !OptionType -- ^type+      !Double -- ^moneyness++-- | use 'plainVanillaPayoff' to construct 'Payoff'+data PlainVanillaPayoff = PlainVanillaPayoff+      !OptionType -- ^type+      !Double -- ^strike++-- | use 'strikedPayoff' to construct 'Payoff'+data StrikedPayoff =+  AssetOrNothing+    !OptionType -- ^type+    !Double -- ^strike+  | CashOrNothing+      !OptionType -- ^type+      !Double -- ^strike+      !Double -- ^cashPayoff+  | Gap+      !OptionType -- ^type+      !Double -- ^strike+      !Double -- ^secondStrike+  | PercentageStrike !PercentageStrikePayoff+  | PlainVanilla !PlainVanillaPayoff+  | SuperFund+      !Double -- ^strike+      !Double -- ^secondStrike+  | SuperSharePayoff+      !Double -- ^strike+      !Double -- ^secondStrike+      !Double -- ^cashPayoff++withPercentageStrikePayoff :: PercentageStrikePayoff -> (QlPercentageStrikePayoff -> IO a) -> IO a+withPercentageStrikePayoff (PercentageStrikePayoff t m) f = qlPercentageStrikePayoff t m >>= newCastForeignPtr >>= flip withGenForeignPtr f++withPlainVanillaPayoff :: PlainVanillaPayoff -> (QlPlainVanillaPayoff -> IO a) -> IO a+withPlainVanillaPayoff (PlainVanillaPayoff t s) f = qlPlainVanillaPayoff t s >>= newCastForeignPtr >>= flip withGenForeignPtr 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++data TypePayoff = Striked !StrikedPayoff+  | Floating !OptionType -- ^type+data BasketPayoff =+    Average+      !Payoff -- ^p+      !Word -- ^n+  | AverageMultiple+      !Payoff -- ^p+      ![Double] -- ^a+  | Max+      !Payoff -- ^p+  | Min+      !Payoff -- ^p+  | Spread+      !Payoff -- ^p++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)++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)++-- | > Payoff+-- >  DoubleStickyRatchet+-- >  ForwardType+-- >  RatchettMax+-- >  RatchetMin+-- >  StickyMax+-- >  StickyMin+-- >  Sticky+-- >  TypePayoff+-- >    Floating+-- >    Striked+-- >      AssetOrNothing+-- >      CashOrNothing+-- >      Gap+-- >      PercentageStrike+-- >      PlainVanilla+-- >      SuperFund+-- >      SuperSharePayoff+-- >  BasketPayoff+-- >    Average+-- >    AverageMultiple+-- >    Max+-- >    Min+-- >    Spread+data Payoff =+    DoubleStickyRatchet+      !Double -- ^type1+      !Double -- ^type2+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^gearing3+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^spread3+      !Double -- ^initialValue1+      !Double -- ^initialValue2+      !Double -- ^accrualFactor+  | ForwardType+      !PositionType -- ^type+      !Double -- ^strike+  | RatchetMax+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^gearing3+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^spread3+      !Double -- ^initialValue1+      !Double -- ^initialValue2+      !Double -- ^accrualFactor+  | RatchetMin+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^gearing3+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^spread3+      !Double -- ^initialValue1+      !Double -- ^initialValue2+      !Double -- ^accrualFactor+  | Ratchet+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^initialValue+      !Double -- ^accrualFactor+  | StickyMax+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^gearing3+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^spread3+      !Double -- ^initialValue1+      !Double -- ^initialValue2+      !Double -- ^accrualFactor+  | StickyMin+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^gearing3+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^spread3+      !Double -- ^initialValue1+      !Double -- ^initialValue2+      !Double -- ^accrualFactor+  | Sticky+      !Double -- ^gearing1+      !Double -- ^gearing2+      !Double -- ^spread1+      !Double -- ^spread2+      !Double -- ^initialValue+      !Double -- ^accrualFactor+  | Type !TypePayoff+  | Basket !BasketPayoff+++{#fun qlAssetOrNothingPayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}+{#fun qlAverageBasketPayoff{`QlPayoff',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}+{#fun qlCashOrNothingPayoff{`OptionType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}+{#fun qlDoubleStickyRatchetPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlFloatingTypePayoff{`OptionType',preErrorCheck-`String'errorCheck*-}->`QlTypePayoff'peekPtr*#}+{#fun qlForwardTypePayoff{`PositionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlGapPayoff{`OptionType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}+{#fun qlMaxBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}+{#fun qlMinBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}+{#fun qlPercentageStrikePayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPercentageStrikePayoff'peekPtr*#}+{#fun qlPlainVanillaPayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPlainVanillaPayoff'peekPtr*#}+{#fun qlRatchetMaxPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlRatchetMinPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlRatchetPayoff{`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlSpreadBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}+{#fun qlStickyMaxPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlStickyMinPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#fun qlStickyPayoff{`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}+{#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*#}++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)++data Callability =+  Soft+    !(Double, BondPriceType)+    !Day+    !Double -- ^trigger+  | Callability+      !(Double, BondPriceType)+      !CallabilityType+      !Day++callability :: Callability -> IO (Standalone CQlCallability)+callability (Soft (p, t) d tg) = qlSoftCallability p t d tg+callability (Callability (p, t) ct d) = qlCallability p t ct d++newtype EnumMeta a b = EnumMeta (a -> IO (Standalone b))++withEnumType :: EnumMeta a b -> a -> (Ptr b -> IO c) -> IO c+withEnumType (EnumMeta t) x f = t x >>= (`withStandalone` f)++withMaybeEnumType :: EnumMeta a b -> Maybe a -> (Ptr b -> IO c) -> IO c+withMaybeEnumType (EnumMeta t) x f = maybe (f nullPtr) (\xx -> t xx >>= (`withStandalone` f)) x++withEnumTypeArray :: EnumMeta a b -> [a] -> ((CUInt, Ptr (Ptr b)) -> IO c) -> IO c+withEnumTypeArray m x f = withMany (withEnumType m) x (`withArray` (\px -> f (fromIntegral $ length x, px)))++callabilityMeta :: EnumMeta Callability CQlCallability+callabilityMeta = EnumMeta callability++withCallability :: Callability -> (Ptr CQlCallability -> IO a) -> IO a+withCallability = withEnumType callabilityMeta++withCallabilityArray :: [Callability] -> ((CUInt, Ptr (Ptr CQlCallability)) -> IO c) -> IO c+withCallabilityArray = withEnumTypeArray callabilityMeta++constraintMeta :: EnumMeta Constraint CConstraint+constraintMeta = EnumMeta constraint++roundingMeta :: EnumMeta Rounding CRounding+roundingMeta = EnumMeta rounding++withMaybeConstraint :: Maybe Constraint -> (Ptr CConstraint -> IO a) -> IO a+withMaybeConstraint = withMaybeEnumType constraintMeta++withMaybeRounding :: Maybe Rounding -> (Ptr CRounding -> IO a) -> IO a+withMaybeRounding = withMaybeEnumType roundingMeta++withConstraint :: Constraint -> (Ptr CConstraint -> IO a) -> IO a+withConstraint = withEnumType constraintMeta++withRounding :: Rounding -> (Ptr CRounding -> IO a) -> IO a+withRounding = withEnumType roundingMeta++fittedBondDiscountFittingMethodMeta :: EnumMeta FittingMethod CFittedBondDiscountCurveFittingMethod+fittedBondDiscountFittingMethodMeta = EnumMeta fittingMethod++withFittedBondDiscountCurveFittingMethod :: FittingMethod -> (Ptr CFittedBondDiscountCurveFittingMethod -> IO a) -> IO a+withFittedBondDiscountCurveFittingMethod = withEnumType fittedBondDiscountFittingMethodMeta++endCriteriaMeta :: EnumMeta EndCriteria CEndCriteria+endCriteriaMeta = EnumMeta endCriteria++withEndCriteria :: EndCriteria -> (Ptr CEndCriteria -> IO a) -> IO a+withEndCriteria = withEnumType endCriteriaMeta++fdmSchemeDescMeta :: EnumMeta FdmScheme CFdmSchemeDesc+fdmSchemeDescMeta = EnumMeta fdmScheme++withFdmSchemeDesc :: FdmScheme -> (Ptr CFdmSchemeDesc -> IO a) -> IO a+withFdmSchemeDesc = withEnumType fdmSchemeDescMeta++optimizationMethodMeta :: EnumMeta OptimizationMethod COptimizationMethod+optimizationMethodMeta = EnumMeta optimizationMethod++withOptimizationMethod :: OptimizationMethod -> (Ptr COptimizationMethod -> IO a) -> IO a+withOptimizationMethod = withEnumType optimizationMethodMeta++-- Payoff/Exercise with* functions are now defined directly, near their ADTs, using+-- Upcastable/GenForeignPtr (see QuantLib.Internal.Type) instead of EnumMeta'/IsQlPayoff/IsQlExercise.++-- |callability leaving to the holder the possibility to convert+{#fun qlSoftCallability{`Double',`BondPriceType',withDay*`Day',`Double',preErrorCheck-`String'errorCheck*-}->`QlCallability'peekCallability*#}+{#fun qlCallability{`Double',`BondPriceType',`CallabilityType',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`QlCallability'peekCallability*#}++-- Every constructor below binds the QuantLib overload that omits the leading+-- optimizationMethod param (see the qlTermStructure.cpp comment above the+-- qlXxxFitting shims for why: OptimizationMethod's hasquant-side handle is a+-- raw, Haskell-finalized pointer, not a QlXxx shared_ptr box, and+-- FittedBondDiscountCurve additionally clones its fitting method -- passing+-- one through safely needs a real ownership-representation change).+data FittingMethod =+  CubicBSplines+    ![Double] -- ^knotVector (year fraction)+    !Bool -- ^constrainAtZero+    ![Double] -- ^weights+    ![Double] -- ^l2+    !Double -- ^minCutoffTime+    !Double -- ^maxCutoffTime+    !(Maybe Constraint)+  | ExponentialSplines+    !Bool -- ^constrainAtZero+    ![Double] -- ^weights+    ![Double] -- ^l2+    !Double -- ^minCutoffTime+    !Double -- ^maxCutoffTime+    !Word -- ^numCoeffs+    !(Maybe Double) -- ^fixedKappa+    !(Maybe Constraint)+  | NelsonSiegel+    ![Double] -- ^weights+    ![Double] -- ^l2+    !Double -- ^minCutoffTime+    !Double -- ^maxCutoffTime+    !(Maybe Constraint)+  | SimplePolynomial+    !Word -- ^degree+    !Bool -- ^constrainAtZero+    ![Double] -- ^weights+    ![Double] -- ^l2+    !Double -- ^minCutoffTime+    !Double -- ^maxCutoffTime+    !(Maybe Constraint)+  | Svensson+    ![Double] -- ^weights+    ![Double] -- ^l2+    !Double -- ^minCutoffTime+    !Double -- ^maxCutoffTime+    !(Maybe Constraint)++fittingMethod :: FittingMethod -> IO QlFittedBondDiscountCurveFittingMethod+fittingMethod (CubicBSplines k c w l2 mn mx cn) = qlCubicBSplinesFitting k c w l2 mn mx cn+fittingMethod (ExponentialSplines c w l2 mn mx n fk cn) = qlExponentialSplinesFitting c w l2 mn mx n fk cn+fittingMethod (NelsonSiegel w l2 mn mx cn) = qlNelsonSiegelFitting w l2 mn mx cn+fittingMethod (SimplePolynomial d c w l2 mn mx cn) = qlSimplePolynomialFitting d c w l2 mn mx cn+fittingMethod (Svensson w l2 mn mx cn) = qlSvenssonFitting w l2 mn mx cn++{#fun qlCubicBSplinesFitting{withDoubleArray*`[Double]'&,`Bool'+  ,withDoubleArray*`[Double]'& -- ^weights+  ,withDoubleArray*`[Double]'& -- ^l2+  ,`Double' -- ^minCutoffTime+  ,`Double' -- ^maxCutoffTime+  ,withMaybeConstraint*`Maybe Constraint'+  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}+{#fun qlExponentialSplinesFitting{`Bool'+  ,withDoubleArray*`[Double]'& -- ^weights+  ,withDoubleArray*`[Double]'& -- ^l2+  ,`Double' -- ^minCutoffTime+  ,`Double' -- ^maxCutoffTime+  ,fromIntegral`Word' -- ^numCoeffs+  ,fromMaybeDouble`Maybe Double' -- ^fixedKappa+  ,withMaybeConstraint*`Maybe Constraint'+  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}+{#fun qlNelsonSiegelFitting{withDoubleArray*`[Double]'& -- ^weights+  ,withDoubleArray*`[Double]'& -- ^l2+  ,`Double' -- ^minCutoffTime+  ,`Double' -- ^maxCutoffTime+  ,withMaybeConstraint*`Maybe Constraint'+  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}+{#fun qlSimplePolynomialFitting{fromIntegral`Word',`Bool'+  ,withDoubleArray*`[Double]'& -- ^weights+  ,withDoubleArray*`[Double]'& -- ^l2+  ,`Double' -- ^minCutoffTime+  ,`Double' -- ^maxCutoffTime+  ,withMaybeConstraint*`Maybe Constraint'+  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}+{#fun qlSvenssonFitting{withDoubleArray*`[Double]'& -- ^weights+  ,withDoubleArray*`[Double]'& -- ^l2+  ,`Double' -- ^minCutoffTime+  ,`Double' -- ^maxCutoffTime+  ,withMaybeConstraint*`Maybe Constraint'+  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}++data FdmScheme =+  FdmScheme+    !FdmSchemeType -- ^type+    !Double -- ^theta+    !Double -- ^mu+  | CraigSneyd+  | Douglas+  | ExplicitEuler+  | Hundsdorfer+  | ImplicitEuler+  | ModifiedCraigSneyd+  | ModifiedHundsdorfer++{#fun qlFdmSchemeDesc{`FdmSchemeType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescCraigSneyd{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescDouglas{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescExplicitEuler{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescHundsdorfer{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescImplicitEuler{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescModifiedCraigSneyd{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}+{#fun qlFdmSchemeDescModifiedHundsdorfer{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}++fdmScheme :: FdmScheme -> IO QlFdmSchemeDesc+fdmScheme (FdmScheme t th mu) = qlFdmSchemeDesc t th mu+fdmScheme CraigSneyd = qlFdmSchemeDescCraigSneyd+fdmScheme Douglas = qlFdmSchemeDescDouglas+fdmScheme ExplicitEuler = qlFdmSchemeDescExplicitEuler+fdmScheme Hundsdorfer = qlFdmSchemeDescHundsdorfer+fdmScheme ImplicitEuler = qlFdmSchemeDescImplicitEuler+fdmScheme ModifiedCraigSneyd = qlFdmSchemeDescModifiedCraigSneyd+fdmScheme ModifiedHundsdorfer = qlFdmSchemeDescModifiedHundsdorfer++data Constraint =+  Boundary+    !Double -- ^low+    !Double -- ^high+  | Composite+    !Constraint -- ^c1+    !Constraint -- ^c2+  | NoConstraint+  | PositiveConstraint++constraint :: Constraint -> IO QlConstraint+constraint (Boundary l h) = qlBoundaryConstraint l h+constraint (Composite c1 c2) = qlCompositeConstraint c1 c2+constraint NoConstraint = qlNoConstraint+constraint PositiveConstraint = qlPositiveConstraint++{#fun qlBoundaryConstraint{`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}+{#fun qlCompositeConstraint{withConstraint*`Constraint',withConstraint*`Constraint',preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}+{#fun qlNoConstraint{preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}+{#fun qlPositiveConstraint{preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}++data OptimizationMethod =+  LevenbergMarquardt+    !Double -- ^epsfcn+    !Double -- ^xtol+    !Double -- ^gtol+    !Bool -- ^useCostFunctionsJacobian+  | Simplex !Double -- ^lambda, characteristic length++optimizationMethod :: OptimizationMethod -> IO QlOptimizationMethod+optimizationMethod (LevenbergMarquardt e x g j) = qlLevenbergMarquardt e x g j+optimizationMethod (Simplex l) = qlSimplex l+{#fun qlLevenbergMarquardt{`Double',`Double',`Double',`Bool',preErrorCheck-`String'errorCheck*-}->`QlOptimizationMethod'peekOptimizationMethod*#}+{#fun qlSimplex{`Double',preErrorCheck-`String'errorCheck*-}->`QlOptimizationMethod'peekOptimizationMethod*#}++data EndCriteria =+  EndCriteria+    !Word -- ^maxIterations+    !Word -- ^maxStationaryStateIterations+    !Double -- ^rootEpsilon+    !Double -- ^functionEpsilon+    !Double -- ^gradientNormEpsilon++endCriteria :: EndCriteria -> IO QlEndCriteria+endCriteria (EndCriteria m1 m2 e f g) = qlEndCriteria m1 m2 e f g+{#fun qlEndCriteria{fromIntegral`Word',fromIntegral`Word',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlEndCriteria'peekEndCriteria*#}++data Rounding = NoRounding+  | Rounding+    !Int -- ^precision+    !RoundingType+    !Int -- ^digit+  deriving (Show, Eq)++rounding :: Rounding -> IO QlRounding+rounding NoRounding = qlRounding+rounding (Rounding p t d) = qlRounding1 p t d++{#fun qlRounding{preErrorCheck-`String'errorCheck*-}->`QlRounding'peekRounding*#}+{#fun qlRounding1{`Int',`RoundingType',`Int',preErrorCheck-`String'errorCheck*-}->`QlRounding'peekRounding*#}++data LmCorrelationModel = ConstWrapperCorrelation LmCorrelationModel+  | ExponentialCorrelation Word -- ^size+    !Double -- ^rho+  | LinearExponentialCorrelation Word -- ^size+    !Double -- ^rho+    !Double -- ^beta+    !Word -- ^factors+  deriving (Show, Eq)++{#fun qlLmConstWrapperCorrelationModel{withStandalone*`QlLmCorrelationModel',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}+{#fun qlLmExponentialCorrelationModel{fromIntegral`Word',`Double',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}+{#fun qlLmLinearExponentialCorrelationModel{fromIntegral`Word',`Double',`Double',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}++correlationModel :: LmCorrelationModel -> IO QlLmCorrelationModel+correlationModel (ConstWrapperCorrelation m) = correlationModel m >>= qlLmConstWrapperCorrelationModel+correlationModel (ExponentialCorrelation s r) = qlLmExponentialCorrelationModel s r+correlationModel (LinearExponentialCorrelation s r b f) = qlLmLinearExponentialCorrelationModel s r b f++correlationModelMeta :: EnumMeta LmCorrelationModel CLmCorrelationModel+correlationModelMeta = EnumMeta correlationModel++withLmCorrelationModel :: LmCorrelationModel -> (Ptr CLmCorrelationModel -> IO a) -> IO a+withLmCorrelationModel = withEnumType correlationModelMeta++data LmVolatilityModel = ConstWrapperVolatility LmVolatilityModel+  | FixedVolatility ![Double] ![Double]+  | LinearExponentialVolatility ![Double] -- ^fixing times+    !Double -- ^a+    !Double -- ^b+    !Double -- ^c+    !Double -- ^d+  deriving (Show, Eq)++{#fun qlLmConstWrapperVolatilityModel{withStandalone*`QlLmVolatilityModel',preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}+{#fun qlLmFixedVolatilityModel{withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}+{#fun qlLmLinearExponentialVolatilityModel{withDoubleArray*`[Double]'&,`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}++volatilityModel :: LmVolatilityModel -> IO QlLmVolatilityModel+volatilityModel (ConstWrapperVolatility m) = volatilityModel m >>= qlLmConstWrapperVolatilityModel+volatilityModel (FixedVolatility d1 d2) = qlLmFixedVolatilityModel d1 d2+volatilityModel (LinearExponentialVolatility s a b c d) = qlLmLinearExponentialVolatilityModel s a b c d++volatilityModelMeta :: EnumMeta LmVolatilityModel CLmVolatilityModel+volatilityModelMeta = EnumMeta volatilityModel++withLmVolatilityModel :: LmVolatilityModel -> (Ptr CLmVolatilityModel -> IO a) -> IO a+withLmVolatilityModel = withEnumType volatilityModelMeta++data Claim = FaceValue | FaceValueAccrual Bond+claimMeta :: EnumMeta Claim CQlClaim+claimMeta = EnumMeta claim++withClaim :: Claim -> (Ptr CQlClaim -> IO a) -> IO a+withClaim = withEnumType claimMeta++claim :: Claim -> IO QlClaim+claim FaceValue = qlFaceValueClaim+claim (FaceValueAccrual b) = qlFaceValueAccrualClaim b++-- |Claim on a notional+{#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*#}++strikedPayoff :: StrikedPayoff -> Payoff+strikedPayoff = Type . Striked++percentageStrikePayoff :: PercentageStrikePayoff -> Payoff+percentageStrikePayoff = Type . Striked . PercentageStrike++plainVanillaPayoff :: PlainVanillaPayoff -> Payoff+plainVanillaPayoff = Type . Striked . PlainVanilla++swingExercise :: SwingExercise -> Exercise+swingExercise = Bermudan . Swing++-- |One value from QuantLib's `Instrument::additionalResults()` map. QuantLib stores the map as+-- `ext::any`, so this Haskell view picks three concrete shapes -- `Real` (`Double`), `std::string`+-- (`String`), `std::vector<Real>` (`[Double]`) -- plus an `UnsupportedVal` fallback recording the+-- value's C++ RTTI type name, so no key is ever silently dropped or mislabelled.+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) #}++-- |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+-- `Storable` instance (`sizeOf`/`alignment` from `{#sizeof#}`/`{#alignof#}`, both read straight+-- from the C struct layout, not hand-computed) is what lets `peekStructArray`+-- (`QuantLib.Internal`) walk the C array via a plain `peekArray`, rather than hand-rolled pointer+-- arithmetic.+data RawResult = RawResult+  { rKey :: CString, rType :: CInt, rDval :: CDouble+  , rSval :: CString, rVarr :: Ptr CDouble, rVlen :: CUInt }++instance Storable RawResult where+  sizeOf _ = {#sizeof QlAdditionalResult #}+  alignment _ = {#alignof QlAdditionalResult #}+  peek p = RawResult <$> {#get QlAdditionalResult.key #} p+                      <*> {#get QlAdditionalResult.type #} p+                      <*> {#get QlAdditionalResult.dval #} p+                      <*> {#get QlAdditionalResult.sval #} p+                      <*> {#get QlAdditionalResult.varr #} p+                      <*> {#get QlAdditionalResult.vlen #} p+  poke = error "RawResult is peek-only (read from C, never constructed in Haskell)"++-- |Convert one raw entry into its keyed Haskell value. `sval`/`varr` are only read for the+-- discriminant that owns them; their buffers are released in bulk afterwards, by+-- `qlFreeAdditionalResults`, not per-field here.+convertResult :: RawResult -> IO (String, AdditionalResultVal)+convertResult r = do+  key <- peekCString (rKey r)+  val <- case toEnum (fromIntegral (rType r)) of+    AdditionalResultDouble -> return (RealVal (realToFrac (rDval r)))+    AdditionalResultString -> StringVal <$> peekCString (rSval r)+    AdditionalResultDoubleVector -> RealVectorVal . map realToFrac+                                       <$> peekArray (fromIntegral (rVlen r)) (rVarr r)+    AdditionalResultUnknown -> UnsupportedVal <$> peekCString (rSval r)+  return (key, val)++-- |Peek the C array of `QlAdditionalResult` into a keyed list, then release the whole array (keys,+-- `sval`/`varr` buffers, and the array itself) in one `qlFreeAdditionalResults` call.+peekAdditionalResults :: Ptr CUInt -> Ptr RawResultPtr -> IO [(String, AdditionalResultVal)]+peekAdditionalResults = peekStructArray convertResult (\l p -> qlFreeAdditionalResults l (castPtr p))++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -1,853 +0,0 @@-{-# LANGUAGE TemplateHaskell, StandaloneDeriving, EmptyDataDecls #-}--- 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.Enum-  (-    qlInterpolation-  , qlInterpolation'-  , Approximation(..)-  , Interpolation(..)-  , Interpolation2D(..)--  , ExerciseType(..)-  , Exercise(..)-  , QlExercise-  , EuropeanExercise(..)-  , BermudanExercise(..)-  , QlEuropeanExercise-  , QlBermudanExercise-  , SwingExercise(..)-  , QlSwingExercise--  , OptionType(..)-  , PositionType(..)-  , BondPriceType(..)--  , StrikedPayoff(..)-  , PlainVanillaPayoff(..)-  , PercentageStrikePayoff(..)-  , QlPlainVanillaPayoff-  , QlPercentageStrikePayoff-  , QlStrikedTypePayoff-  , Payoff(..)-  , QlPayoff-  , BasketPayoff(..)-  , QlBasketPayoff-  , TypePayoff(..)-  , QlTypePayoff--  , CallabilityType(..)-  , Callability(..)-  , QlCallability--  , Claim(..)-  , QlClaim-  , withClaim--  , FittingMethod(..)-  , QlFittedBondDiscountCurveFittingMethod-  , withFittedBondDiscountCurveFittingMethod--  , FdmSchemeType(..)-  , FdmScheme(..)-  , QlFdmSchemeDesc-  , withFdmSchemeDesc--  , CPIInterpolationType(..)--  , Constraint(..)-  , QlConstraint-  , withConstraint-  , withMaybeConstraint-  , OptimizationMethod(..)-  , QlOptimizationMethod-  , withOptimizationMethod-  , EndCriteria(..)-  , QlEndCriteria-  , withEndCriteria--  , QlRounding-  , RoundingType(..)-  , Rounding(..)-  , withRounding-  , withMaybeRounding--  , withCallability-  , withCallabilityArray--  , QlLmVolatilityModel-  , LmVolatilityModel(..)-  , QlLmCorrelationModel-  , LmCorrelationModel(..)-  , withLmCorrelationModel-  , withLmVolatilityModel--  , TimeUnit(..)--  , withEuropeanExercise-  , withSwingExercise-  , withBermudanExercise-  , withExercise-  , withPercentageStrikePayoff-  , withPlainVanillaPayoff-  , withStrikedPayoff-  , withTypePayoff-  , withBasketPayoff-  , withPayoff--  , strikedPayoff-  , percentageStrikePayoff-  , plainVanillaPayoff-  , swingExercise-  ) where-import Foreign.Ptr(Ptr, nullPtr)-import Foreign.C.Types(CUInt)-import Foreign.Marshal.Utils(withMany)-import Foreign.Marshal.Array(withArray)-import Control.Exception(finally)--import QuantLib.Internal-import QuantLib.Internal.Type-import QuantLib.Internal.Syntax--#include "qlTypesC2HS.h"-#include "ql.h"--#include "qlEnumC2HS.h"-#include "qlEnumObjects.h"---- this enum is not special, just used in many places and was put here to avoid cyclic dependencies-{#enum TimeUnit{} deriving(Show, Eq, Bounded)#}-{#enum ApproximationType{} add prefix="Approximation__" deriving(Show, Eq)#}-{#enum InterpolationType{} add prefix="Interpolation" deriving(Show, Eq)#}--- 2-D interpolators for a BlackVarianceSurface. Unlike InterpolationType/ApproximationType--- above (merged into the public Interpolation ADT by deriveCrossEnum), this enum is itself the--- public type: setInterpolation on a surface is a member template over a default-constructed--- interpolator, so there is no approximator to pair it with. Declared here rather than in--- QuantLib.TermStructure.Volatility for the usual cross-module {#import#} ordering reason.-{#enum Interpolation2D{} deriving (Show, Eq, Bounded)#}-{#enum ExerciseType{} add prefix = "ExerciseType" deriving (Show, Eq)#}-{#enum OptionType{} deriving (Show, Eq)#}-{#enum PositionType{} deriving (Show, Eq)#}-{#enum BondPriceType{} deriving (Show, Eq)#}-{#enum CallabilityType{} add prefix="Callability" deriving(Show, Eq)#}-{#enum FdmSchemeType{} deriving(Show, Eq)#}-{#enum RoundingType{} deriving (Show, Eq)#}--- 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).-{#enum CPIInterpolationType{} deriving (Show, Eq, Bounded)#}---- Payoff/Exercise pointer hierarchy: the Finalizable/Upcastable instances and raw phantom--- tags (CPayoff' etc.) live in QuantLib.Internal.Type alongside every other class hierarchy;--- these are just c2hs-local aliases so {#fun#} specs below can keep writing the bare `QlX'--- names, resolving to a raw, unwrapped Ptr (no auto-generated foreign-pointer code) since--- construction/upcasting is handled by hand in the with* functions further down.-type QlPayoff = Ptr CPayoff'-type QlBasketPayoff = Ptr CBasketPayoff'-type QlTypePayoff = Ptr CTypePayoff'-type QlStrikedTypePayoff = Ptr CStrikedTypePayoff'-type QlPercentageStrikePayoff = Ptr CPercentageStrikePayoff'-type QlPlainVanillaPayoff = Ptr CPlainVanillaPayoff'-type QlExercise = Ptr CExercise'-type QlEuropeanExercise = Ptr CEuropeanExercise'-type QlAmericanExercise = Ptr CAmericanExercise'-type QlSwingExercise = Ptr CSwingExercise'-type QlBermudanExercise = Ptr CBermudanExercise'--- identity peek function: c2hs {#fun#} return specs always need a named out-marshaller,--- even when (as here) construction should just hand back the raw, un-wrapped pointer.-peekPtr :: Ptr a -> IO (Ptr a)-peekPtr = pure-{#pointer *QlPayoff nocode#}-{#pointer *QlBasketPayoff nocode#}-{#pointer *QlTypePayoff nocode#}-{#pointer *QlStrikedTypePayoff nocode#}-{#pointer *QlPercentageStrikePayoff nocode#}-{#pointer *QlPlainVanillaPayoff nocode#}-{#pointer *QlExercise nocode#}-{#pointer *QlEuropeanExercise nocode#}-{#pointer *QlAmericanExercise nocode#}-{#pointer *QlSwingExercise nocode#}-{#pointer *QlBermudanExercise nocode#}-{#pointer *QlCallability foreign -> CQlCallability nocode#}-{#pointer *OptimizationMethod as QlOptimizationMethod foreign -> COptimizationMethod nocode#}-{#pointer *EndCriteria as QlEndCriteria foreign -> CEndCriteria nocode#}-{#pointer *Constraint as QlConstraint foreign -> CConstraint nocode#}-{#pointer *FdmSchemeDesc as QlFdmSchemeDesc foreign -> CFdmSchemeDesc nocode#}-{#pointer *FittedBondDiscountCurveFittingMethod as QlFittedBondDiscountCurveFittingMethod foreign -> CFittedBondDiscountCurveFittingMethod nocode#}-{#pointer *QlClaim as Claim foreign -> CQlClaim nocode#}-{#pointer *QlBond as Bond foreign -> CBond' nocode#}-{#pointer *QlLmCorrelationModel foreign -> CLmCorrelationModel nocode#}-{#pointer *QlLmVolatilityModel foreign -> CLmVolatilityModel nocode#}-{#pointer *Rounding as QlRounding foreign -> CRounding nocode#}---- 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--- doesn't for the ApproximationType enum itself: these two type synonyms (and ApproximationExtra--- below) must be declared textually *above* the deriveCrossEnum splice, since a TH splice can--- only see top-level declarations that already exist earlier in the same module -- classifySub's--- lookupTypeName would silently miss them (falling back to NoSub, dropping the Bool field) if--- they were moved below the splice.-type NaturalSplineMonotonic = Bool-type ParabolicMonotonic = Bool---- every Approximation case is driven by ApproximationType itself, so unlike--- CalendarExtra/DayCounterExtra/IborExtra there are no non-enum-driven cases to add here-data ApproximationExtra--$(deriveCrossEnum CrossEnumSpec-    { crossTypeName = "Approximation"-    , crossMapperFn = "qlApproximation"-    , crossMainEnum = ''ApproximationType-    , crossSubSuffix = "Monotonic"-    , crossExtraType = ''ApproximationExtra-    })--deriving instance Show Approximation-deriving instance Eq Approximation---- Remaining cpp<->hs lockstep, unlike CalendarConstructor/DayCounterConstructor/IborConstructor:--- those own a full C-side array/table, so *every* lockstep edit needed for a new value stays--- inside cbits/. Approximation/Interpolation instead get dispatched via symbolic switch-case on--- the shared enum (cbits/qlTermStructure.cpp's setInterpolation, and ~18 duplicated--- switch(interpolator){switch(approximator){...}} sites in cbits/qlTermStructureAux.cpp, one per--- PiecewiseYieldCurve trait/interpolator instantiation). Adding a new ApproximationType/--- InterpolationType value to cbits/qlEnumObjects.h is zero-touch here on the Haskell side--- (deriveCrossEnum picks it up automatically, defaulting to a nullary constructor unless a--- <Value>Monotonic marker is added above), but each cbits switch still needs a matching--- `case hasquant::NewValue:` by hand -- a missed one isn't a compile error, just a runtime--- QL_FAIL("Unsupported ..."), exactly the pre-existing gap Abcd fell into (see the comment next--- to setInterpolation's default case in qlTermStructure.cpp).--qlInterpolation :: Interpolation -> (Int, (Int, Int))-qlInterpolation BackwardFlat = (fromEnum InterpolationBackwardFlat, (0, 0))-qlInterpolation ForwardFlat = (fromEnum InterpolationForwardFlat, (0, 0))-qlInterpolation Linear = (fromEnum InterpolationLinear, (0, 0))-qlInterpolation LogLinear = (fromEnum InterpolationLogLinear, (0, 0))-qlInterpolation (Cubic x) = (fromEnum InterpolationCubic, qlApproximation x)-qlInterpolation (LogCubic x) = (fromEnum InterpolationLogCubic, qlApproximation x)-qlInterpolation Abcd = (fromEnum InterpolationAbcd, (0, 0))--qlInterpolation' :: Maybe Interpolation -> (Int, (Int, Int))-qlInterpolation' Nothing = (fromIntegral qlNullInteger, (0, 0))-qlInterpolation' (Just i) = qlInterpolation i--data Interpolation =-  BackwardFlat-  | ForwardFlat-  | Linear-  | LogLinear-  | Cubic !Approximation-  | LogCubic !Approximation-  | Abcd-  deriving (Show, Eq)--data EuropeanExercise = EuropeanExercise Day--- | Use 'swingExerice' to construct 'Exercise'-data SwingExercise =-    SwingListExercise ![(Day, Word)] -- ^(dates, seconds)-    | SwingIntervalExercise !Day !Day !Word -- ^stepSizeSecs-data BermudanExercise =-    BermudanExercise ![Day] !Bool-    | Swing SwingExercise---- | > Exercise--- >  American--- >  Early--- >  Vanilla--- >  EuropeanExercise--- >  BermudanExercise--- >    SwingExercise-data Exercise =-    American-      !(Maybe Day) -- ^earliestDate-      !Day -- ^latestDate-      !Bool -- ^paoffAtExpiry-    | Early !ExerciseType !Bool-    | Vanilla !ExerciseType-    | European !EuropeanExercise-    | Bermudan !BermudanExercise--{#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*#}-{#fun qlBermudanExercise{withDayArray*`[Day]'&,`Bool',preErrorCheck-`String'errorCheck*-}->`QlBermudanExercise'peekPtr*#}-{#fun qlEarlyExercise{`ExerciseType',`Bool',preErrorCheck-`String'errorCheck*-}->`QlExercise'peekPtr*#}-{#fun qlEuropeanExercise{withDay*`Day',preErrorCheck-`String'errorCheck*-}->`QlEuropeanExercise'peekPtr*#}-{#fun qlSwingExercise{withDayArray*`[Day]'&,withIntArray*`[Word]'&,preErrorCheck-`String'errorCheck*-}->`QlSwingExercise'peekPtr*#}-{#fun qlSwingExercise1{withDay*`Day',withDay*`Day',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlSwingExercise'peekPtr*#}--withEuropeanExercise :: EuropeanExercise -> (QlEuropeanExercise -> IO a) -> IO a-withEuropeanExercise (EuropeanExercise d) f = qlEuropeanExercise d >>= newCastForeignPtr >>= flip withGenForeignPtr f--withSwingExercise :: SwingExercise -> (QlSwingExercise -> IO a) -> IO a-withSwingExercise (SwingListExercise ds) f = uncurry qlSwingExercise (unzip ds) >>= newCastForeignPtr >>= flip withGenForeignPtr f-withSwingExercise (SwingIntervalExercise d1 d2 s) f = qlSwingExercise1 d1 d2 s >>= newCastForeignPtr >>= flip withGenForeignPtr f--withBermudanExercise :: BermudanExercise -> (QlBermudanExercise -> IO a) -> IO a-withBermudanExercise (BermudanExercise d p) f = qlBermudanExercise d p >>= newCastForeignPtr >>= flip withGenForeignPtr f-withBermudanExercise (Swing e) f = withSwingExercise e (\sp -> upcast sp >>= \bp -> f bp `finally` freeUpcast bp)--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)---- | use 'percentageStrikePayoff' to construct 'Payoff'-data PercentageStrikePayoff = PercentageStrikePayoff-      !OptionType -- ^type-      !Double -- ^moneyness---- | use 'plainVanillaPayoff' to construct 'Payoff'-data PlainVanillaPayoff = PlainVanillaPayoff-      !OptionType -- ^type-      !Double -- ^strike---- | use 'strikedPayoff' to construct 'Payoff'-data StrikedPayoff =-  AssetOrNothing-    !OptionType -- ^type-    !Double -- ^strike-  | CashOrNothing-      !OptionType -- ^type-      !Double -- ^strike-      !Double -- ^cashPayoff-  | Gap-      !OptionType -- ^type-      !Double -- ^strike-      !Double -- ^secondStrike-  | PercentageStrike !PercentageStrikePayoff-  | PlainVanilla !PlainVanillaPayoff-  | SuperFund-      !Double -- ^strike-      !Double -- ^secondStrike-  | SuperSharePayoff-      !Double -- ^strike-      !Double -- ^secondStrike-      !Double -- ^cashPayoff--withPercentageStrikePayoff :: PercentageStrikePayoff -> (QlPercentageStrikePayoff -> IO a) -> IO a-withPercentageStrikePayoff (PercentageStrikePayoff t m) f = qlPercentageStrikePayoff t m >>= newCastForeignPtr >>= flip withGenForeignPtr f--withPlainVanillaPayoff :: PlainVanillaPayoff -> (QlPlainVanillaPayoff -> IO a) -> IO a-withPlainVanillaPayoff (PlainVanillaPayoff t s) f = qlPlainVanillaPayoff t s >>= newCastForeignPtr >>= flip withGenForeignPtr 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--data TypePayoff = Striked !StrikedPayoff-  | Floating !OptionType -- ^type-data BasketPayoff =-    Average-      !Payoff -- ^p-      !Word -- ^n-  | AverageMultiple-      !Payoff -- ^p-      ![Double] -- ^a-  | Max-      !Payoff -- ^p-  | Min-      !Payoff -- ^p-  | Spread-      !Payoff -- ^p--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)--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)---- | > Payoff--- >  DoubleStickyRatchet--- >  ForwardType--- >  RatchettMax--- >  RatchetMin--- >  StickyMax--- >  StickyMin--- >  Sticky--- >  TypePayoff--- >    Floating--- >    Striked--- >      AssetOrNothing--- >      CashOrNothing--- >      Gap--- >      PercentageStrike--- >      PlainVanilla--- >      SuperFund--- >      SuperSharePayoff--- >  BasketPayoff--- >    Average--- >    AverageMultiple--- >    Max--- >    Min--- >    Spread-data Payoff =-    DoubleStickyRatchet-      !Double -- ^type1-      !Double -- ^type2-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^gearing3-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^spread3-      !Double -- ^initialValue1-      !Double -- ^initialValue2-      !Double -- ^accrualFactor-  | ForwardType-      !PositionType -- ^type-      !Double -- ^strike-  | RatchetMax-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^gearing3-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^spread3-      !Double -- ^initialValue1-      !Double -- ^initialValue2-      !Double -- ^accrualFactor-  | RatchetMin-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^gearing3-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^spread3-      !Double -- ^initialValue1-      !Double -- ^initialValue2-      !Double -- ^accrualFactor-  | Ratchet-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^initialValue-      !Double -- ^accrualFactor-  | StickyMax-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^gearing3-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^spread3-      !Double -- ^initialValue1-      !Double -- ^initialValue2-      !Double -- ^accrualFactor-  | StickyMin-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^gearing3-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^spread3-      !Double -- ^initialValue1-      !Double -- ^initialValue2-      !Double -- ^accrualFactor-  | Sticky-      !Double -- ^gearing1-      !Double -- ^gearing2-      !Double -- ^spread1-      !Double -- ^spread2-      !Double -- ^initialValue-      !Double -- ^accrualFactor-  | Type !TypePayoff-  | Basket !BasketPayoff---{#fun qlAssetOrNothingPayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}-{#fun qlAverageBasketPayoff{`QlPayoff',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlCashOrNothingPayoff{`OptionType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}-{#fun qlDoubleStickyRatchetPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlFloatingTypePayoff{`OptionType',preErrorCheck-`String'errorCheck*-}->`QlTypePayoff'peekPtr*#}-{#fun qlForwardTypePayoff{`PositionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlGapPayoff{`OptionType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlStrikedTypePayoff'peekPtr*#}-{#fun qlMaxBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlMinBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlPercentageStrikePayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPercentageStrikePayoff'peekPtr*#}-{#fun qlPlainVanillaPayoff{`OptionType',`Double',preErrorCheck-`String'errorCheck*-}->`QlPlainVanillaPayoff'peekPtr*#}-{#fun qlRatchetMaxPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlRatchetMinPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlRatchetPayoff{`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlSpreadBasketPayoff{`QlPayoff',preErrorCheck-`String'errorCheck*-}->`QlBasketPayoff'peekPtr*#}-{#fun qlStickyMaxPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlStickyMinPayoff{`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#fun qlStickyPayoff{`Double',`Double',`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlPayoff'peekPtr*#}-{#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*#}--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)--data Callability =-  Soft-    !(Double, BondPriceType)-    !Day-    !Double -- ^trigger-  | Callability-      !(Double, BondPriceType)-      !CallabilityType-      !Day--callability :: Callability -> IO (Standalone CQlCallability)-callability (Soft (p, t) d tg) = qlSoftCallability p t d tg-callability (Callability (p, t) ct d) = qlCallability p t ct d--newtype EnumMeta a b = EnumMeta (a -> IO (Standalone b))--withEnumType :: EnumMeta a b -> a -> (Ptr b -> IO c) -> IO c-withEnumType (EnumMeta t) x f = t x >>= (`withStandalone` f)--withMaybeEnumType :: EnumMeta a b -> Maybe a -> (Ptr b -> IO c) -> IO c-withMaybeEnumType (EnumMeta t) x f = maybe (f nullPtr) (\xx -> t xx >>= (`withStandalone` f)) x--withEnumTypeArray :: EnumMeta a b -> [a] -> ((CUInt, Ptr (Ptr b)) -> IO c) -> IO c-withEnumTypeArray m x f = withMany (withEnumType m) x (`withArray` (\px -> f (fromIntegral $ length x, px)))--callabilityMeta :: EnumMeta Callability CQlCallability-callabilityMeta = EnumMeta callability--withCallability :: Callability -> (Ptr CQlCallability -> IO a) -> IO a-withCallability = withEnumType callabilityMeta--withCallabilityArray :: [Callability] -> ((CUInt, Ptr (Ptr CQlCallability)) -> IO c) -> IO c-withCallabilityArray = withEnumTypeArray callabilityMeta--constraintMeta :: EnumMeta Constraint CConstraint-constraintMeta = EnumMeta constraint--roundingMeta :: EnumMeta Rounding CRounding-roundingMeta = EnumMeta rounding--withMaybeConstraint :: Maybe Constraint -> (Ptr CConstraint -> IO a) -> IO a-withMaybeConstraint = withMaybeEnumType constraintMeta--withMaybeRounding :: Maybe Rounding -> (Ptr CRounding -> IO a) -> IO a-withMaybeRounding = withMaybeEnumType roundingMeta--withConstraint :: Constraint -> (Ptr CConstraint -> IO a) -> IO a-withConstraint = withEnumType constraintMeta--withRounding :: Rounding -> (Ptr CRounding -> IO a) -> IO a-withRounding = withEnumType roundingMeta--fittedBondDiscountFittingMethodMeta :: EnumMeta FittingMethod CFittedBondDiscountCurveFittingMethod-fittedBondDiscountFittingMethodMeta = EnumMeta fittingMethod--withFittedBondDiscountCurveFittingMethod :: FittingMethod -> (Ptr CFittedBondDiscountCurveFittingMethod -> IO a) -> IO a-withFittedBondDiscountCurveFittingMethod = withEnumType fittedBondDiscountFittingMethodMeta--endCriteriaMeta :: EnumMeta EndCriteria CEndCriteria-endCriteriaMeta = EnumMeta endCriteria--withEndCriteria :: EndCriteria -> (Ptr CEndCriteria -> IO a) -> IO a-withEndCriteria = withEnumType endCriteriaMeta--fdmSchemeDescMeta :: EnumMeta FdmScheme CFdmSchemeDesc-fdmSchemeDescMeta = EnumMeta fdmScheme--withFdmSchemeDesc :: FdmScheme -> (Ptr CFdmSchemeDesc -> IO a) -> IO a-withFdmSchemeDesc = withEnumType fdmSchemeDescMeta--optimizationMethodMeta :: EnumMeta OptimizationMethod COptimizationMethod-optimizationMethodMeta = EnumMeta optimizationMethod--withOptimizationMethod :: OptimizationMethod -> (Ptr COptimizationMethod -> IO a) -> IO a-withOptimizationMethod = withEnumType optimizationMethodMeta---- Payoff/Exercise with* functions are now defined directly, near their ADTs, using--- Upcastable/GenForeignPtr (see QuantLib.Internal.Type) instead of EnumMeta'/IsQlPayoff/IsQlExercise.---- |callability leaving to the holder the possibility to convert-{#fun qlSoftCallability{`Double',`BondPriceType',withDay*`Day',`Double',preErrorCheck-`String'errorCheck*-}->`QlCallability'peekCallability*#}-{#fun qlCallability{`Double',`BondPriceType',`CallabilityType',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`QlCallability'peekCallability*#}---- Every constructor below binds the QuantLib overload that omits the leading--- optimizationMethod param (see the qlTermStructure.cpp comment above the--- qlXxxFitting shims for why: OptimizationMethod's hasquant-side handle is a--- raw, Haskell-finalized pointer, not a QlXxx shared_ptr box, and--- FittedBondDiscountCurve additionally clones its fitting method -- passing--- one through safely needs a real ownership-representation change).-data FittingMethod =-  CubicBSplines-    ![Double] -- ^knotVector (year fraction)-    !Bool -- ^constrainAtZero-    ![Double] -- ^weights-    ![Double] -- ^l2-    !Double -- ^minCutoffTime-    !Double -- ^maxCutoffTime-    !(Maybe Constraint)-  | ExponentialSplines-    !Bool -- ^constrainAtZero-    ![Double] -- ^weights-    ![Double] -- ^l2-    !Double -- ^minCutoffTime-    !Double -- ^maxCutoffTime-    !Word -- ^numCoeffs-    !(Maybe Double) -- ^fixedKappa-    !(Maybe Constraint)-  | NelsonSiegel-    ![Double] -- ^weights-    ![Double] -- ^l2-    !Double -- ^minCutoffTime-    !Double -- ^maxCutoffTime-    !(Maybe Constraint)-  | SimplePolynomial-    !Word -- ^degree-    !Bool -- ^constrainAtZero-    ![Double] -- ^weights-    ![Double] -- ^l2-    !Double -- ^minCutoffTime-    !Double -- ^maxCutoffTime-    !(Maybe Constraint)-  | Svensson-    ![Double] -- ^weights-    ![Double] -- ^l2-    !Double -- ^minCutoffTime-    !Double -- ^maxCutoffTime-    !(Maybe Constraint)--fittingMethod :: FittingMethod -> IO QlFittedBondDiscountCurveFittingMethod-fittingMethod (CubicBSplines k c w l2 mn mx cn) = qlCubicBSplinesFitting k c w l2 mn mx cn-fittingMethod (ExponentialSplines c w l2 mn mx n fk cn) = qlExponentialSplinesFitting c w l2 mn mx n fk cn-fittingMethod (NelsonSiegel w l2 mn mx cn) = qlNelsonSiegelFitting w l2 mn mx cn-fittingMethod (SimplePolynomial d c w l2 mn mx cn) = qlSimplePolynomialFitting d c w l2 mn mx cn-fittingMethod (Svensson w l2 mn mx cn) = qlSvenssonFitting w l2 mn mx cn--{#fun qlCubicBSplinesFitting{withDoubleArray*`[Double]'&,`Bool'-  ,withDoubleArray*`[Double]'& -- ^weights-  ,withDoubleArray*`[Double]'& -- ^l2-  ,`Double' -- ^minCutoffTime-  ,`Double' -- ^maxCutoffTime-  ,withMaybeConstraint*`Maybe Constraint'-  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}-{#fun qlExponentialSplinesFitting{`Bool'-  ,withDoubleArray*`[Double]'& -- ^weights-  ,withDoubleArray*`[Double]'& -- ^l2-  ,`Double' -- ^minCutoffTime-  ,`Double' -- ^maxCutoffTime-  ,fromIntegral`Word' -- ^numCoeffs-  ,fromMaybeDouble`Maybe Double' -- ^fixedKappa-  ,withMaybeConstraint*`Maybe Constraint'-  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}-{#fun qlNelsonSiegelFitting{withDoubleArray*`[Double]'& -- ^weights-  ,withDoubleArray*`[Double]'& -- ^l2-  ,`Double' -- ^minCutoffTime-  ,`Double' -- ^maxCutoffTime-  ,withMaybeConstraint*`Maybe Constraint'-  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}-{#fun qlSimplePolynomialFitting{fromIntegral`Word',`Bool'-  ,withDoubleArray*`[Double]'& -- ^weights-  ,withDoubleArray*`[Double]'& -- ^l2-  ,`Double' -- ^minCutoffTime-  ,`Double' -- ^maxCutoffTime-  ,withMaybeConstraint*`Maybe Constraint'-  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}-{#fun qlSvenssonFitting{withDoubleArray*`[Double]'& -- ^weights-  ,withDoubleArray*`[Double]'& -- ^l2-  ,`Double' -- ^minCutoffTime-  ,`Double' -- ^maxCutoffTime-  ,withMaybeConstraint*`Maybe Constraint'-  ,preErrorCheck-`String'errorCheck*-}->`QlFittedBondDiscountCurveFittingMethod'peekFittedBondDiscountCurveFittingMethod*#}--data FdmScheme =-  FdmScheme-    !FdmSchemeType -- ^type-    !Double -- ^theta-    !Double -- ^mu-  | CraigSneyd-  | Douglas-  | ExplicitEuler-  | Hundsdorfer-  | ImplicitEuler-  | ModifiedCraigSneyd-  | ModifiedHundsdorfer--{#fun qlFdmSchemeDesc{`FdmSchemeType',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescCraigSneyd{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescDouglas{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescExplicitEuler{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescHundsdorfer{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescImplicitEuler{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescModifiedCraigSneyd{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}-{#fun qlFdmSchemeDescModifiedHundsdorfer{preErrorCheck-`String'errorCheck*-}->`QlFdmSchemeDesc'peekFdmSchemeDesc*#}--fdmScheme :: FdmScheme -> IO QlFdmSchemeDesc-fdmScheme (FdmScheme t th mu) = qlFdmSchemeDesc t th mu-fdmScheme CraigSneyd = qlFdmSchemeDescCraigSneyd-fdmScheme Douglas = qlFdmSchemeDescDouglas-fdmScheme ExplicitEuler = qlFdmSchemeDescExplicitEuler-fdmScheme Hundsdorfer = qlFdmSchemeDescHundsdorfer-fdmScheme ImplicitEuler = qlFdmSchemeDescImplicitEuler-fdmScheme ModifiedCraigSneyd = qlFdmSchemeDescModifiedCraigSneyd-fdmScheme ModifiedHundsdorfer = qlFdmSchemeDescModifiedHundsdorfer--data Constraint =-  Boundary-    !Double -- ^low-    !Double -- ^high-  | Composite-    !Constraint -- ^c1-    !Constraint -- ^c2-  | NoConstraint-  | PositiveConstraint--constraint :: Constraint -> IO QlConstraint-constraint (Boundary l h) = qlBoundaryConstraint l h-constraint (Composite c1 c2) = qlCompositeConstraint c1 c2-constraint NoConstraint = qlNoConstraint-constraint PositiveConstraint = qlPositiveConstraint--{#fun qlBoundaryConstraint{`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}-{#fun qlCompositeConstraint{withConstraint*`Constraint',withConstraint*`Constraint',preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}-{#fun qlNoConstraint{preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}-{#fun qlPositiveConstraint{preErrorCheck-`String'errorCheck*-}->`QlConstraint'peekConstraint*#}--data OptimizationMethod =-  LevenbergMarquardt-    !Double -- ^epsfcn-    !Double -- ^xtol-    !Double -- ^gtol-    !Bool -- ^useCostFunctionsJacobian-  | Simplex !Double -- ^lambda, characteristic length--optimizationMethod :: OptimizationMethod -> IO QlOptimizationMethod-optimizationMethod (LevenbergMarquardt e x g j) = qlLevenbergMarquardt e x g j-optimizationMethod (Simplex l) = qlSimplex l-{#fun qlLevenbergMarquardt{`Double',`Double',`Double',`Bool',preErrorCheck-`String'errorCheck*-}->`QlOptimizationMethod'peekOptimizationMethod*#}-{#fun qlSimplex{`Double',preErrorCheck-`String'errorCheck*-}->`QlOptimizationMethod'peekOptimizationMethod*#}--data EndCriteria =-  EndCriteria-    !Word -- ^maxIterations-    !Word -- ^maxStationaryStateIterations-    !Double -- ^rootEpsilon-    !Double -- ^functionEpsilon-    !Double -- ^gradientNormEpsilon--endCriteria :: EndCriteria -> IO QlEndCriteria-endCriteria (EndCriteria m1 m2 e f g) = qlEndCriteria m1 m2 e f g-{#fun qlEndCriteria{fromIntegral`Word',fromIntegral`Word',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlEndCriteria'peekEndCriteria*#}--data Rounding = NoRounding-  | Rounding-    !Int -- ^precision-    !RoundingType-    !Int -- ^digit-  deriving (Show, Eq)--rounding :: Rounding -> IO QlRounding-rounding NoRounding = qlRounding-rounding (Rounding p t d) = qlRounding1 p t d--{#fun qlRounding{preErrorCheck-`String'errorCheck*-}->`QlRounding'peekRounding*#}-{#fun qlRounding1{`Int',`RoundingType',`Int',preErrorCheck-`String'errorCheck*-}->`QlRounding'peekRounding*#}--data LmCorrelationModel = ConstWrapperCorrelation LmCorrelationModel-  | ExponentialCorrelation Word -- ^size-    !Double -- ^rho-  | LinearExponentialCorrelation Word -- ^size-    !Double -- ^rho-    !Double -- ^beta-    !Word -- ^factors-  deriving (Show, Eq)--{#fun qlLmConstWrapperCorrelationModel{withStandalone*`QlLmCorrelationModel',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}-{#fun qlLmExponentialCorrelationModel{fromIntegral`Word',`Double',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}-{#fun qlLmLinearExponentialCorrelationModel{fromIntegral`Word',`Double',`Double',fromIntegral`Word',preErrorCheck-`String'errorCheck*-}->`QlLmCorrelationModel'peekLmCorrelationModel*#}--correlationModel :: LmCorrelationModel -> IO QlLmCorrelationModel-correlationModel (ConstWrapperCorrelation m) = correlationModel m >>= qlLmConstWrapperCorrelationModel-correlationModel (ExponentialCorrelation s r) = qlLmExponentialCorrelationModel s r-correlationModel (LinearExponentialCorrelation s r b f) = qlLmLinearExponentialCorrelationModel s r b f--correlationModelMeta :: EnumMeta LmCorrelationModel CLmCorrelationModel-correlationModelMeta = EnumMeta correlationModel--withLmCorrelationModel :: LmCorrelationModel -> (Ptr CLmCorrelationModel -> IO a) -> IO a-withLmCorrelationModel = withEnumType correlationModelMeta--data LmVolatilityModel = ConstWrapperVolatility LmVolatilityModel-  | FixedVolatility ![Double] ![Double]-  | LinearExponentialVolatility ![Double] -- ^fixing times-    !Double -- ^a-    !Double -- ^b-    !Double -- ^c-    !Double -- ^d-  deriving (Show, Eq)--{#fun qlLmConstWrapperVolatilityModel{withStandalone*`QlLmVolatilityModel',preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}-{#fun qlLmFixedVolatilityModel{withDoubleArray*`[Double]'&,withDoubleArray*`[Double]'&,preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}-{#fun qlLmLinearExponentialVolatilityModel{withDoubleArray*`[Double]'&,`Double',`Double',`Double',`Double',preErrorCheck-`String'errorCheck*-}->`QlLmVolatilityModel'peekLmVolatilityModel*#}--volatilityModel :: LmVolatilityModel -> IO QlLmVolatilityModel-volatilityModel (ConstWrapperVolatility m) = volatilityModel m >>= qlLmConstWrapperVolatilityModel-volatilityModel (FixedVolatility d1 d2) = qlLmFixedVolatilityModel d1 d2-volatilityModel (LinearExponentialVolatility s a b c d) = qlLmLinearExponentialVolatilityModel s a b c d--volatilityModelMeta :: EnumMeta LmVolatilityModel CLmVolatilityModel-volatilityModelMeta = EnumMeta volatilityModel--withLmVolatilityModel :: LmVolatilityModel -> (Ptr CLmVolatilityModel -> IO a) -> IO a-withLmVolatilityModel = withEnumType volatilityModelMeta--data Claim = FaceValue | FaceValueAccrual Bond-claimMeta :: EnumMeta Claim CQlClaim-claimMeta = EnumMeta claim--withClaim :: Claim -> (Ptr CQlClaim -> IO a) -> IO a-withClaim = withEnumType claimMeta--claim :: Claim -> IO QlClaim-claim FaceValue = qlFaceValueClaim-claim (FaceValueAccrual b) = qlFaceValueAccrualClaim b---- |Claim on a notional-{#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*#}--strikedPayoff :: StrikedPayoff -> Payoff-strikedPayoff = Type . Striked--percentageStrikePayoff :: PercentageStrikePayoff -> Payoff-percentageStrikePayoff = Type . Striked . PercentageStrike--plainVanillaPayoff :: PlainVanillaPayoff -> Payoff-plainVanillaPayoff = Type . Striked . PlainVanilla--swingExercise :: SwingExercise -> Exercise-swingExercise = Bermudan . Swing---- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -11,8 +11,8 @@ import Control.Monad((>=>)) import System.IO.Unsafe(unsafePerformIO) -import QuantLib.Internal(peekDynString, preArray, peekDayArray)-import Control.Exception (finally, bracket, mask)+import QuantLib.Internal(peekDynString, preArray, peekDayArray, peekPtrArray)+import Control.Exception (finally, mask)  (<.>) :: Functor f => (b -> r) -> (a -> f b) -> a -> f r f1 <.> f2 = fmap f1 . f2@@ -90,6 +90,80 @@ instance Show Currency where show x = showStandalone qlCurrencyName (getCCurrency x) instance Eq Currency where x == y = show x == show y +data CCommodityType+newtype CommodityType = CommodityType {getCCommodityType :: Standalone CCommodityType}+foreign import ccall unsafe "ql.h &qlFreeCommodityType" qlFreeCommodityType :: FinalizerPtr CCommodityType+instance Finalizable CCommodityType where finalize = qlFreeCommodityType+peekCommodityType :: Ptr CCommodityType -> IO CommodityType+peekCommodityType = CommodityType <.> peekStandalone+withCommodityType :: CommodityType -> (Ptr CCommodityType -> IO b) -> IO b+withCommodityType = withStandalone . getCCommodityType+withMaybeCommodityType :: Maybe CommodityType -> (Ptr CCommodityType -> IO b) -> IO b+withMaybeCommodityType = withMaybeStandalone . (getCCommodityType <$>)+peekMaybeCommodityType :: Ptr CCommodityType -> IO (Maybe CommodityType)+peekMaybeCommodityType p+  | p == nullPtr = pure Nothing+  | otherwise = Just <$> peekCommodityType p+foreign import ccall safe "ql.h qlCommodityTypeCode" qlCommodityTypeCode :: Ptr CCommodityType -> IO CString+instance Show CommodityType where show x = showStandalone qlCommodityTypeCode (getCCommodityType x)+instance Eq CommodityType where x == y = show x == show y+-- |Peek a 'CommodityType' out of a @CommodityType**@ out-parameter (as opposed to+-- 'peekCommodityType', which peeks it directly out of a @CommodityType*@ primary return).+peekCommodityTypePtr :: Ptr (Ptr CCommodityType) -> IO CommodityType+peekCommodityTypePtr = peek >=> peekCommodityType++data CUnitOfMeasure+newtype UnitOfMeasure = UnitOfMeasure {getCUnitOfMeasure :: Standalone CUnitOfMeasure}+foreign import ccall unsafe "ql.h &qlFreeUnitOfMeasure" qlFreeUnitOfMeasure :: FinalizerPtr CUnitOfMeasure+instance Finalizable CUnitOfMeasure where finalize = qlFreeUnitOfMeasure+peekUnitOfMeasure :: Ptr CUnitOfMeasure -> IO UnitOfMeasure+peekUnitOfMeasure = UnitOfMeasure <.> peekStandalone+withUnitOfMeasure :: UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b+withUnitOfMeasure = withStandalone . getCUnitOfMeasure+withMaybeUnitOfMeasure :: Maybe UnitOfMeasure -> (Ptr CUnitOfMeasure -> IO b) -> IO b+withMaybeUnitOfMeasure = withMaybeStandalone . (getCUnitOfMeasure <$>)+peekMaybeUnitOfMeasure :: Ptr CUnitOfMeasure -> IO (Maybe UnitOfMeasure)+peekMaybeUnitOfMeasure p+  | p == nullPtr = pure Nothing+  | otherwise = Just <$> peekUnitOfMeasure p+foreign import ccall safe "ql.h qlUnitOfMeasureCode" qlUnitOfMeasureCode :: Ptr CUnitOfMeasure -> IO CString+instance Show UnitOfMeasure where show x = showStandalone qlUnitOfMeasureCode (getCUnitOfMeasure x)+instance Eq UnitOfMeasure where x == y = show x == show y+-- |Peek a 'UnitOfMeasure' out of a @UnitOfMeasure**@ out-parameter (as opposed to+-- 'peekUnitOfMeasure', which peeks it directly out of a @UnitOfMeasure*@ primary return).+peekUnitOfMeasurePtr :: Ptr (Ptr CUnitOfMeasure) -> IO UnitOfMeasure+peekUnitOfMeasurePtr = peek >=> peekUnitOfMeasure++data CPaymentTerm+newtype PaymentTerm = PaymentTerm {getCPaymentTerm :: Standalone CPaymentTerm}+foreign import ccall unsafe "ql.h &qlFreePaymentTerm" qlFreePaymentTerm :: FinalizerPtr CPaymentTerm+instance Finalizable CPaymentTerm where finalize = qlFreePaymentTerm+peekPaymentTerm :: Ptr CPaymentTerm -> IO PaymentTerm+peekPaymentTerm = PaymentTerm <.> peekStandalone+withPaymentTerm :: PaymentTerm -> (Ptr CPaymentTerm -> IO b) -> IO b+withPaymentTerm = withStandalone . getCPaymentTerm+withMaybePaymentTerm :: Maybe PaymentTerm -> (Ptr CPaymentTerm -> IO b) -> IO b+withMaybePaymentTerm = withMaybeStandalone . (getCPaymentTerm <$>)+peekMaybePaymentTerm :: Ptr CPaymentTerm -> IO (Maybe PaymentTerm)+peekMaybePaymentTerm p+  | p == nullPtr = pure Nothing+  | otherwise = Just <$> peekPaymentTerm p+foreign import ccall safe "ql.h qlPaymentTermName" qlPaymentTermName :: Ptr CPaymentTerm -> IO CString+instance Show PaymentTerm where show x = showStandalone qlPaymentTermName (getCPaymentTerm x)+instance Eq PaymentTerm where x == y = show x == show y++data CUnitOfMeasureConversion+newtype UnitOfMeasureConversion = UnitOfMeasureConversion {getCUnitOfMeasureConversion :: Standalone CUnitOfMeasureConversion}+foreign import ccall unsafe "ql.h &qlFreeUnitOfMeasureConversion" qlFreeUnitOfMeasureConversion :: FinalizerPtr CUnitOfMeasureConversion+instance Finalizable CUnitOfMeasureConversion where finalize = qlFreeUnitOfMeasureConversion+peekUnitOfMeasureConversion :: Ptr CUnitOfMeasureConversion -> IO UnitOfMeasureConversion+peekUnitOfMeasureConversion = UnitOfMeasureConversion <.> peekStandalone+withUnitOfMeasureConversion :: UnitOfMeasureConversion -> (Ptr CUnitOfMeasureConversion -> IO b) -> IO b+withUnitOfMeasureConversion = withStandalone . getCUnitOfMeasureConversion+foreign import ccall safe "ql.h qlUnitOfMeasureConversionCode" qlUnitOfMeasureConversionCode :: Ptr CUnitOfMeasureConversion -> IO CString+instance Show UnitOfMeasureConversion where show x = showStandalone qlUnitOfMeasureConversionCode (getCUnitOfMeasureConversion x)+instance Eq UnitOfMeasureConversion where x == y = show x == show y+ data CExchangeRate newtype ExchangeRate = ExchangeRate {getCExchangeRate :: Standalone CExchangeRate} foreign import ccall unsafe "ql.h &qlFreeExchangeRate" qlFreeExchangeRate :: FinalizerPtr CExchangeRate@@ -234,6 +308,22 @@ withSabrInterpolatedSmileSection :: SabrInterpolatedSmileSection -> (Ptr CSabrInterpolatedSmileSection -> IO b) -> IO b withSabrInterpolatedSmileSection = withStandalone . getCSabrInterpolatedSmileSection +-- |a dedicated leaf, not a downcast target: 'QuantLib.TermStructure.Volatility.optionletStripper2'+-- fuses construction of an 'OptionletStripper1' underneath (never exposed to Haskell, mirroring+-- 'QuantLib.TermStructure.Volatility.optionletStripper1') and stores the resulting+-- @OptionletStripper2@ itself, so its own diagnostic getters (atmCapFloorStrikes\/atmCapFloorPrices\/+-- spreadsVol) need no runtime cast. Use+-- 'QuantLib.TermStructure.Volatility.optionletStripper2AsOptionletVolatilityStructure' to pass one+-- into anything that wants the generic 'OptionletVolatilityStructure' interface.+data COptionletStripper2+newtype OptionletStripper2 = OptionletStripper2 {getCOptionletStripper2 :: Standalone COptionletStripper2}+foreign import ccall unsafe "ql.h &qlFreeOptionletStripper2" qlFreeOptionletStripper2 :: FinalizerPtr COptionletStripper2+instance Finalizable COptionletStripper2 where finalize = qlFreeOptionletStripper2+peekOptionletStripper2 :: Ptr COptionletStripper2 -> IO OptionletStripper2+peekOptionletStripper2 = OptionletStripper2 <.> peekStandalone+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@@ -274,6 +364,19 @@ withEquityCashFlowPricer :: EquityCashFlowPricer -> (Ptr CEquityCashFlowPricer -> IO b) -> IO b withEquityCashFlowPricer = withStandalone . getCEquityCashFlowPricer +data CYoYInflationCouponPricer+-- | Pricer for capped\/floored 'QuantLib.CashFlow.yoyInflationLeg' coupons. All 3 concrete+-- upstream pricers (Black\/UnitDisplacedBlack\/Bachelier) share one ctor shape and are bound as+-- constructors of this single type, mirroring 'FloatingRateCouponPricer'\/'EquityCashFlowPricer'+-- (a standalone pricer type, not part of any 'GenX' hierarchy).+newtype YoYInflationCouponPricer = YoYInflationCouponPricer {getCYoYInflationCouponPricer :: Standalone CYoYInflationCouponPricer}+foreign import ccall unsafe "ql.h &qlFreeYoYInflationCouponPricer" qlFreeYoYInflationCouponPricer :: FinalizerPtr CYoYInflationCouponPricer+instance Finalizable CYoYInflationCouponPricer where finalize = qlFreeYoYInflationCouponPricer+peekYoYInflationCouponPricer :: Ptr CYoYInflationCouponPricer -> IO YoYInflationCouponPricer+peekYoYInflationCouponPricer = YoYInflationCouponPricer <.> peekStandalone+withYoYInflationCouponPricer :: YoYInflationCouponPricer -> (Ptr CYoYInflationCouponPricer -> IO b) -> IO b+withYoYInflationCouponPricer = withStandalone . getCYoYInflationCouponPricer+ data CDefaultProbabilityHelper newtype DefaultProbabilityHelper = DefaultProbabilityHelper {getCDefaultProbabilityHelper :: Standalone CDefaultProbabilityHelper} foreign import ccall unsafe "ql.h &qlFreeDefaultProbabilityHelper" qlFreeDefaultProbabilityHelper :: FinalizerPtr CDefaultProbabilityHelper@@ -418,8 +521,9 @@ --                upstream but unconstructible here, while Quote/Index/TermStructure are --                pure-virtual upstream yet routinely returned by bindings. Marks are --                added where established; an unmarked node is not a claim of the opposite.---   `X + Y'      X also reaches secondary interface Y, via the standalone qlXAsY shim and---                the hand-written Y ADT (see CAffineModel' below), not via Upcastable.+--   `X + Y'      X also reaches secondary interface Y, via the standalone qlXAsY shim,+--                materialized eagerly into a `Standalone Y' value by a per-leaf `xAsY'+--                function (see CAffineModel' below), not via Upcastable. --   X (CFoo')    X's C type, given only where it is not the expected C<X>'. -- Payoff and Exercise are documented in the files that define them, not here. -- the original pointer to `a' with a way to marshal it to `b'@@ -462,7 +566,7 @@ -- `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 -- happening inside `access', and `restore' hands `f' back the caller's masking state. This--- is `bracket' semantics (cf. `withUpcast' below) expressed around a continuation that+-- is `bracket' semantics expressed around a continuation that -- 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@@ -479,6 +583,36 @@ peel :: GenForeignPtr (AnyOf b a) c -> GenForeignPtr a b peel = getAnyOf . ptr +-- |Arrays of 'CommodityType'\/'UnitOfMeasure' values, first needed by 'QuantLib.Instrument.Energy'+-- for marshalling a 'QuantLib.Commodity.PricingPeriods' list to\/from its C-side+-- structure-of-parallel-arrays representation (@Quantity@'s @CommodityType@\/@UnitOfMeasure@+-- component, split out one array per field, alongside 'QuantLib.Internal.withDayArray'\/'peekDayArray'+-- for the date fields and 'QuantLib.Internal.withDoubleArray'\/'peekDoubleArray' for the amount) --+-- reusing 'withGenArray'\/'peekPtrArray' exactly as 'withBlackCalibrationHelperArray' does.+withCommodityTypeArray :: [CommodityType] -> ((CUInt, Ptr (Ptr CCommodityType)) -> IO b) -> IO b+withCommodityTypeArray = withGenArray withCommodityType+-- |Output side, first needed by 'QuantLib.Instrument.Energy.createPricingPeriods' (the only+-- 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++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++-- |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).+withMaybeUnitOfMeasureArray :: [Maybe UnitOfMeasure] -> ((CUInt, Ptr (Ptr CUnitOfMeasure)) -> IO b) -> IO b+withMaybeUnitOfMeasureArray = withGenArray withMaybeUnitOfMeasure++-- |An array of 'Currency' values -- @SecondaryCosts@'\/@SecondaryCostAmounts@'s per-entry currency.+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+ -- | > Quote -- >   SimpleQuote -- >   DeltaVolQuote@@ -535,7 +669,7 @@ withQuoteArrayRaw :: [GenQuote q] -> (Ptr (Ptr CQuote') -> IO b) -> IO b withQuoteArrayRaw x f = withMany withQuote x (`withArray` f) --- PAYOFF/EXERCISE upcast targets used by QuantLib.Internal.Enum's Payoff/Exercise ADT dispatch+-- PAYOFF/EXERCISE upcast targets used by QuantLib.Internal.Common's Payoff/Exercise ADT dispatch -- (the ADTs themselves stay in Enum.chs; only the pointer hierarchy plumbing lives here, -- matching every other hierarchy in this module) data CPayoff'@@ -600,6 +734,12 @@ instance Upcastable CSwingExercise' where {type Base CSwingExercise' = CBermudanExercise'; upcast = qlSwingExerciseAsBermudanExercise} foreign import ccall "ql.h qlSwingExerciseAsBermudanExercise" qlSwingExerciseAsBermudanExercise :: Ptr CSwingExercise' -> IO (Ptr CBermudanExercise') +data CRebatedExercise'+foreign import ccall unsafe "ql.h &qlFreeRebatedExercise" qlFreeRebatedExercise :: FinalizerPtr CRebatedExercise'+instance Finalizable CRebatedExercise' where finalize = qlFreeRebatedExercise+instance Upcastable CRebatedExercise' where {type Base CRebatedExercise' = CExercise'; upcast = qlRebatedExerciseAsExercise}+foreign import ccall "ql.h qlRebatedExerciseAsExercise" qlRebatedExerciseAsExercise :: Ptr CRebatedExercise' -> IO (Ptr CExercise')+ data CLeg' data CCouponLeg' newtype GenLeg l = GenLeg {getLeg :: GenForeignPtr l CLeg'}@@ -677,14 +817,23 @@ peekOISRateHelper = GenRateHelper <.> newGenForeignPtr  -- | > CalibrationHelper--- >   BlackCalibrationHelper+-- >   BlackCalibrationHelper*+-- >     SwaptionHelper+-- BlackCalibrationHelper is a proper one-AnyOf-layer family (mirrors GenSwap/GenOption under+-- GenInstrument), not a plain leaf directly under CalibrationHelper as before, so a concrete+-- subtype (SwaptionHelper) can be given its own getters without a runtime cast: SwaptionHelper's+-- own underlying()/swaption() need the real SwaptionHelper pointer, while the pre-existing+-- BlackCalibrationHelper-level accessors (times, blackPrice, impliedVolatility, ...) are+-- generalized to 'GenBlackCalibrationHelper bch' so they keep working on any leaf, SwaptionHelper+-- included, without an explicit upcast at each call site. type CalibrationHelper = GenCalibrationHelper CCalibrationHelper data CCalibrationHelper' data CBlackCalibrationHelper' newtype GenCalibrationHelper ch = GenCalibrationHelper {getCalibrationHelper :: GenForeignPtr ch CCalibrationHelper'} type CCalibrationHelper = ForeignPtr CCalibrationHelper'+type GenBlackCalibrationHelper bch = GenCalibrationHelper (AnyOf CBlackCalibrationHelper' bch) type CBlackCalibrationHelper = ForeignPtr CBlackCalibrationHelper'-type BlackCalibrationHelper = GenCalibrationHelper CBlackCalibrationHelper+type BlackCalibrationHelper = GenBlackCalibrationHelper CBlackCalibrationHelper foreign import ccall unsafe "ql.h &qlFreeCalibrationHelper" qlFreeCalibrationHelper :: FinalizerPtr CCalibrationHelper' foreign import ccall unsafe "ql.h &qlFreeBlackCalibrationHelper" qlFreeBlackCalibrationHelper :: FinalizerPtr CBlackCalibrationHelper' instance Finalizable CCalibrationHelper' where finalize = qlFreeCalibrationHelper@@ -697,15 +846,43 @@ peekCalibrationHelper = GenCalibrationHelper <.> newCastForeignPtr withCalibrationHelper :: GenCalibrationHelper ch -> (Ptr CCalibrationHelper' -> IO b) -> IO b withCalibrationHelper = withGenForeignPtr . getCalibrationHelper-withGenCalibrationHelper :: GenCalibrationHelper (ForeignPtr ch) -> (Ptr ch -> IO b) -> IO b-withGenCalibrationHelper = withForeignPtr . ptr . getCalibrationHelper+-- hands back the raw stored leaf pointer (e.g. Ptr CSwaptionHelper'); for a marshaller that+-- upcasts to the concrete Ptr CBlackCalibrationHelper', see 'withBlackCalibrationHelper' below.+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 peekBlackCalibrationHelper :: Ptr CBlackCalibrationHelper' -> IO BlackCalibrationHelper-peekBlackCalibrationHelper = GenCalibrationHelper <.> newGenForeignPtr+peekBlackCalibrationHelper = newCastForeignPtr >=> newGenBlackCalibrationHelper+withBlackCalibrationHelper :: GenBlackCalibrationHelper bch -> (Ptr CBlackCalibrationHelper' -> IO b) -> IO b+withBlackCalibrationHelper = withGenForeignPtr . peel . getCalibrationHelper+newGenBlackCalibrationHelper :: GenForeignPtr bch CBlackCalibrationHelper' -> IO (GenBlackCalibrationHelper bch)+newGenBlackCalibrationHelper = pure . GenCalibrationHelper . newAnyOf withCalibrationHelperArray :: [GenCalibrationHelper ch] -> ((CUInt, Ptr (Ptr CCalibrationHelper')) -> IO b) -> IO b withCalibrationHelperArray = withGenArray withCalibrationHelper-withBlackCalibrationHelperArray :: [BlackCalibrationHelper] -> ((CUInt, Ptr (Ptr CBlackCalibrationHelper')) -> IO b) -> IO b-withBlackCalibrationHelperArray = withGenArray withGenCalibrationHelper+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 +-- SwaptionHelper is only reachable as this concrete type when hasquant itself constructs it+-- (Model.chs's swaptionHelper/swaptionHelperFromDate/swaptionHelperFromDates); a basket returned+-- by NonstandardSwaption/FloatFloatSwaption's calibrationBasket is erased to plain+-- BlackCalibrationHelper by QuantLib's own calibrationBasket signature before it ever reaches+-- this binding, so underlying/swaption are not reachable on basket elements without a cast --+-- deliberately not offered there.+data CSwaptionHelper'+type CSwaptionHelper = ForeignPtr CSwaptionHelper'+type SwaptionHelper = GenBlackCalibrationHelper CSwaptionHelper+foreign import ccall unsafe "ql.h &qlFreeSwaptionHelper" qlFreeSwaptionHelper :: FinalizerPtr CSwaptionHelper'+instance Finalizable CSwaptionHelper' where finalize = qlFreeSwaptionHelper+foreign import ccall "ql.h qlSwaptionHelperAsBlackCalibrationHelper" qlSwaptionHelperAsBlackCalibrationHelper :: Ptr CSwaptionHelper' -> IO (Ptr CBlackCalibrationHelper')+instance Upcastable CSwaptionHelper' where {type Base CSwaptionHelper' = CBlackCalibrationHelper'; upcast = qlSwaptionHelperAsBlackCalibrationHelper}+peekSwaptionHelper :: Ptr CSwaptionHelper' -> IO SwaptionHelper+peekSwaptionHelper = newGenForeignPtr >=> newGenBlackCalibrationHelper+withSwaptionHelper :: SwaptionHelper -> (Ptr CSwaptionHelper' -> IO b) -> IO b+withSwaptionHelper = withForeignPtr . ptr . peel . getCalibrationHelper+ -- | > BlackCalculator -- >   BlackScholesCalculator type BlackCalculator = GenBlackCalculator CBlackCalculator@@ -756,6 +933,7 @@ -- >    YoYInflationIndex -- >    ZeroInflationIndex -- >  EquityIndex+-- >  CommodityIndex type Index = GenIndex CIndex data CIndex' data CInterestRateIndex'@@ -924,6 +1102,19 @@ withEquityIndex :: EquityIndex -> (Ptr CEquityIndex' -> IO b) -> IO b withEquityIndex = withForeignPtr . ptr . getIndex +-- | A plain 'Index' leaf, mirroring 'EquityIndex' -- no subclasses upstream.+data CCommodityIndex'+type CCommodityIndex = ForeignPtr CCommodityIndex'+type CommodityIndex = GenIndex CCommodityIndex+foreign import ccall unsafe "ql.h &qlFreeCommodityIndex" qlFreeCommodityIndex :: FinalizerPtr CCommodityIndex'+instance Finalizable CCommodityIndex' where finalize = qlFreeCommodityIndex+foreign import ccall "ql.h qlCommodityIndexAsIndex" qlCommodityIndexAsIndex :: Ptr CCommodityIndex' -> IO (Ptr CIndex')+instance Upcastable CCommodityIndex' where {type Base CCommodityIndex' = CIndex'; upcast = qlCommodityIndexAsIndex}+peekCommodityIndex :: Ptr CCommodityIndex' -> IO CommodityIndex+peekCommodityIndex = GenIndex <.> newGenForeignPtr+withCommodityIndex :: CommodityIndex -> (Ptr CCommodityIndex' -> IO b) -> IO b+withCommodityIndex = withForeignPtr . ptr . getIndex+ -- | > TermStructure = GenTermStructure t -- >  YieldTermStructure = GenYieldTermStructure y = GenTermStructure t -- >    FittedBondDiscountCurve = GenYieldTermStructure ...@@ -942,12 +1133,23 @@ -- >      RelinkableSwaptionVolatilityStructure -- >      SabrSwaptionVolatilityCube -- >      InterpolatedSwaptionVolatilityCube--- >    CapFloorTermVolSurface+-- >    CapFloorTermVolatilityStructure*+-- >      CapFloorTermVolCurve+-- >      CapFloorTermVolSurface+-- >    BlackAtmVolCurve*+-- >      AbcdAtmVolCurve+-- >      BlackVolSurface*+-- >        SabrVolSurface -- >    LocalVolTermStructure+-- >    YoYOptionletVolatilitySurface+-- >    CPIVolatilitySurface -- >  CallableBondVolatilityStructure -- >  DefaultProbabilityTermStructure -- >  ZeroInflationTermStructure -- >  YoYInflationTermStructure+-- >  YoYCapFloorTermPriceSurface+-- >  CPICapFloorTermPriceSurface+-- >  CommodityCurve type TermStructure = GenTermStructure CTermStructure data CTermStructure' data CVolatilityTermStructure'@@ -957,8 +1159,12 @@ data CRelinkableSwaptionVolatilityStructure' data CSabrSwaptionVolatilityCube' data CInterpolatedSwaptionVolatilityCube'+data CCapFloorTermVolatilityStructure'+data CCapFloorTermVolCurve' data CCapFloorTermVolSurface' data CLocalVolTermStructure'+data CYoYOptionletVolatilitySurface'+data CCPIVolatilitySurface' data CBlackVolTermStructure' data CRelinkableBlackVolTermStructure' data CBlackVarianceCurve'@@ -970,6 +1176,7 @@ data CDefaultProbabilityTermStructure' data CZeroInflationTermStructure' data CYoYInflationTermStructure'+data CCommodityCurve' newtype GenTermStructure t = GenTermStructure {getTermStructure :: GenForeignPtr t CTermStructure'} type CTermStructure = ForeignPtr CTermStructure' type GenYieldTermStructure y = GenTermStructure (AnyOf CYieldTermStructure' y)@@ -996,8 +1203,26 @@ -- 'QuantLib.TermStructure.Volatility.linkOptionletVolTo' reaches everything already built on -- it. Mirrors 'RelinkableSwaptionVolatilityStructure'. type RelinkableOptionletVolatilityStructure = GenOptionletVolatilityStructure CRelinkableOptionletVolatilityStructure+type GenCapFloorTermVolatilityStructure c = GenVolatilityTermStructure (AnyOf CCapFloorTermVolatilityStructure' c)+type CCapFloorTermVolatilityStructure = ForeignPtr CCapFloorTermVolatilityStructure'+-- | The abstract root shared by 'ConstantCapFloorTermVolatility' (erased straight to this type at+-- construction, having no calc\/getter of its own beyond 'capFloorVolatilityForPeriod' et al.,+-- mirroring 'ConstantOptionletVolatility' \/\'OptionletVolatilityStructure'), and the two dedicated+-- leaves below. Promoted out of a flat 'VolatilityTermStructure' leaf (the way+-- 'YoYOptionletVolatilitySurface' still is) specifically so 'capFloorVolatilityForPeriod'\/+-- 'capFloorVolatilityForDate'\/'capFloorVolatilityForTime' -- declared on+-- @CapFloorTermVolatilityStructure@ upstream, not on 'VolatilityTermStructure' -- can be bound+-- generically without a @dynamic_pointer_cast@ in the shim.+type CapFloorTermVolatilityStructure = GenCapFloorTermVolatilityStructure CCapFloorTermVolatilityStructure+type CCapFloorTermVolCurve = ForeignPtr CCapFloorTermVolCurve'+-- | An ATM-only cap\/floor term vol curve (no strike dimension, unlike 'CapFloorTermVolSurface').+-- Gets its own dedicated leaf (rather than erasing to 'CapFloorTermVolatilityStructure' the way+-- 'ConstantCapFloorTermVolatility' does) so a future binding of @OptionletStripper2@ -- which takes+-- a concrete @Handle\<CapFloorTermVolCurve\>@ upstream -- has a type to reach for without another+-- breaking change here.+type CapFloorTermVolCurve = GenCapFloorTermVolatilityStructure CCapFloorTermVolCurve type CCapFloorTermVolSurface = ForeignPtr CCapFloorTermVolSurface'-type CapFloorTermVolSurface = GenVolatilityTermStructure CCapFloorTermVolSurface+type CapFloorTermVolSurface = GenCapFloorTermVolatilityStructure CCapFloorTermVolSurface type GenSwaptionVolatilityStructure sv = GenVolatilityTermStructure (AnyOf CSwaptionVolatilityStructure' sv) type CSwaptionVolatilityStructure = ForeignPtr CSwaptionVolatilityStructure' type SwaptionVolatilityStructure = GenSwaptionVolatilityStructure CSwaptionVolatilityStructure@@ -1022,8 +1247,65 @@ -- treatment as 'SabrSwaptionVolatilityCube' for its 'atmStrike' getter (inherited, in upstream, -- from the same abstract @SwaptionVolatilityCube@ base both concrete cubes share). type InterpolatedSwaptionVolatilityCube = GenSwaptionVolatilityStructure CInterpolatedSwaptionVolatilityCube+-- | Black at-the-money (no-smile) volatility curve, abstract here (hasquant binds no+-- @qlBlackAtmVolCurve@ constructor -- @BlackAtmVolCurve@ has no bindable constructor upstream+-- either, only its concrete subclasses do). A sibling of 'OptionletVolatilityStructure'\/+-- 'CapFloorTermVolatilityStructure'\/'SwaptionVolatilityStructure' directly off+-- 'VolatilityTermStructure'. Reachable as a value via 'SabrVolSurface''s @atmCurve@ getter (any+-- concrete member may be held there), and as the argument type of 'sabrVolSurface'.+type GenBlackAtmVolCurve b = GenVolatilityTermStructure (AnyOf CBlackAtmVolCurve' b)+data CBlackAtmVolCurve'+type CBlackAtmVolCurve = ForeignPtr CBlackAtmVolCurve'+type BlackAtmVolCurve = GenBlackAtmVolCurve CBlackAtmVolCurve+-- | Black volatility (smile) surface: adds a strike\/smile dimension over 'BlackAtmVolCurve'.+-- Abstract here (no bindable constructor of its own -- only 'SabrVolSurface' constructs one in+-- this binding), but earns its own hierarchy level rather than folding into 'BlackAtmVolCurve'+-- (unlike @InterestRateVolSurface@, deliberately not given its own level -- see 'SabrVolSurface')+-- because its own calculation, @smileSection@, is the defining feature of the "surface" vs+-- "curve" distinction, not a thin pass-through inspector.+type GenBlackVolSurface b = GenBlackAtmVolCurve (AnyOf CBlackVolSurface' b)+data CBlackVolSurface'+type CBlackVolSurface = ForeignPtr CBlackVolSurface'+type BlackVolSurface = GenBlackVolSurface CBlackVolSurface+data CAbcdAtmVolCurve'+type CAbcdAtmVolCurve = ForeignPtr CAbcdAtmVolCurve'+-- | ABCD-parametric fit to a set of (tenor, quote) at-the-money vols. A dedicated+-- 'BlackAtmVolCurve' leaf (real calc\/getters of its own -- @a@\/@b@\/@c@\/@d@\/@rmsError@\/etc --+-- per the API-design rule in CLAUDE.md), one 'AnyOf' layer under 'GenBlackAtmVolCurve', same depth+-- as 'CapFloorTermVolCurve' under 'GenCapFloorTermVolatilityStructure'.+type AbcdAtmVolCurve = GenBlackAtmVolCurve CAbcdAtmVolCurve+data CSabrVolSurface'+type CSabrVolSurface = ForeignPtr CSabrVolSurface'+-- | SABR-smile surface built from an interest-rate index, an ATM 'BlackAtmVolCurve', and+-- per-tenor vol spreads. A dedicated 'BlackVolSurface' leaf (own getters: @atmCurve@,+-- @volatilitySpreads@; plus @index@\/@optionDateFromTenor@ folded in directly from upstream's+-- @InterestRateVolSurface@, which is not given its own hierarchy level here since+-- 'SabrVolSurface' is its only concrete member in this binding -- per CLAUDE.md's "don't mirror+-- the C++ hierarchy 1:1" rule). Two 'AnyOf' layers under 'GenBlackVolSurface' (mirrors+-- 'VanillaSwap' under 'FixedVsFloatingSwap' under 'GenSwap').+type SabrVolSurface = GenBlackVolSurface CSabrVolSurface type CLocalVolTermStructure = ForeignPtr CLocalVolTermStructure' type LocalVolTermStructure = GenVolatilityTermStructure CLocalVolTermStructure+type CYoYOptionletVolatilitySurface = ForeignPtr CYoYOptionletVolatilitySurface'+-- | A YoY-inflation optionlet vol surface, quoted via 'volatility'\/'totalVariance' at+-- (maturity, strike) pairs rather than QuantLib's usual (option date, tenor, strike) grid, since+-- inflation caplets observe a single index fixing rather than a forward rate. A plain+-- 'VolatilityTermStructure' leaf like 'CapFloorTermVolSurface', constructed and consumed via a+-- @Handle@ (mirroring 'OptionletVolatilityStructure', since it feeds+-- 'QuantLib.PricingEngine.yoyInflationBlackCapFloorEngine' et al. exactly the way+-- 'OptionletVolatilityStructure' feeds 'QuantLib.PricingEngine.blackCapFloorEngine'').+type YoYOptionletVolatilitySurface = GenVolatilityTermStructure CYoYOptionletVolatilitySurface+type CCPIVolatilitySurface = ForeignPtr CCPIVolatilitySurface'+-- | A CPI (zero-inflation) volatility surface, quoted via 'volatility'\/'totalVariance' at+-- (maturity, strike) pairs -- same shape as 'YoYOptionletVolatilitySurface', a plain+-- 'VolatilityTermStructure' leaf constructed and consumed via a @Handle@. Unlike+-- 'YoYOptionletVolatilitySurface' it feeds no pricing engine in QL 1.43: 'CPICapFloor' prices+-- purely off 'QuantLib.TermStructure.InflationVolatility.CPICapFloorTermPriceSurface' via+-- 'QuantLib.PricingEngine.interpolatingCPICapFloorEngine', and 'CPICouponPricer' (the type that+-- would consume this) is itself explicitly unfinished upstream for vol-dependent coupons (no+-- concrete descendant exists to bind, unlike 'YoYInflationCouponPricer's three) -- so this type+-- stands alone as a queryable surface, not (yet) as engine\/pricer plumbing.+type CPIVolatilitySurface = GenVolatilityTermStructure CCPIVolatilitySurface type GenBlackVolTermStructure bv = GenVolatilityTermStructure (AnyOf CBlackVolTermStructure' bv) type CBlackVolTermStructure = ForeignPtr CBlackVolTermStructure' type BlackVolTermStructure = GenBlackVolTermStructure CBlackVolTermStructure@@ -1045,6 +1327,34 @@ type ZeroInflationTermStructure = GenTermStructure CZeroInflationTermStructure type CYoYInflationTermStructure = ForeignPtr CYoYInflationTermStructure' type YoYInflationTermStructure = GenTermStructure CYoYInflationTermStructure+type CCommodityCurve = ForeignPtr CCommodityCurve'+-- | A plain 'TermStructure' leaf (not a 'YieldTermStructure' -- it has no discount-factor+-- semantics, just an interpolated price curve), constructed and consumed by @shared_ptr@ like+-- 'CallableBondVolatilityStructure'\/'DefaultProbabilityTermStructure', never a @Handle@.+type CommodityCurve = GenTermStructure CCommodityCurve+data CYoYCapFloorTermPriceSurface'+type CYoYCapFloorTermPriceSurface = ForeignPtr CYoYCapFloorTermPriceSurface'+-- | Prices YoY cap\/floors by cap\/floor-surface intersection and put\/call parity, deriving an+-- ATM YoY swap curve as a side effect -- the market-data input the YoY optionlet stripper+-- ('QuantLib.TermStructure.InflationVolatility.kInterpolatedYoYOptionletVolatilitySurfaceBlack'+-- et al.) bootstraps from. A plain 'TermStructure' leaf, constructed and consumed by+-- @shared_ptr@ like 'CPICapFloorTermPriceSurface', never a @Handle@. Takes independent+-- 'Interpolation2D' (cap\/floor price grid) and 'Interpolation' (per-maturity) choices --+-- a different template (@InterpolatedYoYCapFloorTermPriceSurface@) from+-- 'CPICapFloorTermPriceSurface's @InterpolatedCPICapFloorTermPriceSurface@, hence the separate+-- 2-D\/1-D pair rather than 'CPICapFloorTermPriceSurface's single 'Interpolation2D'.+type YoYCapFloorTermPriceSurface = GenTermStructure CYoYCapFloorTermPriceSurface+data CCPICapFloorTermPriceSurface'+type CCPICapFloorTermPriceSurface = ForeignPtr CCPICapFloorTermPriceSurface'+-- | Prices CPI cap\/floors by interpolation and put\/call parity off a market strike\/maturity+-- price grid, not by any vol model (see 'CPICapFloor's own comment) -- a plain 'TermStructure'+-- leaf, constructed and consumed by @shared_ptr@ like 'CommodityCurve', never a @Handle@ (wrapped+-- into one at the point of use, e.g. 'QuantLib.PricingEngine.interpolatingCPICapFloorEngine').+-- Takes an 'Interpolation2D' choice for the cap\/floor price grid -- a different template+-- (@InterpolatedCPICapFloorTermPriceSurface@) from 'YoYCapFloorTermPriceSurface's+-- @InterpolatedYoYCapFloorTermPriceSurface@, hence its own single 2-D slot rather than+-- 'YoYCapFloorTermPriceSurface's separate 2-D\/1-D pair.+type CPICapFloorTermPriceSurface = GenTermStructure CCPICapFloorTermPriceSurface foreign import ccall unsafe "ql.h &qlFreeTermStructure" qlFreeTermStructure :: FinalizerPtr CTermStructure' foreign import ccall unsafe "ql.h &qlFreeVolatilityTermStructure" qlFreeVolatilityTermStructure :: FinalizerPtr CVolatilityTermStructure' foreign import ccall unsafe "ql.h &qlFreeOptionletVolatilityStructure" qlFreeOptionletVolatilityStructure :: FinalizerPtr COptionletVolatilityStructure'@@ -1053,8 +1363,16 @@ 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 &qlFreeInterpolatedSwaptionVolatilityCube" qlFreeInterpolatedSwaptionVolatilityCube :: FinalizerPtr CInterpolatedSwaptionVolatilityCube'+foreign import ccall unsafe "ql.h &qlFreeCapFloorTermVolatilityStructure" qlFreeCapFloorTermVolatilityStructure :: FinalizerPtr CCapFloorTermVolatilityStructure'+foreign import ccall unsafe "ql.h &qlFreeCapFloorTermVolCurve" qlFreeCapFloorTermVolCurve :: FinalizerPtr CCapFloorTermVolCurve' foreign import ccall unsafe "ql.h &qlFreeCapFloorTermVolSurface" qlFreeCapFloorTermVolSurface :: FinalizerPtr CCapFloorTermVolSurface'+foreign import ccall unsafe "ql.h &qlFreeBlackAtmVolCurve" qlFreeBlackAtmVolCurve :: FinalizerPtr CBlackAtmVolCurve'+foreign import ccall unsafe "ql.h &qlFreeBlackVolSurface" qlFreeBlackVolSurface :: FinalizerPtr CBlackVolSurface'+foreign import ccall unsafe "ql.h &qlFreeAbcdAtmVolCurve" qlFreeAbcdAtmVolCurve :: FinalizerPtr CAbcdAtmVolCurve'+foreign import ccall unsafe "ql.h &qlFreeSabrVolSurface" qlFreeSabrVolSurface :: FinalizerPtr CSabrVolSurface' foreign import ccall unsafe "ql.h &qlFreeLocalVolTermStructure" qlFreeLocalVolTermStructure :: FinalizerPtr CLocalVolTermStructure'+foreign import ccall unsafe "ql.h &qlFreeYoYOptionletVolatilitySurface" qlFreeYoYOptionletVolatilitySurface :: FinalizerPtr CYoYOptionletVolatilitySurface'+foreign import ccall unsafe "ql.h &qlFreeCPIVolatilitySurface" qlFreeCPIVolatilitySurface :: FinalizerPtr CCPIVolatilitySurface' foreign import ccall unsafe "ql.h &qlFreeBlackVolTermStructure" qlFreeBlackVolTermStructure :: FinalizerPtr CBlackVolTermStructure' foreign import ccall unsafe "ql.h &qlFreeRelinkableBlackVolTermStructure" qlFreeRelinkableBlackVolTermStructure :: FinalizerPtr CRelinkableBlackVolTermStructure' foreign import ccall unsafe "ql.h &qlFreeBlackVarianceCurve" qlFreeBlackVarianceCurve :: FinalizerPtr CBlackVarianceCurve'@@ -1066,6 +1384,9 @@ foreign import ccall unsafe "ql.h &qlFreeDefaultProbabilityTermStructure" qlFreeDefaultProbabilityTermStructure :: FinalizerPtr CDefaultProbabilityTermStructure' 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'+foreign import ccall unsafe "ql.h &qlFreeCPICapFloorTermPriceSurface" qlFreeCPICapFloorTermPriceSurface :: FinalizerPtr CCPICapFloorTermPriceSurface'+foreign import ccall unsafe "ql.h &qlFreeCommodityCurve" qlFreeCommodityCurve :: FinalizerPtr CCommodityCurve' instance Finalizable CTermStructure' where finalize = qlFreeTermStructure instance Finalizable CVolatilityTermStructure' where finalize = qlFreeVolatilityTermStructure instance Finalizable COptionletVolatilityStructure' where finalize = qlFreeOptionletVolatilityStructure@@ -1074,8 +1395,16 @@ instance Finalizable CRelinkableSwaptionVolatilityStructure' where finalize = qlFreeRelinkableSwaptionVolatilityStructure instance Finalizable CSabrSwaptionVolatilityCube' where finalize = qlFreeSabrSwaptionVolatilityCube instance Finalizable CInterpolatedSwaptionVolatilityCube' where finalize = qlFreeInterpolatedSwaptionVolatilityCube+instance Finalizable CCapFloorTermVolatilityStructure' where finalize = qlFreeCapFloorTermVolatilityStructure+instance Finalizable CCapFloorTermVolCurve' where finalize = qlFreeCapFloorTermVolCurve instance Finalizable CCapFloorTermVolSurface' where finalize = qlFreeCapFloorTermVolSurface+instance Finalizable CBlackAtmVolCurve' where finalize = qlFreeBlackAtmVolCurve+instance Finalizable CBlackVolSurface' where finalize = qlFreeBlackVolSurface+instance Finalizable CAbcdAtmVolCurve' where finalize = qlFreeAbcdAtmVolCurve+instance Finalizable CSabrVolSurface' where finalize = qlFreeSabrVolSurface instance Finalizable CLocalVolTermStructure' where finalize = qlFreeLocalVolTermStructure+instance Finalizable CYoYOptionletVolatilitySurface' where finalize = qlFreeYoYOptionletVolatilitySurface+instance Finalizable CCPIVolatilitySurface' where finalize = qlFreeCPIVolatilitySurface instance Finalizable CBlackVolTermStructure' where finalize = qlFreeBlackVolTermStructure instance Finalizable CRelinkableBlackVolTermStructure' where finalize = qlFreeRelinkableBlackVolTermStructure instance Finalizable CBlackVarianceCurve' where finalize = qlFreeBlackVarianceCurve@@ -1087,6 +1416,9 @@ instance Finalizable CDefaultProbabilityTermStructure' where finalize = qlFreeDefaultProbabilityTermStructure instance Finalizable CZeroInflationTermStructure' where finalize = qlFreeZeroInflationTermStructure instance Finalizable CYoYInflationTermStructure' where finalize = qlFreeYoYInflationTermStructure+instance Finalizable CYoYCapFloorTermPriceSurface' where finalize = qlFreeYoYCapFloorTermPriceSurface+instance Finalizable CCPICapFloorTermPriceSurface' where finalize = qlFreeCPICapFloorTermPriceSurface+instance Finalizable CCommodityCurve' where finalize = qlFreeCommodityCurve foreign import ccall "ql.h qlYieldTermStructureAsTermStructure" qlYieldTermStructureAsTermStructure :: Ptr CYieldTermStructure' -> IO (Ptr CTermStructure') foreign import ccall "ql.h qlFittedBondDiscountCurveAsYieldTermStructure" qlFittedBondDiscountCurveAsYieldTermStructure :: Ptr CFittedBondDiscountCurve' -> IO (Ptr CYieldTermStructure') foreign import ccall "ql.h qlRelinkableYieldTermStructureAsYieldTermStructure" qlRelinkableYieldTermStructureAsYieldTermStructure :: Ptr CRelinkableYieldTermStructure' -> IO (Ptr CYieldTermStructure')@@ -1101,12 +1433,23 @@ 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 qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure" qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure :: Ptr CInterpolatedSwaptionVolatilityCube' -> IO (Ptr CSwaptionVolatilityStructure')-foreign import ccall "ql.h qlCapFloorTermVolSurfaceAsVolatilityTermStructure" qlCapFloorTermVolSurfaceAsVolatilityTermStructure :: Ptr CCapFloorTermVolSurface' -> IO (Ptr CVolatilityTermStructure')+foreign import ccall "ql.h qlCapFloorTermVolatilityStructureAsVolatilityTermStructure" qlCapFloorTermVolatilityStructureAsVolatilityTermStructure :: Ptr CCapFloorTermVolatilityStructure' -> IO (Ptr CVolatilityTermStructure')+foreign import ccall "ql.h qlCapFloorTermVolCurveAsCapFloorTermVolatilityStructure" qlCapFloorTermVolCurveAsCapFloorTermVolatilityStructure :: Ptr CCapFloorTermVolCurve' -> IO (Ptr CCapFloorTermVolatilityStructure')+foreign import ccall "ql.h qlCapFloorTermVolSurfaceAsCapFloorTermVolatilityStructure" qlCapFloorTermVolSurfaceAsCapFloorTermVolatilityStructure :: Ptr CCapFloorTermVolSurface' -> IO (Ptr CCapFloorTermVolatilityStructure')+foreign import ccall "ql.h qlBlackAtmVolCurveAsVolatilityTermStructure" qlBlackAtmVolCurveAsVolatilityTermStructure :: Ptr CBlackAtmVolCurve' -> IO (Ptr CVolatilityTermStructure')+foreign import ccall "ql.h qlBlackVolSurfaceAsBlackAtmVolCurve" qlBlackVolSurfaceAsBlackAtmVolCurve :: Ptr CBlackVolSurface' -> IO (Ptr CBlackAtmVolCurve')+foreign import ccall "ql.h qlAbcdAtmVolCurveAsBlackAtmVolCurve" qlAbcdAtmVolCurveAsBlackAtmVolCurve :: Ptr CAbcdAtmVolCurve' -> IO (Ptr CBlackAtmVolCurve')+foreign import ccall "ql.h qlSabrVolSurfaceAsBlackVolSurface" qlSabrVolSurfaceAsBlackVolSurface :: Ptr CSabrVolSurface' -> IO (Ptr CBlackVolSurface') foreign import ccall "ql.h qlLocalVolTermStructureAsVolatilityTermStructure" qlLocalVolTermStructureAsVolatilityTermStructure :: Ptr CLocalVolTermStructure' -> IO (Ptr CVolatilityTermStructure')+foreign import ccall "ql.h qlYoYOptionletVolatilitySurfaceAsVolatilityTermStructure" qlYoYOptionletVolatilitySurfaceAsVolatilityTermStructure :: Ptr CYoYOptionletVolatilitySurface' -> IO (Ptr CVolatilityTermStructure')+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 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')+foreign import ccall "ql.h qlCPICapFloorTermPriceSurfaceAsTermStructure" qlCPICapFloorTermPriceSurfaceAsTermStructure :: Ptr CCPICapFloorTermPriceSurface' -> IO (Ptr CTermStructure')+foreign import ccall "ql.h qlCommodityCurveAsTermStructure" qlCommodityCurveAsTermStructure :: Ptr CCommodityCurve' -> IO (Ptr CTermStructure') instance Upcastable CYieldTermStructure' where {type Base CYieldTermStructure' = CTermStructure'; upcast = qlYieldTermStructureAsTermStructure} instance Upcastable CFittedBondDiscountCurve' where {type Base CFittedBondDiscountCurve' = CYieldTermStructure'; upcast = qlFittedBondDiscountCurveAsYieldTermStructure} instance Upcastable CRelinkableYieldTermStructure' where {type Base CRelinkableYieldTermStructure' = CYieldTermStructure'; upcast = qlRelinkableYieldTermStructureAsYieldTermStructure}@@ -1115,6 +1458,9 @@ instance Upcastable CDefaultProbabilityTermStructure' where {type Base CDefaultProbabilityTermStructure' = CTermStructure'; upcast = qlDefaultProbabilityTermStructureAsTermStructure} 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}+instance Upcastable CCPICapFloorTermPriceSurface' where {type Base CCPICapFloorTermPriceSurface' = CTermStructure'; upcast = qlCPICapFloorTermPriceSurfaceAsTermStructure}+instance Upcastable CCommodityCurve' where {type Base CCommodityCurve' = CTermStructure'; upcast = qlCommodityCurveAsTermStructure} instance Upcastable CBlackVolTermStructure' where {type Base CBlackVolTermStructure' = CVolatilityTermStructure'; upcast = qlBlackVolTermStructureAsVolatilityTermStructure} instance Upcastable CRelinkableBlackVolTermStructure' where {type Base CRelinkableBlackVolTermStructure' = CBlackVolTermStructure'; upcast = qlRelinkableBlackVolTermStructureAsBlackVolTermStructure} instance Upcastable CBlackVarianceCurve' where {type Base CBlackVarianceCurve' = CBlackVolTermStructure'; upcast = qlBlackVarianceCurveAsBlackVolTermStructure}@@ -1125,8 +1471,16 @@ instance Upcastable CRelinkableSwaptionVolatilityStructure' where {type Base CRelinkableSwaptionVolatilityStructure' = CSwaptionVolatilityStructure'; upcast = qlRelinkableSwaptionVolatilityStructureAsSwaptionVolatilityStructure} instance Upcastable CSabrSwaptionVolatilityCube' where {type Base CSabrSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlSabrSwaptionVolatilityCubeAsSwaptionVolatilityStructure} instance Upcastable CInterpolatedSwaptionVolatilityCube' where {type Base CInterpolatedSwaptionVolatilityCube' = CSwaptionVolatilityStructure'; upcast = qlInterpolatedSwaptionVolatilityCubeAsSwaptionVolatilityStructure}-instance Upcastable CCapFloorTermVolSurface' where {type Base CCapFloorTermVolSurface' = CVolatilityTermStructure'; upcast = qlCapFloorTermVolSurfaceAsVolatilityTermStructure}+instance Upcastable CCapFloorTermVolatilityStructure' where {type Base CCapFloorTermVolatilityStructure' = CVolatilityTermStructure'; upcast = qlCapFloorTermVolatilityStructureAsVolatilityTermStructure}+instance Upcastable CCapFloorTermVolCurve' where {type Base CCapFloorTermVolCurve' = CCapFloorTermVolatilityStructure'; upcast = qlCapFloorTermVolCurveAsCapFloorTermVolatilityStructure}+instance Upcastable CCapFloorTermVolSurface' where {type Base CCapFloorTermVolSurface' = CCapFloorTermVolatilityStructure'; upcast = qlCapFloorTermVolSurfaceAsCapFloorTermVolatilityStructure}+instance Upcastable CBlackAtmVolCurve' where {type Base CBlackAtmVolCurve' = CVolatilityTermStructure'; upcast = qlBlackAtmVolCurveAsVolatilityTermStructure}+instance Upcastable CBlackVolSurface' where {type Base CBlackVolSurface' = CBlackAtmVolCurve'; upcast = qlBlackVolSurfaceAsBlackAtmVolCurve}+instance Upcastable CAbcdAtmVolCurve' where {type Base CAbcdAtmVolCurve' = CBlackAtmVolCurve'; upcast = qlAbcdAtmVolCurveAsBlackAtmVolCurve}+instance Upcastable CSabrVolSurface' where {type Base CSabrVolSurface' = CBlackVolSurface'; upcast = qlSabrVolSurfaceAsBlackVolSurface} instance Upcastable CLocalVolTermStructure' where {type Base CLocalVolTermStructure' = CVolatilityTermStructure'; upcast = qlLocalVolTermStructureAsVolatilityTermStructure}+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 withTermStructure :: GenTermStructure t  -> (Ptr CTermStructure' -> IO b) -> IO b@@ -1205,10 +1559,44 @@ peekInterpolatedSwaptionVolatilityCube = newGenForeignPtr >=> newGenSwaptionVolatilityStructure withInterpolatedSwaptionVolatilityCube :: InterpolatedSwaptionVolatilityCube -> (Ptr CInterpolatedSwaptionVolatilityCube' -> IO b) -> IO b withInterpolatedSwaptionVolatilityCube = withForeignPtr . ptr . peel . peel . getTermStructure+peekCapFloorTermVolatilityStructure :: Ptr CCapFloorTermVolatilityStructure' -> IO CapFloorTermVolatilityStructure+peekCapFloorTermVolatilityStructure = newCastForeignPtr >=> newGenCapFloorTermVolatilityStructure+withGenCapFloorTermVolatilityStructure :: GenCapFloorTermVolatilityStructure c -> (Ptr CCapFloorTermVolatilityStructure' -> IO b) -> IO b+withGenCapFloorTermVolatilityStructure = withGenForeignPtr . peel . peel . getTermStructure+newGenCapFloorTermVolatilityStructure :: GenForeignPtr c CCapFloorTermVolatilityStructure' -> IO (GenCapFloorTermVolatilityStructure c)+newGenCapFloorTermVolatilityStructure = pure . GenTermStructure . newAnyOf . newAnyOf+peekCapFloorTermVolCurve :: Ptr CCapFloorTermVolCurve' -> IO CapFloorTermVolCurve+peekCapFloorTermVolCurve = newGenForeignPtr >=> newGenCapFloorTermVolatilityStructure+withCapFloorTermVolCurve :: CapFloorTermVolCurve -> (Ptr CCapFloorTermVolCurve' -> IO b) -> IO b+withCapFloorTermVolCurve = withForeignPtr . ptr . peel . peel . getTermStructure peekCapFloorTermVolSurface :: Ptr CCapFloorTermVolSurface' -> IO CapFloorTermVolSurface-peekCapFloorTermVolSurface = peekGenVolatilityTermStructure+peekCapFloorTermVolSurface = newGenForeignPtr >=> newGenCapFloorTermVolatilityStructure+withCapFloorTermVolSurface :: CapFloorTermVolSurface -> (Ptr CCapFloorTermVolSurface' -> IO b) -> IO b+withCapFloorTermVolSurface = withForeignPtr . ptr . peel . peel . getTermStructure+peekBlackAtmVolCurve :: Ptr CBlackAtmVolCurve' -> IO BlackAtmVolCurve+peekBlackAtmVolCurve = newCastForeignPtr >=> newGenBlackAtmVolCurve+withGenBlackAtmVolCurve :: GenBlackAtmVolCurve b -> (Ptr CBlackAtmVolCurve' -> IO r) -> IO r+withGenBlackAtmVolCurve = withGenForeignPtr . peel . peel . getTermStructure+newGenBlackAtmVolCurve :: GenForeignPtr b CBlackAtmVolCurve' -> IO (GenBlackAtmVolCurve b)+newGenBlackAtmVolCurve = pure . GenTermStructure . newAnyOf . newAnyOf+peekAbcdAtmVolCurve :: Ptr CAbcdAtmVolCurve' -> IO AbcdAtmVolCurve+peekAbcdAtmVolCurve = newGenForeignPtr >=> newGenBlackAtmVolCurve+withAbcdAtmVolCurve :: AbcdAtmVolCurve -> (Ptr CAbcdAtmVolCurve' -> IO b) -> IO b+withAbcdAtmVolCurve = withForeignPtr . ptr . peel . peel . getTermStructure+withGenBlackVolSurface :: GenBlackVolSurface b -> (Ptr CBlackVolSurface' -> IO r) -> IO r+withGenBlackVolSurface = withGenForeignPtr . peel . peel . peel . getTermStructure+newGenBlackVolSurface :: GenForeignPtr b CBlackVolSurface' -> IO (GenBlackVolSurface b)+newGenBlackVolSurface = pure . GenTermStructure . newAnyOf . newAnyOf . newAnyOf+peekSabrVolSurface :: Ptr CSabrVolSurface' -> IO SabrVolSurface+peekSabrVolSurface = newGenForeignPtr >=> newGenBlackVolSurface+withSabrVolSurface :: SabrVolSurface -> (Ptr CSabrVolSurface' -> IO b) -> IO b+withSabrVolSurface = withForeignPtr . ptr . peel . peel . peel . getTermStructure peekLocalVolTermStructure :: Ptr CLocalVolTermStructure' -> IO LocalVolTermStructure peekLocalVolTermStructure = peekGenVolatilityTermStructure+peekYoYOptionletVolatilityStructure :: Ptr CYoYOptionletVolatilitySurface' -> IO YoYOptionletVolatilitySurface+peekYoYOptionletVolatilityStructure = peekGenVolatilityTermStructure+peekCPIVolatilitySurface :: Ptr CCPIVolatilitySurface' -> IO CPIVolatilitySurface+peekCPIVolatilitySurface = peekGenVolatilityTermStructure withLocalVolTermStructure :: LocalVolTermStructure -> (Ptr CLocalVolTermStructure' -> IO b) -> IO b withLocalVolTermStructure = withGenVolatilityTermStructure withMaybeLocalVolTermStructure :: Maybe LocalVolTermStructure -> (Ptr CLocalVolTermStructure' -> IO b) -> IO b@@ -1227,6 +1615,21 @@ peekYoYInflationTermStructure = GenTermStructure <.> newGenForeignPtr withMaybeYoYInflationTermStructure :: Maybe YoYInflationTermStructure -> (Ptr CYoYInflationTermStructure' -> IO b) -> IO b withMaybeYoYInflationTermStructure x f = maybe (f nullPtr) (`withGenTermStructure` f) x+peekYoYCapFloorTermPriceSurface :: Ptr CYoYCapFloorTermPriceSurface' -> IO YoYCapFloorTermPriceSurface+peekYoYCapFloorTermPriceSurface = GenTermStructure <.> newGenForeignPtr+peekCPICapFloorTermPriceSurface :: Ptr CCPICapFloorTermPriceSurface' -> IO CPICapFloorTermPriceSurface+peekCPICapFloorTermPriceSurface = GenTermStructure <.> newGenForeignPtr+peekCommodityCurve :: Ptr CCommodityCurve' -> IO CommodityCurve+peekCommodityCurve = GenTermStructure <.> newGenForeignPtr+withMaybeCommodityCurve :: Maybe CommodityCurve -> (Ptr CCommodityCurve' -> IO b) -> IO b+withMaybeCommodityCurve x f = maybe (f nullPtr) (`withGenTermStructure` f) x+-- |Peek a possibly-null @CommodityCurve*@ -- @basisOfCurve_@ is a @nullptr@ 'shared_ptr' when no+-- basis curve has been set via 'QuantLib.TermStructure.Commodity.setCommodityCurveBasisOfCurve',+-- not an empty-'Data'-style placeholder (unlike 'peekMaybeCommodityType' et al.).+peekMaybeCommodityCurve :: Ptr CCommodityCurve' -> IO (Maybe CommodityCurve)+peekMaybeCommodityCurve p+  | p == nullPtr = pure Nothing+  | otherwise = Just <$> peekCommodityCurve p  asYieldTermStructure :: GenYieldTermStructure y -> IO YieldTermStructure asYieldTermStructure = transferGenForeignPtr peekYieldTermStructure . peel . getTermStructure@@ -1676,24 +2079,26 @@ foreign import ccall "ql.h qlG2AsAffineModel" qlG2AsAffineModel :: Ptr CG2' -> IO (Ptr CAffineModel') foreign import ccall "ql.h qlHullWhiteAsAffineModel" qlHullWhiteAsAffineModel :: Ptr CHullWhite' -> IO (Ptr CAffineModel') -data AffineModel = HullWhite HullWhite | G2 G2 | OneFactorAffineModel OneFactorAffineModel | LiborForwardModel LiborForwardModel-withUpcast :: Finalizable b => (Ptr a -> IO (Ptr b)) -> (Ptr b -> IO r) -> Ptr a -> IO r-withUpcast up f p = bracket (up p) freeUpcast f-withAffineModel :: AffineModel -> (Ptr CAffineModel' -> IO b) -> IO b-withAffineModel (HullWhite m) f = withHullWhite m (withUpcast qlHullWhiteAsAffineModel f)-withAffineModel (G2 m) f = withG2 m (withUpcast qlG2AsAffineModel f)-withAffineModel (OneFactorAffineModel m) f = withOneFactorAffineModel m (withUpcast qlOneFactorAffineModelAsAffineModel f)-withAffineModel (LiborForwardModel m) f = withGenCalibratedModel m (withUpcast qlLiborForwardModelAsAffineModel f)+type AffineModel = Standalone CAffineModel'+hullWhiteAsAffineModel :: HullWhite -> IO AffineModel+hullWhiteAsAffineModel m = withHullWhite m qlHullWhiteAsAffineModel >>= peekStandalone+g2AsAffineModel :: G2 -> IO AffineModel+g2AsAffineModel m = withG2 m qlG2AsAffineModel >>= peekStandalone+oneFactorAffineModelAsAffineModel :: OneFactorAffineModel -> IO AffineModel+oneFactorAffineModelAsAffineModel m = withOneFactorAffineModel m qlOneFactorAffineModelAsAffineModel >>= peekStandalone+liborForwardModelAsAffineModel :: LiborForwardModel -> IO AffineModel+liborForwardModelAsAffineModel m = withGenCalibratedModel m qlLiborForwardModelAsAffineModel >>= peekStandalone  data CGaussian1dModel' foreign import ccall unsafe "ql.h &qlFreeGaussian1dModel" qlFreeGaussian1dModel :: FinalizerPtr CGaussian1dModel' instance Finalizable CGaussian1dModel' where finalize = qlFreeGaussian1dModel foreign import ccall "ql.h qlGsrAsGaussian1dModel" qlGsrAsGaussian1dModel :: Ptr CGsr' -> IO (Ptr CGaussian1dModel') foreign import ccall "ql.h qlMarkovFunctionalAsGaussian1dModel" qlMarkovFunctionalAsGaussian1dModel :: Ptr CMarkovFunctional' -> IO (Ptr CGaussian1dModel')-data Gaussian1dModel = Gsr Gsr | MarkovFunctional MarkovFunctional-withGaussian1dModel :: Gaussian1dModel -> (Ptr CGaussian1dModel' -> IO b) -> IO b-withGaussian1dModel (Gsr m) f = withGenCalibratedModel m (withUpcast qlGsrAsGaussian1dModel f)-withGaussian1dModel (MarkovFunctional m) f = withGenCalibratedModel m (withUpcast qlMarkovFunctionalAsGaussian1dModel f)+type Gaussian1dModel = Standalone CGaussian1dModel'+gsrAsGaussian1dModel :: Gsr -> IO Gaussian1dModel+gsrAsGaussian1dModel m = withGenCalibratedModel m qlGsrAsGaussian1dModel >>= peekStandalone+markovFunctionalAsGaussian1dModel :: MarkovFunctional -> IO Gaussian1dModel+markovFunctionalAsGaussian1dModel m = withGenCalibratedModel m qlMarkovFunctionalAsGaussian1dModel >>= peekStandalone  -- | > Instrument* -- >  Forward*@@ -1709,13 +2114,19 @@ -- >    OneAssetOption -- >      BarrierOption -- >      DoubleBarrierOption+-- >      SoftBarrierOption -- >      VanillaOption -- >      QuantoVanillaOption -- >      QuantoForwardVanillaOption -- >      QuantoBarrierOption -- >    Swaption+-- >    NonstandardSwaption+-- >    FloatFloatSwaption -- >  Swap*--- >    VanillaSwap+-- >    FixedVsFloatingSwap*+-- >      VanillaSwap+-- >    NonstandardSwap+-- >    FloatFloatSwap -- >    AssetSwap -- >    BMASwap -- >    OvernightIndexedSwap@@ -1724,13 +2135,24 @@ -- >    CPISwap -- >    ZeroCouponSwap -- >    EquityTotalReturnSwap+-- >    ConstNotionalCrossCurrencySwap+-- >      ConstNotionalCrossCurrencyBasisSwap+-- >      ConstNotionalCrossCurrencyFixedVsFloatingSwap -- >  CreditDefaultSwap -- >  CapFloor+-- >  YoYInflationCapFloor+-- >  CPICapFloor -- >  Bond -- >    ConvertibleBond -- >    FixedRateBond -- >    CallableBond -- >    CPIBond+-- >  Commodity*+-- >    EnergyCommodity*+-- >      EnergyFuture+-- >      EnergySwap*+-- >        EnergyVanillaSwap+-- >        EnergyBasisSwap type Instrument = GenInstrument CInstrument data CInstrument' newtype GenInstrument i = GenInstrument {getInstrument :: GenForeignPtr i CInstrument'}@@ -1806,6 +2228,35 @@ peekCapFloor :: Ptr CCapFloor' -> IO CapFloor peekCapFloor = GenInstrument <.> newGenForeignPtr +data CYoYInflationCapFloor'+type CYoYInflationCapFloor = ForeignPtr CYoYInflationCapFloor'+-- | A YoY-inflation cap\/floor\/collar (all three are thin ctor-only subclasses upstream with+-- no logic of their own, so 'QuantLib.Instrument.InflationCapFloor.yoyInflationCap'\/+-- 'yoyInflationCollar'\/'yoyInflationFloor' each construct this one flat leaf directly, mirroring+-- how 'CapFloor' collapses @Cap@\/@Collar@\/@Floor@). Unlike 'CapFloor', it shares no C++ base+-- below 'Instrument' with the nominal cap/floor, so it's a separate sibling leaf, not a subtype.+type YoYInflationCapFloor = GenInstrument CYoYInflationCapFloor+foreign import ccall unsafe "ql.h &qlFreeYoYInflationCapFloor" qlFreeYoYInflationCapFloor :: FinalizerPtr CYoYInflationCapFloor'+instance Finalizable CYoYInflationCapFloor' where finalize = qlFreeYoYInflationCapFloor+foreign import ccall "ql.h qlYoYInflationCapFloorAsInstrument" qlYoYInflationCapFloorAsInstrument :: Ptr CYoYInflationCapFloor' -> IO (Ptr CInstrument')+instance Upcastable CYoYInflationCapFloor' where {type Base CYoYInflationCapFloor' = CInstrument'; upcast = qlYoYInflationCapFloorAsInstrument}+peekYoYInflationCapFloor :: Ptr CYoYInflationCapFloor' -> IO YoYInflationCapFloor+peekYoYInflationCapFloor = GenInstrument <.> newGenForeignPtr++data CCPICapFloor'+type CCPICapFloor = ForeignPtr CCPICapFloor'+-- | A CPI cap\/floor: unlike 'YoYInflationCapFloor', a single cumulative option (observes+-- cumulative inflation up to maturity, like a ZCIIS option) rather than a strip of optionlets --+-- flat sibling leaf under 'Instrument', sharing no C++ base with either 'CapFloor' or+-- 'YoYInflationCapFloor'.+type CPICapFloor = GenInstrument CCPICapFloor+foreign import ccall unsafe "ql.h &qlFreeCPICapFloor" qlFreeCPICapFloor :: FinalizerPtr CCPICapFloor'+instance Finalizable CCPICapFloor' where finalize = qlFreeCPICapFloor+foreign import ccall "ql.h qlCPICapFloorAsInstrument" qlCPICapFloorAsInstrument :: Ptr CCPICapFloor' -> IO (Ptr CInstrument')+instance Upcastable CCPICapFloor' where {type Base CCPICapFloor' = CInstrument'; upcast = qlCPICapFloorAsInstrument}+peekCPICapFloor :: Ptr CCPICapFloor' -> IO CPICapFloor+peekCPICapFloor = GenInstrument <.> newGenForeignPtr+ data CForward' type GenForward f = GenInstrument (AnyOf CForward' f) type CForward = ForeignPtr CForward'@@ -1950,18 +2401,114 @@ 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+-- 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 --+-- binding them generically over 'GenFixedVsFloatingSwap' avoids a cast to reach them from that+-- getter's result. FixedVsFloatingSwap itself is abstract upstream (pure virtual+-- setupFloatingArguments), so hasquant binds no constructor for it directly.+data CFixedVsFloatingSwap'+type GenFixedVsFloatingSwap f = GenSwap (AnyOf CFixedVsFloatingSwap' f)+type CFixedVsFloatingSwap = ForeignPtr CFixedVsFloatingSwap'+type FixedVsFloatingSwap = GenFixedVsFloatingSwap CFixedVsFloatingSwap data CVanillaSwap' type CVanillaSwap = ForeignPtr CVanillaSwap'-type VanillaSwap = GenSwap CVanillaSwap+type VanillaSwap = GenFixedVsFloatingSwap CVanillaSwap+foreign import ccall unsafe "ql.h &qlFreeFixedVsFloatingSwap" qlFreeFixedVsFloatingSwap :: FinalizerPtr CFixedVsFloatingSwap' foreign import ccall unsafe "ql.h &qlFreeVanillaSwap" qlFreeVanillaSwap :: FinalizerPtr CVanillaSwap'+instance Finalizable CFixedVsFloatingSwap' where finalize = qlFreeFixedVsFloatingSwap instance Finalizable CVanillaSwap' where finalize = qlFreeVanillaSwap-foreign import ccall "ql.h qlVanillaSwapAsSwap" qlVanillaSwapAsSwap :: Ptr CVanillaSwap' -> IO (Ptr CSwap')-instance Upcastable CVanillaSwap' where {type Base CVanillaSwap' = CSwap'; upcast = qlVanillaSwapAsSwap}+foreign import ccall "ql.h qlFixedVsFloatingSwapAsSwap" qlFixedVsFloatingSwapAsSwap :: Ptr CFixedVsFloatingSwap' -> IO (Ptr CSwap')+foreign import ccall "ql.h qlVanillaSwapAsFixedVsFloatingSwap" qlVanillaSwapAsFixedVsFloatingSwap :: Ptr CVanillaSwap' -> IO (Ptr CFixedVsFloatingSwap')+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+peekFixedVsFloatingSwap :: Ptr CFixedVsFloatingSwap' -> IO FixedVsFloatingSwap+peekFixedVsFloatingSwap = newCastForeignPtr >=> newGenFixedVsFloatingSwap+withFixedVsFloatingSwap :: GenFixedVsFloatingSwap f -> (Ptr CFixedVsFloatingSwap' -> IO b) -> IO b+withFixedVsFloatingSwap = withGenForeignPtr . peel . peel . getInstrument+newGenFixedVsFloatingSwap :: GenForeignPtr f CFixedVsFloatingSwap' -> IO (GenFixedVsFloatingSwap f)+newGenFixedVsFloatingSwap = pure . GenInstrument . newAnyOf . newAnyOf peekVanillaSwap :: Ptr CVanillaSwap' -> IO VanillaSwap-peekVanillaSwap = peekGenSwap+peekVanillaSwap = newGenForeignPtr >=> newGenFixedVsFloatingSwap withVanillaSwap :: VanillaSwap -> (Ptr CVanillaSwap' -> IO b) -> IO b-withVanillaSwap = withForeignPtr . ptr . peel . getInstrument+withVanillaSwap = withForeignPtr . ptr . peel . peel . getInstrument +-- ConstNotionalCrossCurrencySwap sits between Swap and its two owned leaves+-- (ConstNotionalCrossCurrencyBasisSwap, ConstNotionalCrossCurrencyFixedVsFloatingSwap). It earns+-- its own family level (mirrors FixedVsFloatingSwap/VanillaSwap just above) because its own+-- getters (legCurrency, inCcyLegBPS, inCcyLegNPV, npvDateDiscounts) are inherited by both leaves+-- and are bound generically over 'GenConstNotionalCrossCurrencySwap', while each leaf keeps its+-- 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 CConstNotionalCrossCurrencySwap'+type GenConstNotionalCrossCurrencySwap x = GenSwap (AnyOf CConstNotionalCrossCurrencySwap' x)+type CConstNotionalCrossCurrencySwap = ForeignPtr CConstNotionalCrossCurrencySwap'+type ConstNotionalCrossCurrencySwap = GenConstNotionalCrossCurrencySwap CConstNotionalCrossCurrencySwap+data CConstNotionalCrossCurrencyBasisSwap'+type CConstNotionalCrossCurrencyBasisSwap = ForeignPtr CConstNotionalCrossCurrencyBasisSwap'+type ConstNotionalCrossCurrencyBasisSwap = GenConstNotionalCrossCurrencySwap CConstNotionalCrossCurrencyBasisSwap+data CConstNotionalCrossCurrencyFixedVsFloatingSwap'+type CConstNotionalCrossCurrencyFixedVsFloatingSwap = ForeignPtr CConstNotionalCrossCurrencyFixedVsFloatingSwap'+type ConstNotionalCrossCurrencyFixedVsFloatingSwap = GenConstNotionalCrossCurrencySwap CConstNotionalCrossCurrencyFixedVsFloatingSwap+foreign import ccall unsafe "ql.h &qlFreeConstNotionalCrossCurrencySwap" qlFreeConstNotionalCrossCurrencySwap :: FinalizerPtr CConstNotionalCrossCurrencySwap'+foreign import ccall unsafe "ql.h &qlFreeConstNotionalCrossCurrencyBasisSwap" qlFreeConstNotionalCrossCurrencyBasisSwap :: FinalizerPtr CConstNotionalCrossCurrencyBasisSwap'+foreign import ccall unsafe "ql.h &qlFreeConstNotionalCrossCurrencyFixedVsFloatingSwap" qlFreeConstNotionalCrossCurrencyFixedVsFloatingSwap :: FinalizerPtr CConstNotionalCrossCurrencyFixedVsFloatingSwap'+instance Finalizable CConstNotionalCrossCurrencySwap' where finalize = qlFreeConstNotionalCrossCurrencySwap+instance Finalizable CConstNotionalCrossCurrencyBasisSwap' where finalize = qlFreeConstNotionalCrossCurrencyBasisSwap+instance Finalizable CConstNotionalCrossCurrencyFixedVsFloatingSwap' where finalize = qlFreeConstNotionalCrossCurrencyFixedVsFloatingSwap+foreign import ccall "ql.h qlConstNotionalCrossCurrencySwapAsSwap" qlConstNotionalCrossCurrencySwapAsSwap :: Ptr CConstNotionalCrossCurrencySwap' -> IO (Ptr CSwap')+foreign import ccall "ql.h qlConstNotionalCrossCurrencyBasisSwapAsConstNotionalCrossCurrencySwap" qlConstNotionalCrossCurrencyBasisSwapAsConstNotionalCrossCurrencySwap :: Ptr CConstNotionalCrossCurrencyBasisSwap' -> IO (Ptr CConstNotionalCrossCurrencySwap')+foreign import ccall "ql.h qlConstNotionalCrossCurrencyFixedVsFloatingSwapAsConstNotionalCrossCurrencySwap" qlConstNotionalCrossCurrencyFixedVsFloatingSwapAsConstNotionalCrossCurrencySwap :: Ptr CConstNotionalCrossCurrencyFixedVsFloatingSwap' -> IO (Ptr CConstNotionalCrossCurrencySwap')+instance Upcastable CConstNotionalCrossCurrencySwap' where {type Base CConstNotionalCrossCurrencySwap' = CSwap'; upcast = qlConstNotionalCrossCurrencySwapAsSwap}+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+peekConstNotionalCrossCurrencySwap :: Ptr CConstNotionalCrossCurrencySwap' -> IO ConstNotionalCrossCurrencySwap+peekConstNotionalCrossCurrencySwap = newCastForeignPtr >=> newGenConstNotionalCrossCurrencySwap+withConstNotionalCrossCurrencySwap :: GenConstNotionalCrossCurrencySwap x -> (Ptr CConstNotionalCrossCurrencySwap' -> IO b) -> IO b+withConstNotionalCrossCurrencySwap = withGenForeignPtr . peel . peel . getInstrument+newGenConstNotionalCrossCurrencySwap :: GenForeignPtr x CConstNotionalCrossCurrencySwap' -> IO (GenConstNotionalCrossCurrencySwap x)+newGenConstNotionalCrossCurrencySwap = pure . GenInstrument . newAnyOf . newAnyOf+peekConstNotionalCrossCurrencyBasisSwap :: Ptr CConstNotionalCrossCurrencyBasisSwap' -> IO ConstNotionalCrossCurrencyBasisSwap+peekConstNotionalCrossCurrencyBasisSwap = newGenForeignPtr >=> newGenConstNotionalCrossCurrencySwap+withConstNotionalCrossCurrencyBasisSwap :: ConstNotionalCrossCurrencyBasisSwap -> (Ptr CConstNotionalCrossCurrencyBasisSwap' -> IO b) -> IO b+withConstNotionalCrossCurrencyBasisSwap = withForeignPtr . ptr . peel . peel . getInstrument+peekConstNotionalCrossCurrencyFixedVsFloatingSwap :: Ptr CConstNotionalCrossCurrencyFixedVsFloatingSwap' -> IO ConstNotionalCrossCurrencyFixedVsFloatingSwap+peekConstNotionalCrossCurrencyFixedVsFloatingSwap = newGenForeignPtr >=> newGenConstNotionalCrossCurrencySwap+withConstNotionalCrossCurrencyFixedVsFloatingSwap :: ConstNotionalCrossCurrencyFixedVsFloatingSwap -> (Ptr CConstNotionalCrossCurrencyFixedVsFloatingSwap' -> IO b) -> IO b+withConstNotionalCrossCurrencyFixedVsFloatingSwap = withForeignPtr . ptr . peel . peel . getInstrument++data CNonstandardSwap'+type CNonstandardSwap = ForeignPtr CNonstandardSwap'+type NonstandardSwap = GenSwap CNonstandardSwap+foreign import ccall unsafe "ql.h &qlFreeNonstandardSwap" qlFreeNonstandardSwap :: FinalizerPtr CNonstandardSwap'+instance Finalizable CNonstandardSwap' where finalize = qlFreeNonstandardSwap+foreign import ccall "ql.h qlNonstandardSwapAsSwap" qlNonstandardSwapAsSwap :: Ptr CNonstandardSwap' -> IO (Ptr CSwap')+instance Upcastable CNonstandardSwap' where {type Base CNonstandardSwap' = CSwap'; upcast = qlNonstandardSwapAsSwap}+peekNonstandardSwap :: Ptr CNonstandardSwap' -> IO NonstandardSwap+peekNonstandardSwap = peekGenSwap+withNonstandardSwap :: NonstandardSwap -> (Ptr CNonstandardSwap' -> IO b) -> IO b+withNonstandardSwap = withForeignPtr . ptr . peel . getInstrument++data CFloatFloatSwap'+type CFloatFloatSwap = ForeignPtr CFloatFloatSwap'+type FloatFloatSwap = GenSwap CFloatFloatSwap+foreign import ccall unsafe "ql.h &qlFreeFloatFloatSwap" qlFreeFloatFloatSwap :: FinalizerPtr CFloatFloatSwap'+instance Finalizable CFloatFloatSwap' where finalize = qlFreeFloatFloatSwap+foreign import ccall "ql.h qlFloatFloatSwapAsSwap" qlFloatFloatSwapAsSwap :: Ptr CFloatFloatSwap' -> IO (Ptr CSwap')+instance Upcastable CFloatFloatSwap' where {type Base CFloatFloatSwap' = CSwap'; upcast = qlFloatFloatSwapAsSwap}+peekFloatFloatSwap :: Ptr CFloatFloatSwap' -> IO FloatFloatSwap+peekFloatFloatSwap = peekGenSwap+withFloatFloatSwap :: FloatFloatSwap -> (Ptr CFloatFloatSwap' -> IO b) -> IO b+withFloatFloatSwap = withForeignPtr . ptr . peel . getInstrument+ data CAssetSwap' type CAssetSwap = ForeignPtr CAssetSwap' type AssetSwap = GenSwap CAssetSwap@@ -2082,6 +2629,30 @@ withSwaption :: Swaption -> (Ptr CSwaption' -> IO b) -> IO b withSwaption = withForeignPtr . ptr . peel . getInstrument +data CNonstandardSwaption'+type CNonstandardSwaption = ForeignPtr CNonstandardSwaption'+type NonstandardSwaption = GenOption CNonstandardSwaption+foreign import ccall unsafe "ql.h &qlFreeNonstandardSwaption" qlFreeNonstandardSwaption :: FinalizerPtr CNonstandardSwaption'+instance Finalizable CNonstandardSwaption' where finalize = qlFreeNonstandardSwaption+foreign import ccall "ql.h qlNonstandardSwaptionAsOption" qlNonstandardSwaptionAsOption :: Ptr CNonstandardSwaption' -> IO (Ptr COption')+instance Upcastable CNonstandardSwaption' where {type Base CNonstandardSwaption' = COption'; upcast = qlNonstandardSwaptionAsOption}+peekNonstandardSwaption :: Ptr CNonstandardSwaption' -> IO NonstandardSwaption+peekNonstandardSwaption = peekGenOption+withNonstandardSwaption :: NonstandardSwaption -> (Ptr CNonstandardSwaption' -> IO b) -> IO b+withNonstandardSwaption = withForeignPtr . ptr . peel . getInstrument++data CFloatFloatSwaption'+type CFloatFloatSwaption = ForeignPtr CFloatFloatSwaption'+type FloatFloatSwaption = GenOption CFloatFloatSwaption+foreign import ccall unsafe "ql.h &qlFreeFloatFloatSwaption" qlFreeFloatFloatSwaption :: FinalizerPtr CFloatFloatSwaption'+instance Finalizable CFloatFloatSwaption' where finalize = qlFreeFloatFloatSwaption+foreign import ccall "ql.h qlFloatFloatSwaptionAsOption" qlFloatFloatSwaptionAsOption :: Ptr CFloatFloatSwaption' -> IO (Ptr COption')+instance Upcastable CFloatFloatSwaption' where {type Base CFloatFloatSwaption' = COption'; upcast = qlFloatFloatSwaptionAsOption}+peekFloatFloatSwaption :: Ptr CFloatFloatSwaption' -> IO FloatFloatSwaption+peekFloatFloatSwaption = peekGenOption+withFloatFloatSwaption :: FloatFloatSwaption -> (Ptr CFloatFloatSwaption' -> IO b) -> IO b+withFloatFloatSwaption = withForeignPtr . ptr . peel . getInstrument+ data CMultiAssetOption' data CMargrabeOption' type GenMultiAssetOption mo = GenOption (AnyOf CMultiAssetOption' mo)@@ -2140,6 +2711,18 @@ withBarrierOption :: BarrierOption -> (Ptr CBarrierOption' -> IO b) -> IO b withBarrierOption = withForeignPtr . ptr . peel . peel . getInstrument +data CSoftBarrierOption'+type CSoftBarrierOption = ForeignPtr CSoftBarrierOption'+type SoftBarrierOption = GenOneAssetOption CSoftBarrierOption+foreign import ccall unsafe "ql.h &qlFreeSoftBarrierOption" qlFreeSoftBarrierOption :: FinalizerPtr CSoftBarrierOption'+instance Finalizable CSoftBarrierOption' where finalize = qlFreeSoftBarrierOption+foreign import ccall "ql.h qlSoftBarrierOptionAsOneAssetOption" qlSoftBarrierOptionAsOneAssetOption :: Ptr CSoftBarrierOption' -> IO (Ptr COneAssetOption')+instance Upcastable CSoftBarrierOption' where {type Base CSoftBarrierOption' = COneAssetOption'; upcast = qlSoftBarrierOptionAsOneAssetOption}+peekSoftBarrierOption :: Ptr CSoftBarrierOption' -> IO SoftBarrierOption+peekSoftBarrierOption = newGenForeignPtr >=> newGenOneAssetOption+withSoftBarrierOption :: SoftBarrierOption -> (Ptr CSoftBarrierOption' -> IO b) -> IO b+withSoftBarrierOption = withForeignPtr . ptr . peel . peel . getInstrument+ data CDoubleBarrierOption' type CDoubleBarrierOption = ForeignPtr CDoubleBarrierOption' type DoubleBarrierOption = GenOneAssetOption CDoubleBarrierOption@@ -2199,6 +2782,134 @@ peekQuantoBarrierOption = newGenForeignPtr >=> newGenOneAssetOption withQuantoBarrierOption :: QuantoBarrierOption -> (Ptr CQuantoBarrierOption' -> IO b) -> IO b withQuantoBarrierOption = 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.+data CCommodity'+type GenCommodity c = GenInstrument (AnyOf CCommodity' c)+type CCommodity = ForeignPtr CCommodity'+type Commodity = GenCommodity CCommodity+foreign import ccall unsafe "ql.h &qlFreeCommodity" qlFreeCommodity :: FinalizerPtr CCommodity'+instance Finalizable CCommodity' where finalize = qlFreeCommodity+foreign import ccall "ql.h qlCommodityAsInstrument" qlCommodityAsInstrument :: Ptr CCommodity' -> IO (Ptr CInstrument')+instance Upcastable CCommodity' where {type Base CCommodity' = CInstrument'; upcast = qlCommodityAsInstrument}++data CEnergyCommodity'+type GenEnergyCommodity e = GenCommodity (AnyOf CEnergyCommodity' e)+type CEnergyCommodity = ForeignPtr CEnergyCommodity'+type EnergyCommodity = GenEnergyCommodity CEnergyCommodity+foreign import ccall unsafe "ql.h &qlFreeEnergyCommodity" qlFreeEnergyCommodity :: FinalizerPtr CEnergyCommodity'+instance Finalizable CEnergyCommodity' where finalize = qlFreeEnergyCommodity+foreign import ccall "ql.h qlEnergyCommodityAsCommodity" qlEnergyCommodityAsCommodity :: Ptr CEnergyCommodity' -> IO (Ptr CCommodity')+instance Upcastable CEnergyCommodity' where {type Base CEnergyCommodity' = CCommodity'; upcast = qlEnergyCommodityAsCommodity}++-- |Generalizes 'Commodity's base-level getters (secondaryCostAmounts, pricingErrors,+-- addPricingError) across every leaf in the Commodity\/EnergyCommodity\/EnergySwap subtree -- the+-- same move as 'withFixedVsFloatingSwap' generalizing its own base-level getters. One peel:+-- Commodity is the (only, so far) 'AnyOf' layer directly under 'GenInstrument' here.+withCommodity :: GenCommodity c -> (Ptr CCommodity' -> IO b) -> IO b+withCommodity = withGenForeignPtr . peel . getInstrument++-- |'newGenEnergyCommodity' wraps the 2 'AnyOf' layers (Commodity, EnergyCommodity) shared by every+-- 'EnergyCommodity' leaf -- the same helper role 'newGenFixedVsFloatingSwap' plays for 'VanillaSwap'.+newGenEnergyCommodity :: GenForeignPtr e CEnergyCommodity' -> IO (GenEnergyCommodity e)+newGenEnergyCommodity = pure . GenInstrument . newAnyOf . newAnyOf++-- |Generalizes 'EnergyCommodity's one pure-virtual interface method, @quantity()@, across every+-- leaf (EnergyFuture, EnergyVanillaSwap, EnergyBasisSwap): one shim, dispatched virtually on the+-- C++ side, rather than a per-leaf binding -- EnergyFuture's own override is a plain echo of its+-- constructor argument, but EnergySwap's is a real computed sum over its pricing periods+-- (energyswap.cpp), so the binding as a whole is not a redundant echo even though one leaf's+-- override happens to be.+withEnergyCommodity :: GenEnergyCommodity e -> (Ptr CEnergyCommodity' -> IO b) -> IO b+withEnergyCommodity = withGenForeignPtr . peel . peel . getInstrument++-- |'EnergyFuture': a leaf directly under 'EnergyCommodity' (Stage 6). 2 peels reach+-- 'CEnergyFuture'' -- through the Commodity and EnergyCommodity layers -- the same depth+-- 'VanillaSwap' needs under 'GenFixedVsFloatingSwap' (Swap + FixedVsFloatingSwap).+data CEnergyFuture'+type CEnergyFuture = ForeignPtr CEnergyFuture'+type EnergyFuture = GenEnergyCommodity CEnergyFuture+foreign import ccall unsafe "ql.h &qlFreeEnergyFuture" qlFreeEnergyFuture :: FinalizerPtr CEnergyFuture'+instance Finalizable CEnergyFuture' where finalize = qlFreeEnergyFuture+foreign import ccall "ql.h qlEnergyFutureAsEnergyCommodity" qlEnergyFutureAsEnergyCommodity :: Ptr CEnergyFuture' -> IO (Ptr CEnergyCommodity')+instance Upcastable CEnergyFuture' where {type Base CEnergyFuture' = CEnergyCommodity'; upcast = qlEnergyFutureAsEnergyCommodity}+peekEnergyFuture :: Ptr CEnergyFuture' -> IO EnergyFuture+peekEnergyFuture = newGenForeignPtr >=> newGenEnergyCommodity+withEnergyFuture :: EnergyFuture -> (Ptr CEnergyFuture' -> IO b) -> IO b+withEnergyFuture = withForeignPtr . ptr . peel . peel . getInstrument++-- |'EnergySwap' is abstract-here: it binds a public constructor upstream, but never overrides+-- 'performCalculations', so calling it directly falls through to 'Instrument's null-engine+-- @QL_REQUIRE@ and throws -- reachable only as an upcast target from 'EnergyVanillaSwap'\/+-- 'EnergyBasisSwap', exactly like 'FixedVsFloatingSwap'\/'VanillaSwap'. Its own accessors+-- (calendar, payCurrency, receiveCurrency, pricingPeriods, dailyPositions, paymentCashFlows,+-- commodityType, quantity) are bound generically over 'GenEnergySwap' in+-- 'QuantLib.Instrument.Energy' so both leaves inherit them for free, mirroring+-- 'GenFixedVsFloatingSwap's fairRate\/fixedLeg*\/floatingLeg* getters.+data CEnergySwap'+type GenEnergySwap s = GenEnergyCommodity (AnyOf CEnergySwap' s)+type CEnergySwap = ForeignPtr CEnergySwap'+type EnergySwap = GenEnergySwap CEnergySwap+foreign import ccall unsafe "ql.h &qlFreeEnergySwap" qlFreeEnergySwap :: FinalizerPtr CEnergySwap'+instance Finalizable CEnergySwap' where finalize = qlFreeEnergySwap+foreign import ccall "ql.h qlEnergySwapAsEnergyCommodity" qlEnergySwapAsEnergyCommodity :: Ptr CEnergySwap' -> IO (Ptr CEnergyCommodity')+instance Upcastable CEnergySwap' where {type Base CEnergySwap' = CEnergyCommodity'; upcast = qlEnergySwapAsEnergyCommodity}+newGenEnergySwap :: GenForeignPtr s CEnergySwap' -> IO (GenEnergySwap s)+newGenEnergySwap = pure . GenInstrument . newAnyOf . newAnyOf . newAnyOf+withEnergySwap :: GenEnergySwap s -> (Ptr CEnergySwap' -> IO b) -> IO b+withEnergySwap = withGenForeignPtr . peel . peel . peel . getInstrument++data CEnergyVanillaSwap'+type CEnergyVanillaSwap = ForeignPtr CEnergyVanillaSwap'+type EnergyVanillaSwap = GenEnergySwap CEnergyVanillaSwap+foreign import ccall unsafe "ql.h &qlFreeEnergyVanillaSwap" qlFreeEnergyVanillaSwap :: FinalizerPtr CEnergyVanillaSwap'+instance Finalizable CEnergyVanillaSwap' where finalize = qlFreeEnergyVanillaSwap+foreign import ccall "ql.h qlEnergyVanillaSwapAsEnergySwap" qlEnergyVanillaSwapAsEnergySwap :: Ptr CEnergyVanillaSwap' -> IO (Ptr CEnergySwap')+instance Upcastable CEnergyVanillaSwap' where {type Base CEnergyVanillaSwap' = CEnergySwap'; upcast = qlEnergyVanillaSwapAsEnergySwap}+peekEnergyVanillaSwap :: Ptr CEnergyVanillaSwap' -> IO EnergyVanillaSwap+peekEnergyVanillaSwap = newGenForeignPtr >=> newGenEnergySwap+withEnergyVanillaSwap :: EnergyVanillaSwap -> (Ptr CEnergyVanillaSwap' -> IO b) -> IO b+withEnergyVanillaSwap = withForeignPtr . ptr . peel . peel . peel . getInstrument++data CEnergyBasisSwap'+type CEnergyBasisSwap = ForeignPtr CEnergyBasisSwap'+type EnergyBasisSwap = GenEnergySwap CEnergyBasisSwap+foreign import ccall unsafe "ql.h &qlFreeEnergyBasisSwap" qlFreeEnergyBasisSwap :: FinalizerPtr CEnergyBasisSwap'+instance Finalizable CEnergyBasisSwap' where finalize = qlFreeEnergyBasisSwap+foreign import ccall "ql.h qlEnergyBasisSwapAsEnergySwap" qlEnergyBasisSwapAsEnergySwap :: Ptr CEnergyBasisSwap' -> IO (Ptr CEnergySwap')+instance Upcastable CEnergyBasisSwap' where {type Base CEnergyBasisSwap' = CEnergySwap'; upcast = qlEnergyBasisSwapAsEnergySwap}+peekEnergyBasisSwap :: Ptr CEnergyBasisSwap' -> IO EnergyBasisSwap+peekEnergyBasisSwap = newGenForeignPtr >=> newGenEnergySwap+withEnergyBasisSwap :: EnergyBasisSwap -> (Ptr CEnergyBasisSwap' -> IO b) -> IO b+withEnergyBasisSwap = withForeignPtr . ptr . peel . peel . peel . getInstrument++-- |'CommodityCashFlow': a standalone 'CashFlow' subclass, following the same+-- ZeroInflationCashFlow\/CPICashFlow\/EquityCashFlow precedent (no polymorphic @CashFlow@ family is+-- modelled here -- see those types in 'QuantLib.CashFlow' -- each concrete cash flow class is its+-- own standalone foreign-pointer type instead).+data CCommodityCashFlow+newtype CommodityCashFlow = CommodityCashFlow {getCCommodityCashFlow :: Standalone CCommodityCashFlow}+foreign import ccall unsafe "ql.h &qlFreeCommodityCashFlow" qlFreeCommodityCashFlow :: FinalizerPtr CCommodityCashFlow+instance Finalizable CCommodityCashFlow where finalize = qlFreeCommodityCashFlow+peekCommodityCashFlow :: Ptr CCommodityCashFlow -> IO CommodityCashFlow+peekCommodityCashFlow = CommodityCashFlow <.> peekStandalone+withCommodityCashFlow :: CommodityCashFlow -> (Ptr CCommodityCashFlow -> IO b) -> IO b+withCommodityCashFlow = withStandalone . getCCommodityCashFlow+-- |An array of freshly-constructed 'CommodityCashFlow's -- 'EnergySwap.paymentCashFlows()''s+-- @map<Date, shared_ptr<CommodityCashFlow>>@, read as a plain list (each element's own+-- 'QuantLib.Instrument.Energy.commodityCashFlowDate' 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  withInstrumentArray :: [GenInstrument i] -> ((CUInt, Ptr (Ptr CInstrument')) -> IO b) -> IO b withInstrumentArray = withGenArray withInstrument

@@ -38,7 +38,7 @@   , points'   ) where import QuantLib.Internal-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Type import Foreign.C.Types(CDouble) import Data.Vector.Storable(Vector)

@@ -9,8 +9,8 @@   , PiecewiseTimeDependentHestonModel   , ShortRateModel   , GenShortRateModel-  , AffineModel(..)-  , Gaussian1dModel(..)+  , AffineModel+  , Gaussian1dModel   , OneFactorAffineModel   , GenOneFactorAffineModel   , LiborForwardModel@@ -28,8 +28,11 @@   , LmVolatilityModel(..)   , CalibrationHelper   , BlackCalibrationHelper+  , GenBlackCalibrationHelper+  , SwaptionHelper   , GenCalibrationHelper   , asCalibrationHelper+  , asBlackCalibrationHelper    , asCalibratedModel   , asHestonModel@@ -37,6 +40,12 @@   , asOneFactorAffineModel   , asBatesModel   , asBatesDoubleExpModel+  , hullWhiteAsAffineModel+  , g2AsAffineModel+  , oneFactorAffineModelAsAffineModel+  , liborForwardModelAsAffineModel+  , gsrAsGaussian1dModel+  , markovFunctionalAsGaussian1dModel    , batesModel   , blackKarasinski@@ -52,6 +61,7 @@   , liborForwardModel   , gsr   , markovFunctional+  , markovFunctionalCaplet    , calibrate   , calibrateVolatilitiesIterative@@ -60,6 +70,8 @@   , swaptionHelper   , swaptionHelperFromDate   , swaptionHelperFromDates+  , swaptionHelperUnderlying+  , swaptionHelperSwaption   , times    , discountBond@@ -74,6 +86,7 @@   , impliedVolatility   , marketValue   , modelValue+  , volatility   , setPricingEngine   ) where #include "qlTypesC2HS.h"@@ -88,7 +101,7 @@ {#import QuantLib.InterestRate#}(VolatilityType) {#import QuantLib.CashFlow#}(RateAveragingType) import QuantLib.Internal.Type-import QuantLib.Internal.Enum+import QuantLib.Internal.Common  {#enum CalibrationErrorType{} deriving(Show, Eq)#} @@ -122,6 +135,9 @@  {#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#}@@ -173,7 +189,7 @@ {#fun qlOneFactorAffineModelDiscountBond as discountBond{withOneFactorAffineModel*`GenOneFactorAffineModel om',`Double' -- ^now   ,`Double' -- ^maturity   ,`Double' -- ^rate-  }->`Double'#}+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Two-additive-factor Gaussian (G2) short-rate model: the sum of two correlated Ornstein-Uhlenbeck factors. {#fun qlG2 as g2{withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^y@@ -202,12 +218,15 @@   ,preErrorCheck-`String'errorCheck*-}->`HullWhite'peekHullWhite*#}  -- |Futures convexity bias (difference between futures implied rate and forward rate), per G. Kirikos, D. Novak, \"Convexity Conundrums\", Risk Magazine, March 1997. @t@/@T@ are in yearfraction using the deposit day counter, @futurePrice@ is the futures' market price.-{#fun pure qlHullWhiteConvexityBias as convexityBias{`Double' -- ^futurePrice+-- Not 'pure': 'HullWhite.convexityBias' can throw ('QL_REQUIRE' on its inputs), and letting a C+++-- exception unwind across the FFI boundary from an 'unsafePerformIO'-backed pure binding is undefined+-- behavior, so this needs the same 'char **e'/'preErrorCheck' error channel as any other throwing call.+{#fun qlHullWhiteConvexityBias as convexityBias{`Double' -- ^futurePrice   ,`Double' -- ^t   ,`Double' -- ^T   ,`Double' -- ^sigma   ,`Double' -- ^a-  }->`Double'#}+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Marks the reversion (@a@) fixed and volatility (@sigma@) free for 'calibrate''s @fixParameters@ argument. Mirrors @HullWhite::FixedReversion()@. fixedReversion :: [Bool]@@ -223,7 +242,7 @@ {#fun qlGsrVolatility as gsrVolatility{withGenCalibratedModel*`Gsr',preArray-`[Double]'&peekDoubleArray*,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*`[BlackCalibrationHelper]'&,withOptimizationMethod*`OptimizationMethod',withEndCriteria*`EndCriteria'+{#fun qlGsrCalibrateVolatilitiesIterative as calibrateVolatilitiesIterative{withGenCalibratedModel*`Gsr',withBlackCalibrationHelperArray*`[GenBlackCalibrationHelper bch]'&,withOptimizationMethod*`OptimizationMethod',withEndCriteria*`EndCriteria'   ,withMaybeConstraint*`Maybe Constraint'   ,withDoubleArray*`[Double]'&   ,preErrorCheck-`String'errorCheck*-}->`()'#}@@ -249,6 +268,16 @@   ,fromIntegral`Word'   ,preErrorCheck-`String'errorCheck*-}->`MarkovFunctional'peekMarkovFunctional*#} +-- |Markov-functional interest-rate model, calibrated to a caplet volatility structure against @iborIndex@.+{#fun qlMarkovFunctionalCaplet as markovFunctionalCaplet{withYieldTermStructure*`GenYieldTermStructure y',`Double' -- ^reversion+  ,withDayArray*`[Day]'& -- ^volstepdates+  ,withDoubleArray*`[Double]'& -- ^volatilities+  ,withOptionletVolatilityStructure*`OptionletVolatilityStructure' -- ^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 as markovFunctionalVolatility{withGenCalibratedModel*`MarkovFunctional',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#} @@ -312,7 +341,7 @@   ,`Double' -- ^shift   ,fromMaybeInt`Maybe Word' -- ^settlementDays   ,`RateAveragingType' -- ^averagingMethod-  ,preErrorCheck-`String'errorCheck*-}->`BlackCalibrationHelper'peekBlackCalibrationHelper*#}+  ,preErrorCheck-`String'errorCheck*-}->`SwaptionHelper'peekSwaptionHelper*#}  -- |Like 'swaptionHelper', but the option's exercise is given as an explicit date rather than a maturity 'Period'. {#fun qlSwaptionHelperFromDate as swaptionHelperFromDate{withDay*`Day' -- ^exerciseDate@@ -328,7 +357,7 @@   ,`Double' -- ^shift   ,fromMaybeInt`Maybe Word' -- ^settlementDays   ,`RateAveragingType' -- ^averagingMethod-  ,preErrorCheck-`String'errorCheck*-}->`BlackCalibrationHelper'peekBlackCalibrationHelper*#}+  ,preErrorCheck-`String'errorCheck*-}->`SwaptionHelper'peekSwaptionHelper*#}  -- |Like 'swaptionHelper', but both the option's exercise and the underlying swap's end are given as explicit dates. {#fun qlSwaptionHelperFromDates as swaptionHelperFromDates{withDay*`Day' -- ^exerciseDate@@ -344,23 +373,29 @@   ,`Double' -- ^shift   ,fromMaybeInt`Maybe Word' -- ^settlementDays   ,`RateAveragingType' -- ^averagingMethod-  ,preErrorCheck-`String'errorCheck*-}->`BlackCalibrationHelper'peekBlackCalibrationHelper*#}+  ,preErrorCheck-`String'errorCheck*-}->`SwaptionHelper'peekSwaptionHelper*#} +-- |Upstream's own vanilla swap underlying this helper's swaption.+{#fun qlSwaptionHelperUnderlying as swaptionHelperUnderlying{withSwaptionHelper*`SwaptionHelper',preErrorCheck-`String'errorCheck*-}->`FixedVsFloatingSwap'peekFixedVsFloatingSwap*#}++-- |The 'QuantLib.Instrument.Swap.Swaption' this helper prices internally to compute 'modelValue'.+{#fun qlSwaptionHelperSwaption as swaptionHelperSwaption{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{withGenCalibrationHelper*`BlackCalibrationHelper',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlBlackCalibrationHelperTimes as times{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preArray-`[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*-}->`()'#}  -- |Black price given a volatility.-{#fun qlBlackCalibrationHelperBlackPrice as blackPrice{withGenCalibrationHelper*`BlackCalibrationHelper',`Double' -- ^volatility+{#fun qlBlackCalibrationHelperBlackPrice as blackPrice{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',`Double' -- ^volatility   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |returns the error resulting from the model valuation-{#fun qlBlackCalibrationHelperCalibrationError as calibrationError{withGenCalibrationHelper*`BlackCalibrationHelper',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlBlackCalibrationHelperCalibrationError as calibrationError{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |Black volatility implied by the model.-{#fun qlBlackCalibrationHelperImpliedVolatility as impliedVolatility{withGenCalibrationHelper*`BlackCalibrationHelper',`Double' -- ^targetValue+{#fun qlBlackCalibrationHelperImpliedVolatility as impliedVolatility{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',`Double' -- ^targetValue   ,`Double' -- ^accuracy   ,fromIntegral`Word' -- ^maxEvaluations   ,`Double' -- ^minVol@@ -368,12 +403,15 @@   ,preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |returns the actual price of the instrument (from volatility)-{#fun qlBlackCalibrationHelperMarketValue as marketValue{withGenCalibrationHelper*`BlackCalibrationHelper',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlBlackCalibrationHelperMarketValue as marketValue{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preErrorCheck-`String'errorCheck*-}->`Double'#}  -- |returns the price of the instrument according to the model-{#fun qlBlackCalibrationHelperModelValue as modelValue{withGenCalibrationHelper*`BlackCalibrationHelper',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlBlackCalibrationHelperModelValue as modelValue{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',preErrorCheck-`String'errorCheck*-}->`Double'#} +-- |The quoted market volatility this helper was built with.+{#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{withGenCalibrationHelper*`BlackCalibrationHelper',withPricingEngine*`PricingEngine',preErrorCheck-`String'errorCheck*-}->`()'#}+{#fun qlBlackCalibrationHelperSetPricingEngine as setPricingEngine{withBlackCalibrationHelper*`GenBlackCalibrationHelper bch',withPricingEngine*`PricingEngine',preErrorCheck-`String'errorCheck*-}->`()'#}  -- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -20,11 +20,16 @@   , riskyBondEngine   , discountingSwapEngine   , discountingFxForwardEngine+  , discountingConstNotionalCrossCurrencySwapEngine   , counterpartyAdjSwapEngine    , analyticBarrierEngine+  , analyticSoftBarrierEngine   , analyticPartialTimeBarrierOptionEngine   , analyticBinaryBarrierEngine+  , analyticSimpleChooserEngine+  , analyticTwoAssetCorrelationEngine+  , analyticWriterExtensibleOptionEngine   , fdBlackScholesBarrierEngine   , fdHestonBarrierEngine   , fdHestonBarrierEngine'@@ -43,19 +48,32 @@   , analyticDigitalAmericanEngine   , analyticDiscreteGeometricAveragePriceAsianEngine   , analyticDiscreteGeometricAverageStrikeAsianEngine+  , turnbullWakemanAsianEngine+  , fdBlackScholesAsianEngine   , analyticDividendEuropeanEngine   , analyticEuropeanEngine   , analyticPerformanceEngine+  , forwardEuropeanEngine+  , forwardBaroneAdesiWhaleyEngine+  , forwardBjerksundStenslandEngine+  , forwardFdBlackScholesVanillaEngine+  , mcForwardEuropeanBSEngine+  , analyticHestonForwardEuropeanEngine   , blackCapFloorEngine'   , blackCapFloorEngine   , blackSwaptionEngine   , blackSwaptionEngine'   , bachelierCapFloorEngine'   , bachelierCapFloorEngine+  , yoyInflationBlackCapFloorEngine+  , yoyInflationUnitDisplacedBlackCapFloorEngine+  , yoyInflationBachelierCapFloorEngine+  , interpolatingCPICapFloorEngine   , bachelierSwaptionEngine   , bachelierSwaptionEngine'   , analyticBSMHullWhiteEngine   , analyticCapFloorEngine+  , gaussian1dCapFloorEngine   , analyticGJRGARCHEngine   , analyticHestonEngine   , analyticHestonHullWhiteEngine@@ -99,6 +117,9 @@   , isdaCdsEngine   , jamshidianSwaptionEngine   , gaussian1dSwaptionEngine+  , gaussian1dNonstandardSwaptionEngine+  , gaussian1dFloatFloatSwaptionEngine+  , gaussian1dJamshidianSwaptionEngine   , juQuadraticApproximationEngine   , kirkEngine   , midPointCdsEngine@@ -223,7 +244,7 @@ {#import QuantLib.Math#} {#import QuantLib.Quote#}(DeltaType, AtmType) {#import QuantLib.Instrument.Option#} hiding(itmCashProbability, deltaForward, strikeSensitivity, dividendRho, rho, vega)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common  {#enum CashAnnuityModel{} deriving(Show, Eq)#} {#enum Probabilities{} deriving(Show, Eq)#}@@ -233,6 +254,7 @@ {#enum ForwardsInCouponPeriod{} deriving(Show, Eq)#}  {#pointer *DayCounter foreign -> CDayCounter nocode#}+{#pointer *Currency foreign -> CCurrency nocode#}  {#pointer *QlDividend as Dividend foreign -> CDividend nocode#} {#pointer *QlQuote as Quote foreign -> CQuote' nocode#}@@ -243,6 +265,9 @@ {#pointer *QlDefaultProbabilityTermStructure as DefaultProbabilityTermStructure foreign -> CDefaultProbabilityTermStructure' nocode#} {#pointer *QlSwaptionVolatilityStructure as SwaptionVolatilityStructure foreign -> CSwaptionVolatilityStructure' nocode#} {#pointer *QlOptionletVolatilityStructure as OptionletVolatilityStructure foreign -> COptionletVolatilityStructure' nocode#}+{#pointer *QlYoYOptionletVolatilitySurface as YoYOptionletVolatilitySurface foreign -> CYoYOptionletVolatilitySurface' nocode#}+{#pointer *QlYoYInflationIndex as YoYInflationIndex foreign -> CYoYInflationIndex' nocode#}+{#pointer *QlCPICapFloorTermPriceSurface as CPICapFloorTermPriceSurface foreign -> CCPICapFloorTermPriceSurface' nocode#}  {#pointer *QlGJRGARCHModel as GJRGARCHModel foreign -> CGJRGARCHModel' nocode#} {#pointer *QlHestonModel as HestonModel foreign -> CHestonModel' nocode#}@@ -307,6 +332,22 @@   ,withQuote*`GenQuote q' -- ^spotFx   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +-- |Discounts each leg of a 'QuantLib.Instrument.Swap.ConstNotionalCrossCurrencySwap' (or either+-- of its two leaves) off its own currency's discount curve, converting to @domesticCcy@ via+-- @spotFX@ (quoted as units of @domesticCcy@ per unit of @foreignCcy@, w.r.t. a settlement equal+-- to the npv date unless @spotFXSettleDate@ says otherwise). Each leg's stored currency must equal+-- @domesticCcy@ or @foreignCcy@; the two discount curves must share the same reference date.+{#fun qlDiscountingConstNotionalCrossCurrencySwapEngine as discountingConstNotionalCrossCurrencySwapEngine{withCurrency*`Currency' -- ^domesticCcy+  ,withYieldTermStructure*`GenYieldTermStructure y1' -- ^domesticCcyDiscountCurve+  ,withCurrency*`Currency' -- ^foreignCcy+  ,withYieldTermStructure*`GenYieldTermStructure y2' -- ^foreignCcyDiscountCurve+  ,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*#}+ -- | CVA/DVA-adjusted swap pricing engine. @invstDTS@\/@invstRecoveryRate@ are the -- own (investor-side) default probability curve and recovery rate for bilateral -- CVA\/DVA; pass 'Nothing' for @invstDTS@ and @0.999@ for @invstRecoveryRate@ to@@ -322,6 +363,21 @@ -- |analytic pricing engine for barrier options {#fun qlAnalyticBarrierEngine as analyticBarrierEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',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*#}++-- |analytic pricing engine for simple chooser options+{#fun qlAnalyticSimpleChooserEngine as analyticSimpleChooserEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |analytic pricing engine for two-asset correlation options+{#fun qlAnalyticTwoAssetCorrelationEngine as analyticTwoAssetCorrelationEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process1+  ,withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess' -- ^process2+  ,withQuote*`GenQuote q' -- ^correlation+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |analytic pricing engine for writer-extensible options+{#fun qlAnalyticWriterExtensibleOptionEngine as analyticWriterExtensibleOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |analytic pricing engine for partial-time barrier options {#fun qlAnalyticPartialTimeBarrierOptionEngine as analyticPartialTimeBarrierOptionEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -400,6 +456,9 @@ -- |analytic pricing engine for European discrete geometric average-strike Asian options {#fun qlAnalyticDiscreteGeometricAverageStrikeAsianEngine as analyticDiscreteGeometricAverageStrikeAsianEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',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*#}+ -- |analytic pricing engine for European options with discrete dividends {#fun qlAnalyticDividendEuropeanEngine as analyticDividendEuropeanEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',withDividendArray*`[Dividend]'&,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -411,6 +470,33 @@ -- |analytic pricing engine for performance (return) options {#fun qlAnalyticPerformanceEngine as analyticPerformanceEngine{withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',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*#}++-- |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*#}++-- |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*#}++-- |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*#}++-- |Monte Carlo pricing engine for forward-starting European options under a Black-Scholes process+{#fun qlMCForwardEuropeanBSEngine1 as mcForwardEuropeanBSEngine{`RngTrait',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',fromMaybeInt`Maybe Word' -- ^timeSteps+  ,fromMaybeInt`Maybe Word' -- ^timeStepsPerYear+  ,`Bool' -- ^brownianBridge+  ,`Bool' -- ^antitheticVariate+  ,fromMaybeInt`Maybe Word' -- ^requiredSamples+  ,fromMaybeDouble`Maybe Double' -- ^requiredTolerance+  ,fromMaybeInt`Maybe Word' -- ^maxSamples+  ,fromIntegral`Word' -- ^seed+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |analytic pricing engine for forward-starting European options under a Heston process+{#fun qlAnalyticHestonForwardEuropeanEngine as analyticHestonForwardEuropeanEngine{withHestonProcess*`GenHestonProcess hp',fromIntegral`Word' -- ^integrationOrder+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |Black-formula cap\/floor engine, taking an optionlet volatility structure {#fun qlBlackCapFloorEngine1 as blackCapFloorEngine'{withYieldTermStructure*`GenYieldTermStructure y',withOptionletVolatilityStructure*`GenOptionletVolatilityStructure ov',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -434,6 +520,32 @@ -- |Bachelier (normal) cap\/floor engine, taking a flat volatility quote {#fun qlBachelierCapFloorEngine as bachelierCapFloorEngine{withYieldTermStructure*`GenYieldTermStructure y',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +-- |Black-formula YoY inflation cap\/floor engine. The nominal discount curve and the index's+-- own linked 'QuantLib.TermStructure.Inflation.YoYInflationTermStructure' are separate --+-- @nominalTermStructure@ discounts cashflows, while the index forecasts them.+{#fun qlYoYInflationBlackCapFloorEngine as yoyInflationBlackCapFloorEngine{withYoYInflationIndex*`GenYoYInflationIndex yidx'+  ,withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface' -- ^vol+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |as 'yoyInflationBlackCapFloorEngine', but unit-displaced Black+{#fun qlYoYInflationUnitDisplacedBlackCapFloorEngine as yoyInflationUnitDisplacedBlackCapFloorEngine{withYoYInflationIndex*`GenYoYInflationIndex yidx'+  ,withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface' -- ^vol+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |as 'yoyInflationBlackCapFloorEngine', but Bachelier (normal model)+{#fun qlYoYInflationBachelierCapFloorEngine as yoyInflationBachelierCapFloorEngine{withYoYInflationIndex*`GenYoYInflationIndex yidx'+  ,withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface' -- ^vol+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |The only 'QuantLib.Instrument.InflationCapFloor.CPICapFloor' pricing engine in QL 1.43 --+-- prices purely by interpolating a market price surface, no stochastic-vol model (see that+-- type's own haddock for the CPI\/YoY asymmetry).+{#fun qlInterpolatingCPICapFloorEngine as interpolatingCPICapFloorEngine{withGenTermStructure*`CPICapFloorTermPriceSurface'+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |Bachelier (normal) swaption engine, taking a flat volatility quote {#fun qlBachelierSwaptionEngine as bachelierSwaptionEngine{withYieldTermStructure*`GenYieldTermStructure y',withQuote*`GenQuote q',withDayCounter*`DayCounter',`CashAnnuityModel' -- ^model   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}@@ -445,8 +557,19 @@ {#fun qlAnalyticBSMHullWhiteEngine as analyticBSMHullWhiteEngine{`Double',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',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{withAffineModel*`AffineModel',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+{#fun qlAnalyticCapFloorEngine as analyticCapFloorEngine{withStandalone*`AffineModel',withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +-- |cap\/floor pricing engine for any one-factor Gaussian short-rate model, evaluated by+-- integration over the model's state variable. As 'gaussian1dSwaptionEngine', without+-- 'Probabilities'.+{#fun qlGaussian1dCapFloorEngine as gaussian1dCapFloorEngine{withStandalone*`Gaussian1dModel'+  ,fromIntegral`Int' -- ^integrationPoints+  ,`Double' -- ^stddevs+  ,`Bool' -- ^extrapolatePayoff+  ,`Bool' -- ^flatPayoffExtrapolation+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountCurve+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}+ -- |analytic pricing engine for vanilla options under a GJR-GARCH process {#fun qlAnalyticGJRGARCHEngine as analyticGJRGARCHEngine{withGenCalibratedModel*`GJRGARCHModel',preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} @@ -558,7 +681,7 @@ {#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-{#fun qlGaussian1dSwaptionEngine as gaussian1dSwaptionEngine{withGaussian1dModel*`Gaussian1dModel'+{#fun qlGaussian1dSwaptionEngine as gaussian1dSwaptionEngine{withStandalone*`Gaussian1dModel'   ,fromIntegral`Int' -- ^integrationPoints   ,`Double' -- ^stddevs   ,`Bool' -- ^extrapolatePayoff@@ -567,6 +690,37 @@   ,`Probabilities' -- ^probabilities   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#} +-- |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.+{#fun qlGaussian1dNonstandardSwaptionEngine as gaussian1dNonstandardSwaptionEngine{withStandalone*`Gaussian1dModel'+  ,fromIntegral`Int' -- ^integrationPoints+  ,`Double' -- ^stddevs+  ,`Bool' -- ^extrapolatePayoff+  ,`Bool' -- ^flatPayoffExtrapolation+  ,withMaybeQuote*`Maybe (GenQuote q)' -- ^oas+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountCurve+  ,`Probabilities' -- ^probabilities+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |As 'gaussian1dNonstandardSwaptionEngine', for a+-- 'QuantLib.Instrument.Swap.FloatFloatSwaption'. Adds 'includeTodaysExercise' -- whether a+-- fixing due exactly \"today\" counts as part of the exercise-into leg.+{#fun qlGaussian1dFloatFloatSwaptionEngine as gaussian1dFloatFloatSwaptionEngine{withStandalone*`Gaussian1dModel'+  ,fromIntegral`Int' -- ^integrationPoints+  ,`Double' -- ^stddevs+  ,`Bool' -- ^extrapolatePayoff+  ,`Bool' -- ^flatPayoffExtrapolation+  ,withMaybeQuote*`Maybe (GenQuote q)' -- ^oas+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountCurve+  ,`Bool' -- ^includeTodaysExercise+  ,`Probabilities' -- ^probabilities+  ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}++-- |swaption pricing engine using Jamshidian's decomposition, for any one-factor Gaussian+-- short-rate model.+{#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*#} @@ -842,6 +996,13 @@  -- |pricing engine for vanilla options using binomial trees {#fun qlBinomialVanillaEngine as binomialVanillaEngine{`BinomialTree',withGeneralizedBlackScholesProcess*`GeneralizedBlackScholesProcess',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+  ,fromIntegral`Word' -- ^xGrid+  ,fromIntegral`Word' -- ^aGrid+  ,withFdmSchemeDesc*`FdmScheme'   ,preErrorCheck-`String'errorCheck*-}->`PricingEngine'peekPricingEngine*#}  -- |finite-differences Black-Scholes pricing engine for vanilla options

@@ -29,7 +29,7 @@   , linkTo   ) where import QuantLib.Internal-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Type  #include "qlTypesC2HS.h"

@@ -0,0 +1,157 @@+module QuantLib.TermStructure.Commodity+  (+    CommodityCurve+  , commodityCurve+  , commodityCurveName+  , commodityCurveCommodityType+  , commodityCurveUnitOfMeasure+  , commodityCurveCurrency+  , commodityCurveDates+  , commodityCurvePrices+  , commodityCurveEmpty+  , commodityCurveBasisOfCurve+  , setCommodityCurveBasisOfCurve+  , commodityCurvePrice+  , commodityCurveBasisOfPrice+  , ExchangeContract+  , ExchangeContracts+  , commodityCurvePriceNearby+  , commodityCurveUnderlyingPriceDate+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "qlEnumObjects.h"++#include "ql.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *Currency foreign -> CCurrency nocode#}+{#pointer *CommodityType foreign -> CCommodityType nocode#}+{#pointer *UnitOfMeasure foreign -> CUnitOfMeasure nocode#}+{#pointer *DayCounter foreign -> CDayCounter nocode#}+{#pointer *QlCommodityCurve as CommodityCurve foreign -> CCommodityCurve' nocode#}++-- |Construct a commodity price curve: a named, interpolated (forward-flat) price curve over a+-- fixed set of dates, for a given commodity type\/currency\/unit of measure. QuantLib's no-dates+-- constructor (populated later via the mutator @setPrices@) is not bound -- per the standing+-- setter-confirmation rule, only 'setCommodityCurveBasisOfCurve' was confirmed, not @setPrices@ --+-- so this with-dates constructor is the only way to build one.+{#fun qlCommodityCurve as commodityCurve+  {`String' -- ^name+  ,withCommodityType*`CommodityType'+  ,withCurrency*`Currency'+  ,withUnitOfMeasure*`UnitOfMeasure'+  ,withCalendar*`Calendar'+  ,withDayArray*`[Day]'&+  ,withDoubleArray*`[Double]'&+  ,withDayCounter*`DayCounter'+  ,preErrorCheck-`String'errorCheck*-}->`CommodityCurve'peekCommodityCurve*#}++-- |The curve's name, as given at construction.+{#fun qlCommodityCurveName as commodityCurveName{withGenTermStructure*`CommodityCurve'}->`String'peekDynString*#}++-- |The commodity type this curve prices.+{#fun qlCommodityCurveCommodityType as commodityCurveCommodityType{withGenTermStructure*`CommodityCurve',preErrorCheck-`String'errorCheck*-}->`CommodityType'peekCommodityType*#}++-- |The unit of measure this curve's prices are quoted in.+{#fun qlCommodityCurveUnitOfMeasure as commodityCurveUnitOfMeasure{withGenTermStructure*`CommodityCurve',preErrorCheck-`String'errorCheck*-}->`UnitOfMeasure'peekUnitOfMeasure*#}++-- |The currency this curve's prices are quoted in.+{#fun qlCommodityCurveCurrency as commodityCurveCurrency{withGenTermStructure*`CommodityCurve',preErrorCheck-`String'errorCheck*-}->`Currency'peekCurrency*#}++-- |The curve's node dates, as given at construction.+{#fun qlCommodityCurveDates as commodityCurveDates{withGenTermStructure*`CommodityCurve',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |The curve's node prices, as given at construction. Paired positionally with 'commodityCurveDates'+-- -- upstream's own @nodes()@ getter is just their zip, so it isn't bound separately (per "bind+-- few inspectors").+{#fun qlCommodityCurvePrices as commodityCurvePrices{withGenTermStructure*`CommodityCurve',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |Whether this curve has any nodes.+{#fun pure qlCommodityCurveEmpty as commodityCurveEmpty{withGenTermStructure*`CommodityCurve'}->`Bool'#}++-- |The basis curve this curve was chained to via 'setCommodityCurveBasisOfCurve', if any.+{#fun qlCommodityCurveBasisOfCurve as commodityCurveBasisOfCurve{withGenTermStructure*`CommodityCurve'}->`Maybe CommodityCurve'peekMaybeCommodityCurve*#}++-- |Chain this curve to a basis curve: prices returned by 'commodityCurvePrice'\/'commodityCurveBasisOfPrice'+-- then include the basis curve's price on top of this curve's own. Confirmed with the user as the+-- one 'CommodityCurve' mutator worth binding (unlike @setPrices@, which stays unbound).+{#fun qlCommodityCurveSetBasisOfCurve as setCommodityCurveBasisOfCurve{withGenTermStructure*`CommodityCurve',withGenTermStructure*`CommodityCurve',preErrorCheck-`String'errorCheck*-}->`()'#}++-- |A dated exchange contract: a code, its expiration date, and the start/end dates of the+-- underlying delivery period it corresponds to. A plain tuple, per the @Money@/'Quantity'-as-tuple+-- convention -- it carries no calculation of its own upstream, only three inspectors that would+-- just be tuple projections.+type ExchangeContract = (String, Day, Day, Day) -- ^code, expirationDate, underlyingStartDate, underlyingEndDate++-- |QuantLib's @std::map\<Date,ExchangeContract\>@: a set of exchange contracts, keyed by the date+-- 'commodityCurvePriceNearby'\/'commodityCurveUnderlyingPriceDate' roll onto (upstream's own+-- @lower_bound@ walk finds the first key at or after the query date, then steps @nearbyOffset - 1@+-- further). Marshalled as an association list, not an actual 'Data.Map.Map' -- the C shim rebuilds+-- the real @std::map@ itself so key order doesn't need to be pre-sorted on the Haskell side.+type ExchangeContracts = [(Day, ExchangeContract)]++-- |Split an 'ExchangeContracts' into the five parallel lists the low-level bindings below take.+-- Not a single combined marshaller: c2hs's @&@ tuple-splitter only ever consumes two C arguments+-- (confirmed against its source, same reasoning as 'QuantLib.Commodity.Quantity'), so each list is+-- passed as its own flat, individually-marshalled argument instead of one bundled continuation.+splitExchangeContracts :: ExchangeContracts -> ([Day], [String], [Day], [Day], [Day])+splitExchangeContracts ecs =+  ( map fst ecs+  , [c | (_, (c, _, _, _)) <- ecs]+  , [x | (_, (_, x, _, _)) <- ecs]+  , [s | (_, (_, _, s, _)) <- ecs]+  , [e | (_, (_, _, _, e)) <- ecs] )++{#fun qlCommodityCurvePrice as qlCommodityCurvePrice_+  {withGenTermStructure*`CommodityCurve'+  ,withDay*`Day'+  ,withDayArray*`[Day]'&+  ,withStringArray*`[String]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,`Int' -- ^nearbyOffset+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The curve's price for a date, plus any chained basis curve's price, rolling forward onto+-- nearby exchange contracts when @nearbyOffset > 0@ (upstream's own @price@ never touches+-- @exchangeContracts@ otherwise). 'commodityCurvePrice' is this with no exchange contracts and+-- offset @0@, which reproduces the flat (no-rolling) case exactly.+commodityCurvePriceNearby :: CommodityCurve -> Day -> ExchangeContracts -> Int -> IO Double+commodityCurvePriceNearby curve date ecs nearbyOffset =+  qlCommodityCurvePrice_ curve date keys codes expirations starts ends nearbyOffset+  where (keys, codes, expirations, starts, ends) = splitExchangeContracts ecs++-- |The curve's price for a date, plus any chained basis curve's price. This is+-- 'commodityCurvePriceNearby' with no exchange contracts and offset @0@ -- the flat (no+-- nearby-rolling) case, which never touches @exchangeContracts@ upstream either way.+commodityCurvePrice :: CommodityCurve -> Day -> IO Double+commodityCurvePrice curve date = commodityCurvePriceNearby curve date [] 0++-- |The chained basis curve's price alone (excluding this curve's own price), for a date.+{#fun qlCommodityCurveBasisOfPrice as commodityCurveBasisOfPrice{withGenTermStructure*`CommodityCurve',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`Double'#}++{#fun qlCommodityCurveUnderlyingPriceDate as qlCommodityCurveUnderlyingPriceDate_+  {withGenTermStructure*`CommodityCurve'+  ,withDay*`Day'+  ,withDayArray*`[Day]'&+  ,withStringArray*`[String]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,withDayArray*`[Day]'&+  ,`Int' -- ^nearbyOffset+  ,preErrorCheck-`String'errorCheck*-}->`Day'toDay#}++-- |The date whose price a nearby roll (@nearbyOffset > 0@) actually reads: the underlying+-- contract's start date at the @nearbyOffset@\'th exchange contract at or after @date@. Throws if+-- @nearbyOffset <= 0@, or if fewer than @nearbyOffset@ contracts are available from @date@ onward.+commodityCurveUnderlyingPriceDate :: CommodityCurve -> Day -> ExchangeContracts -> Int -> IO Day+commodityCurveUnderlyingPriceDate curve date ecs nearbyOffset =+  qlCommodityCurveUnderlyingPriceDate_ curve date keys codes expirations starts ends nearbyOffset+  where (keys, codes, expirations, starts, ends) = splitExchangeContracts ecs++-- vim: set ff=unix ts=8 sts=2 sw=2 et:

@@ -31,14 +31,14 @@ #include "qlEnumObjects.h"  import QuantLib.Internal-{#import QuantLib.Time.Calendar#}(BusinessDayConvention) {#import QuantLib.Instrument#}(PricingModel) import QuantLib.Internal.Type {#import QuantLib.Time.Schedule#}(DateGenerationRule, Frequency)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common  {#enum ProbabilityTrait{} deriving(Show, Eq)#} +{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *QlDefaultProbabilityTermStructure as DefaultProbabilityTermStructure foreign -> CDefaultProbabilityTermStructure' nocode#} {#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#} {#pointer *QlTermStructure as TermStructure foreign -> CTermStructure' nocode#}@@ -102,7 +102,7 @@ {#fun qlSpreadCdsHelper as spreadCdsHelper{withQuote*`GenQuote q' -- ^runningSpread   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^tenor   ,`Int' -- ^settlementDays-  ,withCalendar*`Calendar',`Frequency',`BusinessDayConvention',`DateGenerationRule',withDayCounter*`DayCounter'+  ,withCalendar*`Calendar',`Frequency',fromEnumC`BusinessDayConvention',`DateGenerationRule',withDayCounter*`DayCounter'   ,`Double' -- recoveryRate   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^discountCurve   ,`Bool' -- ^settlesAccrual@@ -118,7 +118,7 @@   ,`Double' -- ^runningSpread   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^tenor   ,`Int' -- ^settlementDays-  ,withCalendar*`Calendar',`Frequency',`BusinessDayConvention',`DateGenerationRule',withDayCounter*`DayCounter'+  ,withCalendar*`Calendar',`Frequency',fromEnumC`BusinessDayConvention',`DateGenerationRule',withDayCounter*`DayCounter'   ,`Double' -- ^recoveryDate   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^discountCurve   ,fromIntegral`Word' -- ^upfrontSettlementDays

@@ -5,7 +5,7 @@   , ZeroCouponInflationSwapHelper   , YearOnYearInflationSwapHelper -  , CPIInterpolationType(..) -- ^re-exported from "QuantLib.Internal.Enum"+  , CPIInterpolationType(..) -- ^re-exported from "QuantLib.Internal.Common"    , zeroCouponInflationSwapHelper   , yearOnYearInflationSwapHelper@@ -14,15 +14,15 @@    , piecewiseZeroInflationCurve   , piecewiseYoYInflationCurve+  , interpolatedYoYInflationCurve    , zeroRate   , yoyRate   ) where import QuantLib.Internal-{#import QuantLib.Time.Calendar#}(BusinessDayConvention) import QuantLib.Internal.Type {#import QuantLib.Time.Schedule#}(Frequency)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common {#import QuantLib.TermStructure.Yield#}(PillarChoice)  #include "qlTypesC2HS.h"@@ -31,6 +31,7 @@  #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#}@@ -47,7 +48,7 @@   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag   ,withDay*`Day' -- ^maturity   ,withCalendar*`Calendar'-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'   ,withZeroInflationIndex*`ZeroInflationIndex'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation@@ -61,7 +62,7 @@   ,fromEnumQuantity`(Word,TimeUnit)'& -- ^swapObsLag   ,withDay*`Day' -- ^maturity   ,withCalendar*`Calendar'-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withDayCounter*`DayCounter'   ,withYoYInflationIndex*`YoYInflationIndex'   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation@@ -97,6 +98,20 @@ -- interpolating between the bootstrapped nodes with the given 'Interpolation'. {#fun qlPiecewiseYoYInflationCurve{withDay*`Day',withDay*`Day',`Double',`Frequency',withDayCounter*`DayCounter'   ,withYearOnYearInflationSwapHelperArray*`[YearOnYearInflationSwapHelper]'&+  ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`YoYInflationTermStructure'peekYoYInflationTermStructure*#}++-- |A YoY-inflation curve interpolating directly between given (date, rate) nodes, unlike+-- 'piecewiseYoYInflationCurve''s bootstrap from swap helpers -- useful when the rates are+-- already known market YoY levels rather than swap quotes to calibrate against. The first+-- node is the curve's own base date\/rate.+interpolatedYoYInflationCurve :: Day -- ^referenceDate+  -> [(Day, Double)] -- ^dates, rates+  -> Frequency -> DayCounter -> Interpolation+  -> IO YoYInflationTermStructure+interpolatedYoYInflationCurve r dr f dc i = uncurryNested (qlInterpolatedYoYInflationCurve r ds rs f dc) (qlInterpolation i)+  where (ds, rs) = unzip dr+{#fun qlInterpolatedYoYInflationCurve{withDay*`Day',withDayArray*`[Day]'&,withDoubleArrayRaw*`[Double]'+  ,`Frequency',withDayCounter*`DayCounter'   ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`YoYInflationTermStructure'peekYoYInflationTermStructure*#}  -- |Zero-coupon inflation rate implied by the curve.

@@ -0,0 +1,297 @@+module QuantLib.TermStructure.InflationVolatility+  (+    YoYOptionletVolatilitySurface++  , constantYoYOptionletVolatility+  , kInterpolatedYoYOptionletVolatilitySurfaceBlack+  , kInterpolatedYoYOptionletVolatilitySurfaceUnitDisplacedBlack+  , kInterpolatedYoYOptionletVolatilitySurfaceBachelier++  , yoyOptionletVolatility+  , yoyOptionletTotalVariance++  , YoYCapFloorTermPriceSurface+  , yoyCapFloorTermPriceSurface++  , yoyCapFloorBaseDate+  , yoyCapFloorAtmYoYSwapDateRates+  , yoyCapFloorAtmYoYSwapRate+  , yoyCapFloorAtmYoYRate+  , yoyCapFloorStrikes++  , CPICapFloorTermPriceSurface+  , cpiCapFloorTermPriceSurface++  , CPIVolatilitySurface+  , constantCPIVolatility++  , cpiVolatility+  , cpiTotalVariance+  ) where+import QuantLib.Internal+import QuantLib.Internal.Type+{#import QuantLib.InterestRate#}(VolatilityType)+{#import QuantLib.Time.Schedule#}(Frequency)+import QuantLib.Internal.Common++#include "qlTypesC2HS.h"+#include "qlEnumC2HS.h"+#include "ql.h"+#include "qlEnumObjects.h"++{#pointer *Calendar foreign -> CCalendar nocode#}+{#pointer *DayCounter foreign -> CDayCounter nocode#}+{#pointer *QlQuote as Quote foreign -> CQuote' nocode#}+{#pointer *QlYieldTermStructure as YieldTermStructure foreign -> CYieldTermStructure' nocode#}+{#pointer *QlZeroInflationIndex as ZeroInflationIndex foreign -> CZeroInflationIndex' nocode#}+{#pointer *QlYoYInflationIndex as YoYInflationIndex foreign -> CYoYInflationIndex' nocode#}+{#pointer *QlYoYOptionletVolatilitySurface as YoYOptionletVolatilitySurface foreign -> CYoYOptionletVolatilitySurface' nocode#}+{#pointer *QlYoYCapFloorTermPriceSurface as YoYCapFloorTermPriceSurface foreign -> CYoYCapFloorTermPriceSurface' nocode#}+{#pointer *QlCPICapFloorTermPriceSurface as CPICapFloorTermPriceSurface foreign -> CCPICapFloorTermPriceSurface' nocode#}+{#pointer *QlCPIVolatilitySurface as CPIVolatilitySurface foreign -> CCPIVolatilitySurface' nocode#}++-- |Constant YoY-inflation optionlet vol surface, no maturity\/strike dependence. Mirrors+-- 'QuantLib.TermStructure.Volatility.constantOptionletVolatility', taking a 'GenQuote' rather+-- than a plain 'Double' per the @std::variant@\/overload-collapse rule (the flat case is already+-- reachable via 'QuantLib.Quote.simpleQuote'). Not the only concrete leaf of this type any+-- more -- see 'kInterpolatedYoYOptionletVolatilitySurfaceBlack' for the market-quote-bootstrapped+-- alternative.+{#fun qlConstantYoYOptionletVolatility as constantYoYOptionletVolatility{withQuote*`GenQuote q'+  ,fromIntegral`Word' -- ^settlementDays+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDayCounter*`DayCounter'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag+  ,`Frequency'+  ,`Bool' -- ^indexIsInterpolated+  ,`Double' -- ^minStrike+  ,`Double' -- ^maxStrike+  ,`VolatilityType'+  ,`Double' -- ^displacement+  ,preErrorCheck-`String'errorCheck*-}->`YoYOptionletVolatilitySurface'peekYoYOptionletVolatilityStructure*#}++-- |The volatility for a given maturity date and strike, observed with the given observation+-- lag (or the surface's own lag when 'Nothing').+{#fun qlYoYOptionletVolatilitySurfaceVolatility as yoyOptionletVolatility{withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface'+  ,withDay*`Day'+  ,`Double' -- ^strike+  ,fromMaybeEnumQuantity`Maybe (Word,TimeUnit)'& -- ^obsLag+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The total integrated variance for a given exercise date and strike -- useful because it+-- scales out time from the optionlet pricing formulae. As 'yoyOptionletVolatility', a+-- 'Nothing' observation lag uses the surface's own.+{#fun qlYoYOptionletVolatilitySurfaceTotalVariance as yoyOptionletTotalVariance{withGenVolatilityTermStructure*`YoYOptionletVolatilitySurface'+  ,withDay*`Day'+  ,`Double' -- ^strike+  ,fromMaybeEnumQuantity`Maybe (Word,TimeUnit)'& -- ^obsLag+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |Prices YoY cap\/floors by cap\/floor-surface intersection and put\/call parity, deriving an+-- ATM YoY swap curve as a side effect. 'Interpolation2D' chooses the cap\/floor price-grid+-- interpolator, 'Interpolation' the per-maturity one.+yoyCapFloorTermPriceSurface :: Word -- ^fixingDays+  -> (Word, TimeUnit) -- ^yyLag+  -> YoYInflationIndex -> CPIInterpolationType -> GenYieldTermStructure y -- ^nominal+  -> DayCounter -> Calendar -> BusinessDayConvention+  -> [Double] -- ^cStrikes+  -> [Double] -- ^fStrikes+  -> [(Word, TimeUnit)] -- ^cfMaturities+  -> Matrix Double -- ^cPrice+  -> Matrix Double -- ^fPrice+  -> Interpolation2D -> Interpolation+  -> IO YoYCapFloorTermPriceSurface+yoyCapFloorTermPriceSurface fixingDays yyLag yii interp nominal dc cal bdc cStrikes fStrikes cfMaturities (Matrix cr cc cd) (Matrix fr fc fd) i2d i1d =+  uncurryNested (qlYoYCapFloorTermPriceSurface fixingDays yyLag yii interp nominal dc cal bdc cStrikes fStrikes maturityNums maturityUnits cr cc cd fr fc fd (fromEnum i2d)) (qlInterpolation i1d)+  where (maturityNums, maturityUnits) = unzip cfMaturities+{#fun qlYoYCapFloorTermPriceSurface{fromIntegral`Word' -- ^fixingDays+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^yyLag+  ,withYoYInflationIndex*`YoYInflationIndex'+  ,fromEnumC`CPIInterpolationType'+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominal+  ,withDayCounter*`DayCounter'+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDoubleArray*`[Double]'& -- ^cStrikes+  ,withDoubleArray*`[Double]'& -- ^fStrikes+  ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'& -- ^cfMaturities+  ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]' -- ^cPrice+  ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]' -- ^fPrice+  ,`Int' -- ^interpolator2D+  ,`Int',`Int',`Int' -- ^interpolator1D, approximator, approximatorArg+  ,preErrorCheck-`String'errorCheck*-}->`YoYCapFloorTermPriceSurface'peekYoYCapFloorTermPriceSurface*#}++-- |The date the surface's own YoY term structure (and hence any 'YoYOptionletVolatilitySurface'+-- stripped from it) treats as its base -- referenceDate minus the observation lag, rounded to+-- the containing inflation period's start.+{#fun qlYoYCapFloorTermPriceSurfaceBaseDate as yoyCapFloorBaseDate{withGenTermStructure*`YoYCapFloorTermPriceSurface'+  ,preErrorCheck-`String'errorCheck*-}->`Day'toDay#}++-- |The ATM YoY swap curve derived from cap\/floor-surface intersection, as (date, rate) pairs.+yoyCapFloorAtmYoYSwapDateRates :: YoYCapFloorTermPriceSurface -> IO [(Day, Double)]+yoyCapFloorAtmYoYSwapDateRates s = do+  (ds, rs) <- qlYoYCapFloorTermPriceSurfaceAtmYoYSwapDateRates s+  return $ zip ds rs+{#fun qlYoYCapFloorTermPriceSurfaceAtmYoYSwapDateRates{withGenTermStructure*`YoYCapFloorTermPriceSurface'+  ,preArray-`[Day]'&peekDayArray*,preArray-`[Double]'&peekDoubleArray*}->`()'#}++-- |The ATM YoY swap rate at the given maturity date, from put\/call parity on the surface's+-- cap\/floor price data.+{#fun qlYoYCapFloorTermPriceSurfaceAtmYoYSwapRate as yoyCapFloorAtmYoYSwapRate{withGenTermStructure*`YoYCapFloorTermPriceSurface'+  ,withDay*`Day'+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The ATM YoY inflation rate at the given maturity date and observation lag (or the surface's+-- own lag when 'Nothing'), derived from the swap-rate curve above.+{#fun qlYoYCapFloorTermPriceSurfaceAtmYoYRate as yoyCapFloorAtmYoYRate{withGenTermStructure*`YoYCapFloorTermPriceSurface'+  ,withDay*`Day'+  ,fromMaybeEnumQuantity`Maybe (Word,TimeUnit)'& -- ^obsLag+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The union of cap and floor strikes in the surface's price grid -- the strikes a stripped+-- 'YoYOptionletVolatilitySurface' (via 'kInterpolatedYoYOptionletVolatilitySurfaceBlack' et al.)+-- has a bootstrapped vol curve for.+{#fun qlYoYCapFloorTermPriceSurfaceStrikes as yoyCapFloorStrikes{withGenTermStructure*`YoYCapFloorTermPriceSurface'+  ,preArray-`[Double]'&peekDoubleArray*}->`()'#}++-- |Strips a 'YoYOptionletVolatilitySurface' from a 'YoYCapFloorTermPriceSurface' by bootstrapping+-- a per-strike vol curve against Black-priced YoY caps\/floors (mirrors upstream's own+-- @testYoYPriceSurfaceToVol@: an @InterpolatedYoYOptionletStripper@ solving each strike's initial+-- vol, then a @KInterpolatedYoYOptionletVolatilitySurface@ interpolating across strikes, both+-- sharing the given 'Interpolation' -- neither is exposed as its own type, since nothing in+-- upstream reaches them from outside this one bootstrap; see this function's C shim for the full+-- pipeline). /index/\//nominalTermStructure/ price the null-vol engine the stripper solves+-- against; /slope/ is the assumed initial caplet-vol slope for strikes past the edge of good+-- price data (a negative slope for typically low\/flat short-dated extreme-strike prices, per+-- upstream's own comment -- too extreme a slope can leave no arbitrage-free solution).+kInterpolatedYoYOptionletVolatilitySurfaceBlack :: Word -- ^settlementDays+  -> Calendar -> BusinessDayConvention -> DayCounter+  -> YoYCapFloorTermPriceSurface -- ^capFloorPrices+  -> YoYInflationIndex -- ^index+  -> GenYieldTermStructure y -- ^nominalTermStructure+  -> Double -- ^slope+  -> Interpolation+  -> IO YoYOptionletVolatilitySurface+kInterpolatedYoYOptionletVolatilitySurfaceBlack settlementDays cal bdc dc capFloorPrices index nominalTs slope i1d =+  uncurryNested (qlKInterpolatedYoYOptionletVolatilitySurfaceBlack settlementDays cal bdc dc capFloorPrices index nominalTs slope) (qlInterpolation i1d)+{#fun qlKInterpolatedYoYOptionletVolatilitySurfaceBlack{fromIntegral`Word' -- ^settlementDays+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDayCounter*`DayCounter'+  ,withGenTermStructure*`YoYCapFloorTermPriceSurface' -- ^capFloorPrices+  ,withYoYInflationIndex*`YoYInflationIndex' -- ^index+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,`Double' -- ^slope+  ,`Int',`Int',`Int' -- ^interpolator, approximator, approximatorArg+  ,preErrorCheck-`String'errorCheck*-}->`YoYOptionletVolatilitySurface'peekYoYOptionletVolatilityStructure*#}++-- |As 'kInterpolatedYoYOptionletVolatilitySurfaceBlack', but unit-displaced Black.+kInterpolatedYoYOptionletVolatilitySurfaceUnitDisplacedBlack :: Word -- ^settlementDays+  -> Calendar -> BusinessDayConvention -> DayCounter+  -> YoYCapFloorTermPriceSurface -- ^capFloorPrices+  -> YoYInflationIndex -- ^index+  -> GenYieldTermStructure y -- ^nominalTermStructure+  -> Double -- ^slope+  -> Interpolation+  -> IO YoYOptionletVolatilitySurface+kInterpolatedYoYOptionletVolatilitySurfaceUnitDisplacedBlack settlementDays cal bdc dc capFloorPrices index nominalTs slope i1d =+  uncurryNested (qlKInterpolatedYoYOptionletVolatilitySurfaceUnitDisplacedBlack settlementDays cal bdc dc capFloorPrices index nominalTs slope) (qlInterpolation i1d)+{#fun qlKInterpolatedYoYOptionletVolatilitySurfaceUnitDisplacedBlack{fromIntegral`Word' -- ^settlementDays+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDayCounter*`DayCounter'+  ,withGenTermStructure*`YoYCapFloorTermPriceSurface' -- ^capFloorPrices+  ,withYoYInflationIndex*`YoYInflationIndex' -- ^index+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,`Double' -- ^slope+  ,`Int',`Int',`Int' -- ^interpolator, approximator, approximatorArg+  ,preErrorCheck-`String'errorCheck*-}->`YoYOptionletVolatilitySurface'peekYoYOptionletVolatilityStructure*#}++-- |As 'kInterpolatedYoYOptionletVolatilitySurfaceBlack', but Bachelier (normal model).+kInterpolatedYoYOptionletVolatilitySurfaceBachelier :: Word -- ^settlementDays+  -> Calendar -> BusinessDayConvention -> DayCounter+  -> YoYCapFloorTermPriceSurface -- ^capFloorPrices+  -> YoYInflationIndex -- ^index+  -> GenYieldTermStructure y -- ^nominalTermStructure+  -> Double -- ^slope+  -> Interpolation+  -> IO YoYOptionletVolatilitySurface+kInterpolatedYoYOptionletVolatilitySurfaceBachelier settlementDays cal bdc dc capFloorPrices index nominalTs slope i1d =+  uncurryNested (qlKInterpolatedYoYOptionletVolatilitySurfaceBachelier settlementDays cal bdc dc capFloorPrices index nominalTs slope) (qlInterpolation i1d)+{#fun qlKInterpolatedYoYOptionletVolatilitySurfaceBachelier{fromIntegral`Word' -- ^settlementDays+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDayCounter*`DayCounter'+  ,withGenTermStructure*`YoYCapFloorTermPriceSurface' -- ^capFloorPrices+  ,withYoYInflationIndex*`YoYInflationIndex' -- ^index+  ,withYieldTermStructure*`GenYieldTermStructure y' -- ^nominalTermStructure+  ,`Double' -- ^slope+  ,`Int',`Int',`Int' -- ^interpolator, approximator, approximatorArg+  ,preErrorCheck-`String'errorCheck*-}->`YoYOptionletVolatilitySurface'peekYoYOptionletVolatilityStructure*#}++-- |Prices CPI cap\/floors by interpolation and put\/call parity off a market strike\/maturity+-- price grid. 'Interpolation2D' chooses the cap\/floor price-grid interpolator. @cPrice@\/+-- @fPrice@ are plain price matrices (rows = strikes, columns = maturities), not quote-linked+-- like 'QuantLib.TermStructure.Volatility.capFloorTermVolSurface's volatility matrix.+cpiCapFloorTermPriceSurface :: Double -- ^nominal+  -> Double -- ^baseRate+  -> (Word, TimeUnit) -- ^observationLag+  -> Calendar -> BusinessDayConvention -> DayCounter+  -> ZeroInflationIndex -> CPIInterpolationType -> GenYieldTermStructure y+  -> [Double] -- ^cStrikes+  -> [Double] -- ^fStrikes+  -> [(Word, TimeUnit)] -- ^cfMaturities+  -> Matrix Double -- ^cPrice+  -> Matrix Double -- ^fPrice+  -> Interpolation2D+  -> IO CPICapFloorTermPriceSurface+cpiCapFloorTermPriceSurface nom baseRate obsLag cal bdc dc zii interp yts cStrikes fStrikes cfMaturities (Matrix cr cc cd) (Matrix fr fc fd) i2d =+  qlCPICapFloorTermPriceSurface nom baseRate obsLag cal bdc dc zii interp yts cStrikes fStrikes maturityNums maturityUnits cr cc cd fr fc fd (fromEnum i2d)+  where (maturityNums, maturityUnits) = unzip cfMaturities+{#fun qlCPICapFloorTermPriceSurface{`Double',`Double',fromEnumQuantity`(Word,TimeUnit)'&+  ,withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter'+  ,withZeroInflationIndex*`ZeroInflationIndex',fromEnumC`CPIInterpolationType'+  ,withYieldTermStructure*`GenYieldTermStructure y'+  ,withDoubleArray*`[Double]'& -- ^cStrikes+  ,withDoubleArray*`[Double]'& -- ^fStrikes+  ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'& -- ^cfMaturities+  ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]' -- ^cPrice+  ,fromIntegral`Word',fromIntegral`Word',withDoubleArrayRaw*`[Double]' -- ^fPrice+  ,`Int' -- ^interpolator2D+  ,preErrorCheck-`String'errorCheck*-}->`CPICapFloorTermPriceSurface'peekCPICapFloorTermPriceSurface*#}++-- |Constant CPI (zero-inflation) volatility surface, no maturity\/strike dependence -- the only+-- concrete leaf bound here, mirroring 'constantYoYOptionletVolatility'. No engine or coupon+-- pricer consumes this in QL 1.43 (see this type's own haddock in "QuantLib.Internal.Type"), so+-- it is queryable via 'cpiVolatility'\/'cpiTotalVariance' but not otherwise wired up.+{#fun qlConstantCPIVolatility as constantCPIVolatility{withQuote*`GenQuote q'+  ,fromIntegral`Word' -- ^settlementDays+  ,withCalendar*`Calendar'+  ,fromEnumC`BusinessDayConvention'+  ,withDayCounter*`DayCounter'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^observationLag+  ,`Frequency'+  ,`Bool' -- ^indexIsInterpolated+  ,preErrorCheck-`String'errorCheck*-}->`CPIVolatilitySurface'peekCPIVolatilitySurface*#}++-- |The volatility for a given maturity date and strike, observed with the given observation+-- lag (or the surface's own lag when 'Nothing').+{#fun qlCPIVolatilitySurfaceVolatility as cpiVolatility{withGenVolatilityTermStructure*`CPIVolatilitySurface'+  ,withDay*`Day'+  ,`Double' -- ^strike+  ,fromMaybeEnumQuantity`Maybe (Word,TimeUnit)'& -- ^obsLag+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The total integrated variance for a given exercise date and strike. As 'cpiVolatility', a+-- 'Nothing' observation lag uses the surface's own.+{#fun qlCPIVolatilitySurfaceTotalVariance as cpiTotalVariance{withGenVolatilityTermStructure*`CPIVolatilitySurface'+  ,withDay*`Day'+  ,`Double' -- ^strike+  ,fromMaybeEnumQuantity`Maybe (Word,TimeUnit)'& -- ^obsLag+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}

@@ -15,6 +15,9 @@   , GenBlackVolTermStructure   , RelinkableBlackVolTermStructure   , CallableBondVolatilityStructure+  , CapFloorTermVolatilityStructure+  , GenCapFloorTermVolatilityStructure+  , CapFloorTermVolCurve   , CapFloorTermVolSurface   , LocalVolTermStructure   , OptionletVolatilityStructure@@ -26,6 +29,13 @@   , RelinkableSwaptionVolatilityStructure   , VolatilityTermStructure   , GenVolatilityTermStructure+  , BlackAtmVolCurve+  , GenBlackAtmVolCurve+  , BlackVolSurface+  , GenBlackVolSurface+  , AbcdAtmVolCurve+  , SabrVolSurface+  , OptionletStripper2    , asVolatilityTermStructure   , asBlackVolTermStructure@@ -34,6 +44,11 @@   , constantOptionletVolatility   , constantOptionletVolatility'   , optionletStripper1+  , optionletStripper2+  , optionletStripper2AsOptionletVolatilityStructure+  , optionletStripper2AtmCapFloorStrikes+  , optionletStripper2AtmCapFloorPrices+  , optionletStripper2SpreadsVol    , impliedVolTermStructure   , blackConstantVol'@@ -85,6 +100,42 @@   , callableBondConstantVolatility   , constantCapFloorTermVolatility'   , constantCapFloorTermVolatility+  , capFloorVolatilityForPeriod+  , capFloorVolatilityForDate+  , capFloorVolatilityForTime+  , capFloorTermVolCurveOptionDates+  , capFloorTermVolCurveOptionTimes+  , capFloorTermVolSurfaceOptionDates+  , capFloorTermVolSurfaceOptionTimes+  , atmVolForPeriod+  , atmVolForDate+  , atmVolForTime+  , atmVarianceForPeriod+  , atmVarianceForDate+  , atmVarianceForTime+  , blackVolSurfaceSmileSectionForPeriod+  , blackVolSurfaceSmileSectionForDate+  , blackVolSurfaceSmileSectionForTime+  , abcdAtmVolCurve+  , abcdAtmVolCurveA+  , abcdAtmVolCurveB+  , abcdAtmVolCurveC+  , abcdAtmVolCurveD+  , abcdAtmVolCurveRmsError+  , abcdAtmVolCurveMaxError+  , abcdAtmVolCurveEndCriteria+  , abcdAtmVolCurveK+  , abcdAtmVolCurveKAtTime+  , abcdAtmVolCurveOptionTenors+  , abcdAtmVolCurveOptionTenorsInInterpolation+  , abcdAtmVolCurveOptionDates+  , abcdAtmVolCurveOptionTimes+  , sabrVolSurface+  , sabrVolSurfaceAtmCurve+  , sabrVolSurfaceVolatilitySpreadsForPeriod+  , sabrVolSurfaceVolatilitySpreadsForDate+  , sabrVolSurfaceIndex+  , sabrVolSurfaceOptionDateFromTenor   , spreadedSwaptionVolatility   , relinkableSwaptionVolatilityStructure   , linkSwaptionVolTo@@ -128,13 +179,11 @@   , atmSmileSection   ) where import QuantLib.Internal-import Foreign.C.Types(CInt)-{#import QuantLib.Time.Calendar#}(BusinessDayConvention) {#import QuantLib.InterestRate#}(VolatilityType) {#import QuantLib.Math#}(EndCriteriaType) {#import QuantLib.Quote#}(DeltaType(..), AtmType(..)) import QuantLib.Internal.Type-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Syntax(deriveOptionsRecord) import QuantLib.Time.Schedule(dayCounter, DayCounterConstructor(..)) @@ -143,6 +192,7 @@ #include "ql.h" #include "qlEnumObjects.h" +{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *DayCounter foreign -> CDayCounter nocode#} {#pointer *QlQuote as Quote foreign -> CQuote' nocode#} {#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#}@@ -160,18 +210,26 @@ {#pointer *QlBlackVolTermStructure as BlackVolTermStructure foreign -> CBlackVolTermStructure' nocode#} {#pointer *QlRelinkableBlackVolTermStructure as RelinkableBlackVolTermStructure foreign -> CRelinkableBlackVolTermStructure' nocode#} {#pointer *QlCallableBondVolatilityStructure as CallableBondVolatilityStructure foreign -> CCallableBondVolatilityStructure' nocode#}+{#pointer *QlCapFloorTermVolatilityStructure as CapFloorTermVolatilityStructure foreign -> CCapFloorTermVolatilityStructure' nocode#}+{#pointer *QlCapFloorTermVolCurve as CapFloorTermVolCurve foreign -> CCapFloorTermVolCurve' nocode#} {#pointer *QlCapFloorTermVolSurface as CapFloorTermVolSurface foreign -> CCapFloorTermVolSurface' nocode#} {#pointer *QlSwaptionVolatilityStructure as SwaptionVolatilityStructure foreign -> CSwaptionVolatilityStructure' nocode#} {#pointer *QlRelinkableSwaptionVolatilityStructure as RelinkableSwaptionVolatilityStructure foreign -> CRelinkableSwaptionVolatilityStructure' nocode#} {#pointer *QlSabrSwaptionVolatilityCube as SabrSwaptionVolatilityCube foreign -> CSabrSwaptionVolatilityCube' nocode#} {#pointer *QlInterpolatedSwaptionVolatilityCube as InterpolatedSwaptionVolatilityCube foreign -> CInterpolatedSwaptionVolatilityCube' nocode#} {#pointer *QlSwapIndex as SwapIndex foreign -> CSwapIndex' nocode#}+{#pointer *QlBlackAtmVolCurve as BlackAtmVolCurve foreign -> CBlackAtmVolCurve' nocode#}+{#pointer *QlBlackVolSurface as BlackVolSurface foreign -> CBlackVolSurface' nocode#}+{#pointer *QlAbcdAtmVolCurve as AbcdAtmVolCurve foreign -> CAbcdAtmVolCurve' nocode#}+{#pointer *QlSabrVolSurface as SabrVolSurface foreign -> CSabrVolSurface' nocode#}+{#pointer *QlInterestRateIndex as InterestRateIndex foreign -> CInterestRateIndex' nocode#}+{#pointer *QlOptionletStripper2 as OptionletStripper2 foreign -> COptionletStripper2 nocode#}  {#enum BlackVarianceSurfaceExtrapolation{} deriving(Show, Eq)#} {#enum ExtendedBlackVarianceSurfaceExtrapolation{} deriving(Show, Eq)#}  -- |'BlackVolatilitySurfaceDelta::SmileInterpolationMethod', local to that class -- not shared--- with any other binding, so declared here rather than in 'QuantLib.Internal.Enum'.+-- with any other binding, so declared here rather than in 'QuantLib.Internal.Common'. {#enum SmileInterpolationMethod{} deriving(Show, Eq)#}  -- |'BlackVolTimeExtrapolation::Type', consumed only by 'blackVolatilitySurfaceDelta' today --@@ -264,28 +322,23 @@  -- |Constant caplet volatility, no time-strike dependence -- floating reference date, floating market data-{#fun qlConstantOptionletVol1 as constantOptionletVolatility'{fromIntegral`Word',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'+{#fun qlConstantOptionletVol1 as constantOptionletVolatility'{fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'   ,`VolatilityType' -- ^type   ,`Double' -- ^displacement   ,preErrorCheck-`String'errorCheck*-}->`OptionletVolatilityStructure'peekOptionletVolatilityStructure*#}  -- |fixed reference date, floating market data-{#fun qlConstantOptionletVolatility as constantOptionletVolatility{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'+{#fun qlConstantOptionletVolatility as constantOptionletVolatility{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'   ,`VolatilityType' -- ^type   ,`Double' -- ^displacement   ,preErrorCheck-`String'errorCheck*-}->`OptionletVolatilityStructure'peekOptionletVolatilityStructure*#} --- |'Nothing' emits 'TimeUnit''s -1 sentinel (same convention as 'fromMaybeEnum'), since 'TimeUnit'--- itself starts at 0 and can't self-sentinel -- used for 'optionletStripper1''s optionletFrequency.-fromMaybeEnumQuantity :: Maybe (Word, TimeUnit) -> (CInt, CInt)-fromMaybeEnumQuantity = maybe (0, -1) fromEnumQuantity- -- |Strips a 'CapFloorTermVolSurface' (quoted cap\/floor term vols) into caplet\/floorlet vols via -- 'OptionletStripper1', immediately wrapping the result behind 'StrippedOptionletAdapter' in one -- step -- 'OptionletStripper1' itself is never exposed as a Haskell type, since none of its own -- getters (capFloorPrices\/capletVols\/etc.) are needed beyond feeding the adapter, per the "bind -- few inspectors" rule.-{#fun qlOptionletStripper1 as optionletStripper1{withGenVolatilityTermStructure*`CapFloorTermVolSurface'+{#fun qlOptionletStripper1 as optionletStripper1{withCapFloorTermVolSurface*`CapFloorTermVolSurface'   ,withIborIndex*`GenIborIndex ibor'   ,fromMaybeDouble`Maybe Double' -- ^switchStrikes   ,`Double' -- ^accuracy@@ -297,6 +350,37 @@   ,fromMaybeEnumQuantity`Maybe (Word, TimeUnit)'& -- ^optionletFrequency   ,preErrorCheck-`String'errorCheck*-}->`OptionletVolatilityStructure'peekOptionletVolatilityStructure*#} +-- |Extends an 'OptionletStripper1' (built internally, never exposed as its own Haskell type --+-- same fusion as 'optionletStripper1') by reconciling it against an ATM 'CapFloorTermVolCurve',+-- producing forward-forward optionlet vols. Unlike 'optionletStripper1', this keeps its own+-- concrete 'OptionletStripper2' object around, since it has real diagnostic getters+-- ('optionletStripper2AtmCapFloorStrikes'\/'optionletStripper2AtmCapFloorPrices'\/+-- 'optionletStripper2SpreadsVol') not reachable through the generic+-- 'OptionletVolatilityStructure' interface. Use 'optionletStripper2AsOptionletVolatilityStructure'+-- to pass one into anything expecting the generic interface.+{#fun qlOptionletStripper2 as optionletStripper2{withCapFloorTermVolSurface*`CapFloorTermVolSurface'+  ,withIborIndex*`GenIborIndex ibor'+  ,fromMaybeDouble`Maybe Double' -- ^switchStrikes+  ,`Double' -- ^accuracy+  ,fromIntegral`Word' -- ^maxIter+  ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discount+  ,`VolatilityType' -- ^type+  ,`Double' -- ^displacement+  ,`Bool' -- ^dontThrow+  ,fromMaybeEnumQuantity`Maybe (Word, TimeUnit)'& -- ^optionletFrequency+  ,withCapFloorTermVolCurve*`CapFloorTermVolCurve' -- ^atmCapFloorTermVolCurve+  ,preErrorCheck-`String'errorCheck*-}->`OptionletStripper2'peekOptionletStripper2*#}++-- |Fresh construction (a 'StrippedOptionletAdapter' wrapping the 'OptionletStripper2' itself),+-- never a cast -- same idiom as 'sabrInterpolatedSmileSectionAsSmileSection'.+{#fun qlOptionletStripper2AsOptionletVolatilityStructure as optionletStripper2AsOptionletVolatilityStructure{withOptionletStripper2*`OptionletStripper2',preErrorCheck-`String'errorCheck*-}->`OptionletVolatilityStructure'peekOptionletVolatilityStructure*#}++{#fun qlOptionletStripper2AtmCapFloorStrikes as optionletStripper2AtmCapFloorStrikes{withOptionletStripper2*`OptionletStripper2',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++{#fun qlOptionletStripper2AtmCapFloorPrices as optionletStripper2AtmCapFloorPrices{withOptionletStripper2*`OptionletStripper2',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++{#fun qlOptionletStripper2SpreadsVol as optionletStripper2SpreadsVol{withOptionletStripper2*`OptionletStripper2',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}+ -- |An optionlet vol surface behind a relinkable handle. The result /is/ an -- 'OptionletVolatilityStructure': pass it anywhere one is expected and everything built on it -- keeps tracking whatever the handle currently points at, so a later 'linkOptionletVolTo'@@ -334,13 +418,13 @@   ,withBlackVolTermStructure*`GenBlackVolTermStructure bv',preErrorCheck-`String'errorCheck*-}->`()'#}  -- |fixed reference date, floating market data-{#fun qlConstantSwaptionVolatility1 as constantSwaptionVolatility'{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'+{#fun qlConstantSwaptionVolatility1 as constantSwaptionVolatility'{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'   ,`VolatilityType' -- ^type   ,`Double' -- ^shift   ,preErrorCheck-`String'errorCheck*-}->`SwaptionVolatilityStructure'peekSwaptionVolatilityStructure*#}  -- |floating reference date, floating market data-{#fun qlConstantSwaptionVolatility as constantSwaptionVolatility{fromIntegral`Word',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'+{#fun qlConstantSwaptionVolatility as constantSwaptionVolatility{fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter'   ,`VolatilityType' -- ^type   ,`Double' -- ^shift   ,preErrorCheck-`String'errorCheck*-}->`SwaptionVolatilityStructure'peekSwaptionVolatilityStructure*#}@@ -536,7 +620,7 @@ -- are the SABR calibration's initial guess and fixed\/free flags; endCriteria\/optimization -- method are left at QuantLib's own internal defaults (a raw, Haskell-finalized EndCriteria or -- OptimizationMethod handle can't safely be stored for this object's full lifetime -- see the--- qlXxxFitting comment in "QuantLib.Internal.Enum" for the same ownership hazard elsewhere).+-- qlXxxFitting comment in "QuantLib.Internal.Common" for the same ownership hazard elsewhere). sabrInterpolatedSmileSection :: Day -- ^optionDate   -> GenQuote q1 -- ^forward   -> [Double] -- ^strikes@@ -665,11 +749,182 @@ {#fun qlCallableBondConstantVolatility as callableBondConstantVolatility{withDay*`Day',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CallableBondVolatilityStructure'peekCallableBondVolatilityStructure*#}  -- |fixed reference date, floating market data-{#fun qlConstantCapFloorTermVolatility1 as constantCapFloorTermVolatility'{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`VolatilityTermStructure'peekVolatilityTermStructure*#}+{#fun qlConstantCapFloorTermVolatility1 as constantCapFloorTermVolatility'{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolatilityStructure'peekCapFloorTermVolatilityStructure*#}  -- |floating reference date, floating market data-{#fun qlConstantCapFloorTermVolatility as constantCapFloorTermVolatility{fromIntegral`Word',withCalendar*`Calendar',`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`VolatilityTermStructure'peekVolatilityTermStructure*#}+{#fun qlConstantCapFloorTermVolatility as constantCapFloorTermVolatility{fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withQuote*`GenQuote q',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolatilityStructure'peekCapFloorTermVolatilityStructure*#} +-- |returns the volatility for a given option tenor and strike+{#fun qlCapFloorTermVolatilityStructureVolatilityForPeriod as capFloorVolatilityForPeriod{withGenCapFloorTermVolatilityStructure*`GenCapFloorTermVolatilityStructure c'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,`Double' -- ^strike+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |returns the volatility for a given option date and strike+{#fun qlCapFloorTermVolatilityStructureVolatilityForDate as capFloorVolatilityForDate{withGenCapFloorTermVolatilityStructure*`GenCapFloorTermVolatilityStructure c'+  ,withDay*`Day' -- ^optionDate+  ,`Double' -- ^strike+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |returns the volatility for a given option time and strike+{#fun qlCapFloorTermVolatilityStructureVolatilityForTime as capFloorVolatilityForTime{withGenCapFloorTermVolatilityStructure*`GenCapFloorTermVolatilityStructure c'+  ,`Double' -- ^optionTime+  ,`Double' -- ^strike+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |The option-tenor grid's dates, calendar-advanced from the curve's reference date.+{#fun qlCapFloorTermVolCurveOptionDates as capFloorTermVolCurveOptionDates{withCapFloorTermVolCurve*`CapFloorTermVolCurve',preArray-`[Day]'&peekDayArray*}->`()'#}++-- |As 'capFloorTermVolCurveOptionDates', in year fractions from the curve's reference date.+{#fun qlCapFloorTermVolCurveOptionTimes as capFloorTermVolCurveOptionTimes{withCapFloorTermVolCurve*`CapFloorTermVolCurve',preArray-`[Double]'&peekDoubleArray*}->`()'#}++-- |The option-tenor grid's dates, calendar-advanced from the surface's reference date.+{#fun qlCapFloorTermVolSurfaceOptionDates as capFloorTermVolSurfaceOptionDates{withCapFloorTermVolSurface*`CapFloorTermVolSurface',preArray-`[Day]'&peekDayArray*}->`()'#}++-- |As 'capFloorTermVolSurfaceOptionDates', in year fractions from the surface's reference date.+{#fun qlCapFloorTermVolSurfaceOptionTimes as capFloorTermVolSurfaceOptionTimes{withCapFloorTermVolSurface*`CapFloorTermVolSurface',preArray-`[Double]'&peekDoubleArray*}->`()'#}++-- |spot at-the-money volatility for a given option tenor+{#fun qlBlackAtmVolCurveAtmVolForPeriod as atmVolForPeriod{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |spot at-the-money volatility for a given option maturity date+{#fun qlBlackAtmVolCurveAtmVolForDate as atmVolForDate{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,withDay*`Day' -- ^maturity+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |spot at-the-money volatility for a given option maturity time+{#fun qlBlackAtmVolCurveAtmVolForTime as atmVolForTime{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,`Double' -- ^maturity+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |spot at-the-money variance for a given option tenor+{#fun qlBlackAtmVolCurveAtmVarianceForPeriod as atmVarianceForPeriod{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |spot at-the-money variance for a given option maturity date+{#fun qlBlackAtmVolCurveAtmVarianceForDate as atmVarianceForDate{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,withDay*`Day' -- ^maturity+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |spot at-the-money variance for a given option maturity time+{#fun qlBlackAtmVolCurveAtmVarianceForTime as atmVarianceForTime{withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,`Double' -- ^maturity+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |returns the smile for a given option tenor+{#fun qlBlackVolSurfaceSmileSectionForPeriod as blackVolSurfaceSmileSectionForPeriod{withGenBlackVolSurface*`GenBlackVolSurface b'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`SmileSection'peekSmileSection*#}++-- |returns the smile for a given option date+{#fun qlBlackVolSurfaceSmileSectionForDate as blackVolSurfaceSmileSectionForDate{withGenBlackVolSurface*`GenBlackVolSurface b'+  ,withDay*`Day' -- ^optionDate+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`SmileSection'peekSmileSection*#}++-- |returns the smile for a given option time+{#fun qlBlackVolSurfaceSmileSectionForTime as blackVolSurfaceSmileSectionForTime{withGenBlackVolSurface*`GenBlackVolSurface b'+  ,`Double' -- ^optionTime+  ,`Bool' -- ^extrapolate+  ,preErrorCheck-`String'errorCheck*-}->`SmileSection'peekSmileSection*#}++-- |Abcd-interpolated at-the-money (no-smile) volatility curve -- floating reference date,+-- floating market data. @inclusionInInterpolationFlag@ selects which quotes feed the ABCD fit+-- (upstream defaults this to all-'True' when omitted; hasquant always requires it explicitly,+-- per the widen-in-place convention for a handful of trailing defaulted params).+abcdAtmVolCurve :: Word -> Calendar -> [(Word, TimeUnit)] -- ^optionTenors+  -> [GenQuote q] -- ^volsHandles+  -> [Bool] -- ^inclusionInInterpolationFlag+  -> BusinessDayConvention -> DayCounter -> IO AbcdAtmVolCurve+abcdAtmVolCurve d c ntenors qs flags bdc dc = qlAbcdAtmVolCurve d c n t qs flags bdc dc+  where (n, t) = unzip ntenors+{#fun qlAbcdAtmVolCurve{fromIntegral`Word',withCalendar*`Calendar',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withQuoteArray*`[GenQuote q]'&,withBoolArray*`[Bool]'&,fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`AbcdAtmVolCurve'peekAbcdAtmVolCurve*#}++{#fun qlAbcdAtmVolCurveA as abcdAtmVolCurveA{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveB as abcdAtmVolCurveB{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveC as abcdAtmVolCurveC{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveD as abcdAtmVolCurveD{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveRmsError as abcdAtmVolCurveRmsError{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveMaxError as abcdAtmVolCurveMaxError{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`Double'#}+{#fun qlAbcdAtmVolCurveEndCriteria as abcdAtmVolCurveEndCriteria{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preErrorCheck-`String'errorCheck*-}->`EndCriteriaType'#}++-- |@k@ adjustment factor at a given time+{#fun qlAbcdAtmVolCurveKAtTime as abcdAtmVolCurveKAtTime{withAbcdAtmVolCurve*`AbcdAtmVolCurve',`Double',preErrorCheck-`String'errorCheck*-}->`Double'#}++-- |@k@ adjustment factors for every option tenor used in interpolation+{#fun qlAbcdAtmVolCurveK as abcdAtmVolCurveK{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++abcdAtmVolCurveOptionTenors :: AbcdAtmVolCurve -> IO [(Word, TimeUnit)]+abcdAtmVolCurveOptionTenors o = do+  (ns, us) <- qlAbcdAtmVolCurveOptionTenors o+  pure $ zip (map fromIntegral ns) (map toEnum us)+{#fun qlAbcdAtmVolCurveOptionTenors{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preArray-`[Int]'&peekIntArray*,preArray-`[Int]'&peekIntArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |As 'abcdAtmVolCurveOptionTenors', but only the tenors actually used in the ABCD fit.+abcdAtmVolCurveOptionTenorsInInterpolation :: AbcdAtmVolCurve -> IO [(Word, TimeUnit)]+abcdAtmVolCurveOptionTenorsInInterpolation o = do+  (ns, us) <- qlAbcdAtmVolCurveOptionTenorsInInterpolation o+  pure $ zip (map fromIntegral ns) (map toEnum us)+{#fun qlAbcdAtmVolCurveOptionTenorsInInterpolation{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preArray-`[Int]'&peekIntArray*,preArray-`[Int]'&peekIntArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++{#fun qlAbcdAtmVolCurveOptionDates as abcdAtmVolCurveOptionDates{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preArray-`[Day]'&peekDayArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |As 'abcdAtmVolCurveOptionDates', in year fractions from the curve's reference date.+{#fun qlAbcdAtmVolCurveOptionTimes as abcdAtmVolCurveOptionTimes{withAbcdAtmVolCurve*`AbcdAtmVolCurve',preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |SABR-smile 'BlackVolSurface' built from an interest-rate index, an ATM 'BlackAtmVolCurve', and+-- per-tenor ATM-rate spreads\/vol-spread matrix. @volSpreads@'s rows follow @optionTenors@ and+-- columns follow @atmRateSpreads@ (same row\/column convention as 'sabrSwaptionVolatilityCube's+-- @volSpreads@).+sabrVolSurface :: GenInterestRateIndex ix -> GenBlackAtmVolCurve b -> [(Word, TimeUnit)] -- ^optionTenors+  -> [Double] -- ^atmRateSpreads+  -> Matrix (GenQuote q) -- ^volSpreads+  -> IO SabrVolSurface+sabrVolSurface ix atm ntenors spreads (Matrix vr vc vd) =+  qlSabrVolSurface ix atm n t spreads vr vc vd+  where (n, t) = unzip ntenors+{#fun qlSabrVolSurface{withInterestRateIndex*`GenInterestRateIndex ix',withGenBlackAtmVolCurve*`GenBlackAtmVolCurve b'+  ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&+  ,withDoubleArray*`[Double]'&+  ,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]'+  ,preErrorCheck-`String'errorCheck*-}->`SabrVolSurface'peekSabrVolSurface*#}++-- |the 'BlackAtmVolCurve' this surface's ATM level is anchored to+{#fun qlSabrVolSurfaceAtmCurve as sabrVolSurfaceAtmCurve{withSabrVolSurface*`SabrVolSurface',preErrorCheck-`String'errorCheck*-}->`BlackAtmVolCurve'peekBlackAtmVolCurve*#}++-- |per-@atmRateSpreads@-column volatility spreads for a given option tenor+{#fun qlSabrVolSurfaceVolatilitySpreadsForPeriod as sabrVolSurfaceVolatilitySpreadsForPeriod{withSabrVolSurface*`SabrVolSurface'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |as 'sabrVolSurfaceVolatilitySpreadsForPeriod', for a given option date+{#fun qlSabrVolSurfaceVolatilitySpreadsForDate as sabrVolSurfaceVolatilitySpreadsForDate{withSabrVolSurface*`SabrVolSurface'+  ,withDay*`Day' -- ^optionDate+  ,preArray-`[Double]'&peekDoubleArray*,preErrorCheck-`String'errorCheck*-}->`()'#}++-- |the interest rate index this surface was built from (folded in from upstream's+-- @InterestRateVolSurface@, not given its own hierarchy level here -- see 'SabrVolSurface').+{#fun qlSabrVolSurfaceIndex as sabrVolSurfaceIndex{withSabrVolSurface*`SabrVolSurface',preErrorCheck-`String'errorCheck*-}->`InterestRateIndex'peekInterestRateIndex*#}++-- |as 'sabrVolSurfaceIndex', converts an option tenor to its option date (folded in from+-- @InterestRateVolSurface@)+{#fun qlSabrVolSurfaceOptionDateFromTenor as sabrVolSurfaceOptionDateFromTenor{withSabrVolSurface*`SabrVolSurface'+  ,fromEnumQuantity`(Word,TimeUnit)'& -- ^optionTenor+  ,preErrorCheck-`String'errorCheck*-}->`Day'toDay#}+ -- |A 'SwaptionVolatilityStructure' whose volatility at every point is @source@'s plus @spread@ -- (which may change over time, since it's a live 'GenQuote' rather than a fixed number) {#fun qlSpreadedSwaptionVolatility as spreadedSwaptionVolatility{withSwaptionVolatilityStructure*`GenSwaptionVolatilityStructure sv',withQuote*`GenQuote q',preErrorCheck-`String'errorCheck*-}->`SwaptionVolatilityStructure'peekSwaptionVolatilityStructure*#}@@ -712,14 +967,14 @@ {#fun qlImpliedVolTermStructure as impliedVolTermStructure{withBlackVolTermStructure*`GenBlackVolTermStructure bv',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`BlackVolTermStructure'peekBlackVolTermStructure*#}  -- |fixed reference date, floating market data-capFloorTermVolCurve' :: Day -> Calendar -> BusinessDayConvention -> [(Word, TimeUnit, GenQuote q)] -> DayCounter -> IO VolatilityTermStructure+capFloorTermVolCurve' :: Day -> Calendar -> BusinessDayConvention -> [(Word, TimeUnit, GenQuote q)] -> DayCounter -> IO CapFloorTermVolCurve capFloorTermVolCurve' d c bd ntq = qlCapFloorTermVolCurve1 d c bd n t q where (n, t, q) = unzip3 ntq-{#fun qlCapFloorTermVolCurve1{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withQuoteArray*`[GenQuote q]'&,withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`VolatilityTermStructure'peekVolatilityTermStructure*#}+{#fun qlCapFloorTermVolCurve1{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withQuoteArray*`[GenQuote q]'&,withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolCurve'peekCapFloorTermVolCurve*#}  -- |floating reference date, floating market data-capFloorTermVolCurve :: Word -> Calendar -> BusinessDayConvention -> [(Word, TimeUnit, GenQuote q)] -> DayCounter -> IO VolatilityTermStructure+capFloorTermVolCurve :: Word -> Calendar -> BusinessDayConvention -> [(Word, TimeUnit, GenQuote q)] -> DayCounter -> IO CapFloorTermVolCurve capFloorTermVolCurve d c bd ntq = qlCapFloorTermVolCurve d c bd n t q where (n, t, q) = unzip3 ntq-{#fun qlCapFloorTermVolCurve{fromIntegral`Word',withCalendar*`Calendar',`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withQuoteArray*`[GenQuote q]'&,withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`VolatilityTermStructure'peekVolatilityTermStructure*#}+{#fun qlCapFloorTermVolCurve{fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withQuoteArray*`[GenQuote q]'&,withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolCurve'peekCapFloorTermVolCurve*#}  -- |A Black volatility curve built from time-dependent (ATM) market vols, interpolating on total -- variance (linear by default, or the given 'Interpolation') -- no strike dependence; see@@ -821,7 +1076,7 @@   -> Matrix (GenQuote q) -- ^volatilities   -> DayCounter -> IO CapFloorTermVolSurface capFloorTermVolSurface d c bd t s (Matrix mr mc md) = qlCapFloorTermVolSurface d c bd pl pu s mr mc md where (pl, pu) = unzip t-{#fun qlCapFloorTermVolSurface{fromIntegral`Word',withCalendar*`Calendar',`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withDoubleArray*`[Double]'&,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolSurface'peekCapFloorTermVolSurface*#}+{#fun qlCapFloorTermVolSurface{fromIntegral`Word',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withDoubleArray*`[Double]'&,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolSurface'peekCapFloorTermVolSurface*#}  -- |fixed reference date, floating market data capFloorTermVolSurface' :: Day -> Calendar -> BusinessDayConvention -> [(Word, TimeUnit)] -- ^optionTenors@@ -829,7 +1084,7 @@   -> Matrix (GenQuote q) -- ^volatilities   -> DayCounter -> IO CapFloorTermVolSurface capFloorTermVolSurface' d c bd t s (Matrix mr mc md) = qlCapFloorTermVolSurface1 d c bd pl pu s mr mc md where (pl, pu) = unzip t-{#fun qlCapFloorTermVolSurface1{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withDoubleArray*`[Double]'&,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolSurface'peekCapFloorTermVolSurface*#}+{#fun qlCapFloorTermVolSurface1{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention',withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&,withDoubleArray*`[Double]'&,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]',withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`CapFloorTermVolSurface'peekCapFloorTermVolSurface*#}  -- |fixed reference date, floating market data. Pass an empty 'Matrix' (@Matrix 0 0 []@) for @shifts@ -- when no shift is needed -- upstream treats a zero-row shift matrix as all-zero.@@ -845,7 +1100,7 @@ swaptionVolatilityMatrix' d c bdc ot st (Matrix vr vc vd) dc' fe ty (Matrix sr sc sd) =   qlSwaptionVolatilityMatrix d c bdc opl opu spl spu vr vc vd dc' fe ty sr sc sd   where (opl, opu) = unzip ot; (spl, spu) = unzip st-{#fun qlSwaptionVolatilityMatrix{withDay*`Day',withCalendar*`Calendar',`BusinessDayConvention'+{#fun qlSwaptionVolatilityMatrix{withDay*`Day',withCalendar*`Calendar',fromEnumC`BusinessDayConvention'   ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&   ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&   ,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]'@@ -867,7 +1122,7 @@ swaptionVolatilityMatrix c bdc ot st (Matrix vr vc vd) dc' fe ty (Matrix sr sc sd) =   qlSwaptionVolatilityMatrix1 c bdc opl opu spl spu vr vc vd dc' fe ty sr sc sd   where (opl, opu) = unzip ot; (spl, spu) = unzip st-{#fun qlSwaptionVolatilityMatrix1{withCalendar*`Calendar',`BusinessDayConvention'+{#fun qlSwaptionVolatilityMatrix1{withCalendar*`Calendar',fromEnumC`BusinessDayConvention'   ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&   ,withIntArray*`[Word]'&,withEnumArray*`[TimeUnit]'&   ,fromIntegral`Word',fromIntegral`Word',withQuoteArrayRaw*`[GenQuote q]'

@@ -99,7 +99,7 @@   , oisRateHelperSwap   ) where import QuantLib.Internal hiding(maxDate)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.Syntax(deriveOptionsRecord) import Language.Haskell.TH(mkName) import Language.Haskell.TH.Lib(varT)@@ -108,7 +108,6 @@ import qualified QuantLib.Instrument.Bond as Bond (BondPriceType) {#import QuantLib.InterestRate#}(Compounding) {#import QuantLib.CashFlow#}(RateAveragingType(..))-{#import QuantLib.Time.Calendar#}(BusinessDayConvention(..)) import QuantLib.Time.Calendar(calendar, CalendarConstructor(..)) import QuantLib.Internal.Type {#import QuantLib.Time.Schedule#}(Frequency(..), DateGenerationRule(..))@@ -124,6 +123,7 @@ -- if you put all pointer declarations in a separate module -- ch2s will not attach finalizers to foreign ptrs in other modules -- I don't want to create extra modules just to workaround the issue with cyclic dependencies and this will not help with finalizers anyway+{#pointer *Calendar foreign -> CCalendar nocode#} {#pointer *QlIborIndex as IborIndex foreign -> CIborIndex' nocode#} {#pointer *QlOvernightIndex as OvernightIndex foreign -> COvernightIndex' nocode#} {#pointer *QlBMAIndex as BMAIndex foreign -> CBMAIndex' nocode#}@@ -221,7 +221,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter',preErrorCheck-`String'errorCheck*-}->`RateHelper'peekRateHelper*#} @@ -230,7 +230,7 @@ {#fun qlFixedRateBondHelper as fixedRateBondHelper{withQuote*`GenQuote q',fromIntegral`Word' -- ^settlementDays   ,`Double' -- ^faceAmount   ,withSchedule*`Schedule',withDoubleArray*`[Double]'& -- ^coupons-  ,withDayCounter*`DayCounter',`BusinessDayConvention' -- ^paymentConvention+  ,withDayCounter*`DayCounter',fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,`Double' -- ^redemption   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,preErrorCheck-`String'errorCheck*-}->`BondHelper'peekBondHelper*#}@@ -246,7 +246,7 @@   ,fromEnumC`CPIInterpolationType' -- ^observationInterpolation   ,withSchedule*`Schedule',withDoubleArray*`[Double]'& -- ^coupons   ,withDayCounter*`DayCounter' -- ^accrualDayCounter-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,withMaybeDay*`Maybe Day' -- ^issueDate   ,withCalendar*`Calendar' -- ^paymentCalendar   ,preErrorCheck-`String'errorCheck*-}->`BondHelper'peekBondHelper*#}@@ -264,7 +264,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,withCalendar*`Calendar' -- ^calendar   ,`Frequency' -- ^fixedFrequency-  ,`BusinessDayConvention' -- ^fixedConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixedConvention   ,withDayCounter*`DayCounter' -- ^fixedDayCount   ,withIborIndex*`GenIborIndex ibor' -- ^iborIndex   ,withMaybeQuote*`Maybe (GenQuote q2)' -- ^spread@@ -321,7 +321,7 @@   ,fromIntegral`Word' -- ^monthsToEnd   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter'   ,`PillarChoice' -- ^pillar@@ -338,7 +338,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^settlementDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withIborIndex*`GenIborIndex ibor1' -- ^baseIndex   ,withIborIndex*`GenIborIndex ibor2' -- ^otherIndex@@ -353,7 +353,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^settlementDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withOvernightIborIndex*`OvernightIborIndex' -- ^baseIndex   ,withIborIndex*`GenIborIndex ibor' -- ^otherIndex@@ -368,7 +368,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withIborIndex*`GenIborIndex ibor1' -- ^baseCurrencyIndex   ,withIborIndex*`GenIborIndex ibor2' -- ^quoteCurrencyIndex@@ -387,7 +387,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,withIborIndex*`GenIborIndex ibor1' -- ^baseCurrencyIndex   ,withIborIndex*`GenIborIndex ibor2' -- ^quoteCurrencyIndex@@ -407,7 +407,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,`Frequency' -- ^fixedFrequency   ,withDayCounter*`DayCounter' -- ^fixedDayCount@@ -425,7 +425,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^fixingDays   ,withCalendar*`Calendar' -- ^calendar-  ,`BusinessDayConvention' -- ^convention+  ,fromEnumC`BusinessDayConvention' -- ^convention   ,`Bool' -- ^endOfMonth   ,`Bool' -- ^isFxBaseCurrencyCollateralCurrency   ,withYieldTermStructure*`GenYieldTermStructure y' -- ^collateralCurve@@ -479,7 +479,7 @@   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountingCurve   ,`Bool' -- ^telescopicValueDates   ,fromIntegral`Int' -- ^paymentLag-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,`Frequency' -- ^paymentFrequency   ,withCalendar*`Calendar' -- ^paymentCalendar   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^forwardStart@@ -496,7 +496,7 @@   ,withMaybeFloatingRateCouponPricer*`Maybe FloatingRateCouponPricer' -- ^pricer   ,`DateGenerationRule' -- ^rule   ,withCalendar*`Calendar' -- ^overnightCalendar-  ,`BusinessDayConvention' -- ^convention (q1.k.q1. overnightConvention)+  ,fromEnumC`BusinessDayConvention' -- ^convention (q1.k.q1. overnightConvention)   ,preErrorCheck-`String'errorCheck*-}->`OISRateHelper'peekOISRateHelper*#} {#fun qlOISRateHelper2 as oisRateHelper2_{withDay*`Day' -- ^startDate   ,withDay*`Day' -- ^endDate@@ -505,7 +505,7 @@   ,withMaybeYieldTermStructure*`Maybe (GenYieldTermStructure y)' -- ^discountingCurve   ,`Bool' -- ^telescopicValueDates   ,fromIntegral`Int' -- ^paymentLag-  ,`BusinessDayConvention' -- ^paymentConvention+  ,fromEnumC`BusinessDayConvention' -- ^paymentConvention   ,`Frequency' -- ^paymentFrequency   ,withCalendar*`Calendar' -- ^paymentCalendar   ,withMaybeQuote*`Maybe (GenQuote q2)' -- ^overnightSpread@@ -521,7 +521,7 @@   ,withMaybeFloatingRateCouponPricer*`Maybe FloatingRateCouponPricer' -- ^pricer   ,`DateGenerationRule' -- ^rule   ,withCalendar*`Calendar' -- ^overnightCalendar-  ,`BusinessDayConvention' -- ^convention (q1.k.q1. overnightConvention)+  ,fromEnumC`BusinessDayConvention' -- ^convention (q1.k.q1. overnightConvention)   ,preErrorCheck-`String'errorCheck*-}->`OISRateHelper'peekOISRateHelper*#}  oisRateHelperFull :: Word -> (Int, TimeUnit) -> GenQuote q -> OvernightIborIndex@@ -576,7 +576,7 @@   ,fromEnumQuantity`(Int,TimeUnit)'& -- ^tenor   ,fromIntegral`Word' -- ^settlementDAys   ,withCalendar*`Calendar',fromEnumQuantity`(Int,TimeUnit)'& -- ^bmpPeriod-  ,`BusinessDayConvention',withDayCounter*`DayCounter',withBMAIndex*`BMAIndex',withIborIndex*`GenIborIndex ibor',preErrorCheck-`String'errorCheck*-}->`RateHelper'peekRateHelper*#}+  ,fromEnumC`BusinessDayConvention',withDayCounter*`DayCounter',withBMAIndex*`BMAIndex',withIborIndex*`GenIborIndex ibor',preErrorCheck-`String'errorCheck*-}->`RateHelper'peekRateHelper*#}  -- |Rate helper for bootstrapping from multiple-resets swap quotes (a floating leg that resets -- several times per fixed-leg coupon period).@@ -590,7 +590,7 @@   ,`Double' -- ^spread   ,`Frequency' -- ^fixedFrequency   ,withDayCounter*`DayCounter' -- ^fixedDayCount-  ,`BusinessDayConvention' -- ^fixedConvention+  ,fromEnumC`BusinessDayConvention' -- ^fixedConvention   ,preErrorCheck-`String'errorCheck*-}->`RateHelper'peekRateHelper*#}  -- |Rate helper for bootstrapping over FRA rates, taking its fixing/day-count conventions from an@@ -607,7 +607,7 @@ {#fun qlFraRateHelper2 as fraRateHelper'{withQuote*`GenQuote q',fromEnumQuantity`(Int,TimeUnit)'& -- ^periodToStart   ,fromIntegral`Word' -- ^lengthInMonths   ,fromIntegral`Word' -- ^fixingDays-  ,withCalendar*`Calendar',`BusinessDayConvention',`Bool' -- ^endOfMonth+  ,withCalendar*`Calendar',fromEnumC`BusinessDayConvention',`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter'   ,`PillarChoice' -- ^pillar   ,withMaybeDay*`Maybe Day' -- ^customPillarDate@@ -639,7 +639,7 @@ -- calendar\/convention\/day-counter conventions. {#fun qlFuturesRateHelper as futuresRateHelper{withQuote*`GenQuote q1',withDay*`Day' -- ^immDate   ,fromIntegral`Word' -- ^lengthInMonths-  ,withCalendar*`Calendar',`BusinessDayConvention',`Bool' -- ^endOfMonth+  ,withCalendar*`Calendar',fromEnumC`BusinessDayConvention',`Bool' -- ^endOfMonth   ,withDayCounter*`DayCounter',withMaybeQuote*`Maybe (GenQuote q2)' -- ^convexityAdjustment   ,`FuturesType' -- ^type   ,preErrorCheck-`String'errorCheck*-}->`RateHelper'peekRateHelper*#}@@ -674,13 +674,16 @@ -- and stays linked to 'baseCurve'. {#fun qlImpliedTermStructure as impliedTermStructure{withYieldTermStructure*`GenYieldTermStructure y',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`YieldTermStructure'peekYieldTermStructure*#} --- |A yield curve with a vector of zero-yield spreads added to 'baseCurve', interpolated linearly--- between the given dates. Remains linked to changes in 'baseCurve' or the spread quotes.+-- |A yield curve with a vector of zero-yield spreads added to 'baseCurve', interpolating+-- between the given dates with the given 'Interpolation'. Remains linked to changes in+-- 'baseCurve' or the spread quotes. piecewiseZeroSpreadedTermStructure :: GenYieldTermStructure y   -> [(Day, GenQuote q)]  -- ^spreads-  -> Compounding -> Frequency -> IO YieldTermStructure-piecewiseZeroSpreadedTermStructure ts qd = qlPiecewiseZeroSpreadedTermStructure ts qs ds where (ds, qs) = unzip qd-{#fun qlPiecewiseZeroSpreadedTermStructure{withYieldTermStructure*`GenYieldTermStructure y',withQuoteArray*`[GenQuote q]'&,withDayArray*`[Day]'&,`Compounding',`Frequency',preErrorCheck-`String'errorCheck*-}->`YieldTermStructure'peekYieldTermStructure*#}+  -> Compounding -> Frequency -> Interpolation -> IO YieldTermStructure+piecewiseZeroSpreadedTermStructure ts qd c f i = uncurryNested (qlPiecewiseZeroSpreadedTermStructure ts qs ds c f) (qlInterpolation i)+  where (ds, qs) = unzip qd+{#fun qlPiecewiseZeroSpreadedTermStructure{withYieldTermStructure*`GenYieldTermStructure y',withQuoteArray*`[GenQuote q]'&,withDayArray*`[Day]'&,`Compounding',`Frequency'+  ,`Int',`Int',`Int',preErrorCheck-`String'errorCheck*-}->`YieldTermStructure'peekYieldTermStructure*#}  -- |Quanto term structure, modelling the quanto effect in option pricing. Stays linked to all -- four inputs.

@@ -21,7 +21,7 @@ import QuantLib.Internal import QuantLib.Internal.Type {#import QuantLib.Time.Date#}(Weekday)-import QuantLib.Internal.Enum+import QuantLib.Internal.Common import QuantLib.Internal.CalendarEnum  #include "qlTypesC2HS.h"@@ -32,8 +32,6 @@  {#pointer *Calendar foreign -> CCalendar nocode#} -{#enum BusinessDayConvention{} deriving(Show, Eq)#}- -- |Constructs the calendar for the given country, with an optional market variant. {#fun qlCalendar{`Int',`Int',preErrorCheck-`String'errorCheck*-}->`Calendar'peekCalendar*#} @@ -45,11 +43,11 @@ calendar x = uncurry qlCalendar $ mapCalendar x  -- |Adjusts a non-business day to the appropriate near business day with respect to the given convention-{#fun qlCalendarAdjust as adjust{withCalendar*`Calendar',withDay*`Day',`BusinessDayConvention'}->`Day'toDay#}+{#fun qlCalendarAdjust as adjust{withCalendar*`Calendar',withDay*`Day',fromEnumC`BusinessDayConvention',preErrorCheck-`String'errorCheck*-}->`Day'toDay#}  -- |Advances the given date of the given number of business days and returns the result using business day convention and the EOM flag-{#fun qlCalendarAdvance as advance{withCalendar*`Calendar',withDay*`Day',fromEnumQuantity`(Int,TimeUnit)'&,`BusinessDayConvention',`Bool' -- ^endOfMonth-  }->`Day'toDay#}+{#fun qlCalendarAdvance as advance{withCalendar*`Calendar',withDay*`Day',fromEnumQuantity`(Int,TimeUnit)'&,fromEnumC`BusinessDayConvention',`Bool' -- ^endOfMonth+  ,preErrorCheck-`String'errorCheck*-}->`Day'toDay#}  -- |Adds a date to the set of holidays for the given calendar. {#fun qlCalendarAddHoliday as addHoliday{withCalendar*`Calendar',withDay*`Day',preErrorCheck-`String'errorCheck*-}->`()'#}

@@ -64,7 +64,7 @@ import Data.Time.LocalTime(localDay, getTimeZone, utcToLocalTime)  import QuantLib.Internal-import QuantLib.Internal.Enum+import QuantLib.Internal.Common  #include "qlTypesC2HS.h" #include "ql.h"