quantlib-users Mailing List for QuantLib (Page 2)

Hi, see <https://github.com/lballabio/QuantLib/pull/2474> recently opened.

Luigi

On Tue, Sep 23, 2025 at 2:51 PM "范博伟" <hz...@si...> wrote:

> Hi Luigi,
>
> We did namage to modify the OvernightIndexedSwap and related methods in
> C++ and build the FR007 swap class, mainly using xuruilong's example as
> reference.
>
> And yes, FR007 is a main bench market interest rate in China Inter Bank
> market. It's the real funding rate for most institution in the market.
> FR007 IRS is the most traded IRS in China IB. It's reset every 1 week as
> the tenor of FR007.
>
> We have most modeling work done in Python. It would be really handy if we
> can do the calibration in Python too.
>
> For now, I managed to write a python version utilizing the FRARateHelper
> for the quotes and iteratively bootstrapping instruments. Error might be
> acceptable for some trading purpose.
>
>
>
>
> ----- 原始邮件 -----
> 发件人：Luigi Ballabio <lui...@gm...>
> 收件人：hz...@si...
> 抄送人：quantlib-users <qua...@li...>
> 主题：Re: Re: [Quantlib-users] Bootstrap non fixed-reset-number floating leg
> interest rate swap
> 日期：2025年09月23日 14点35分
>
> Hello,
>     no, there's no such class.  One should inherit from RateHelper and
> code it in C++.  Are these instruments the way rates are quoted in your
> market?
>
> Best,
>     Luigi
>
>
> On Mon, Sep 22, 2025 at 4:40 PM "范博伟" <hz...@si...> wrote:
>
> Hi Luigi,
>
> Thanks for the reply!
>
> I check the MultipleResetCoupon and I think I can use that and put a swap
> together by passing fixedLeg and floatingLeg to ql.Swap, or
> ql.NonstandardSwap.
>
> However, how can I bootstrap from those swaps for discounting curve? I
> think SwapRateHelper won't take swap as input.
>
> Is there any available helper class would help in this case?
>
> Thanks.
>
>
> ----- 原始邮件 -----
> 发件人：Luigi Ballabio <lui...@gm...>
> 收件人：hz...@si...
> 抄送人：quantlib-users <qua...@li...>
> 主题：Re: [Quantlib-users] Bootstrap non fixed-reset-number floating leg
> interest rate swap
> 日期：2025年09月22日 14点24分
>
> Hello,
>     instead of using MultipleResetsLeg, you can instantiate the underlying
> MultipleResetCoupon instances directly.  Each coupon can take its set of
> reset dates explicitly.
>
> Hope this helps,
>     Luigi
>
>
> On Sun, Sep 14, 2025 at 3:10 PM "范博伟" <hz...@si...> wrote:
>
> Hi there,
>
> I am trying to use python to calibrate interest rate swap in China, which
> is a bit non-standard as the floating leg is reset weekly and paid
> quarterly.
>
> I am tring to the use the MultipleResetsLeg for the floating leg to
> construct a swap  and do the calibartoin. However, the MultipleResetsLeg
> has a fixed number of resets per coupon while in real case, the number of
> resets is not fixed. It could be 12-14 resets per coupon due to the
> convention and calendar.
>
> In C++, we could build the swap from scratch but not sure if we can do
> that in python, since some api is not exposed.
>
> Could anyone help me with the issue. Thanks.
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>
>

It looks like you're not using QuantLib 1.41 (the release you find at <
https://github.com/lballabio/QuantLib/releases/tag/v1.41> but a checkout of
the git repository, which is more recent than 1.41 and removed a few
deprecated classes.  If that's the case, you also need a checkout of the
git repository for QuantLib-SWIG.

Luigi


On Wed, Mar 11, 2026 at 12:38 PM Chirag Desai <chi...@ya...>
wrote:

> Hi
>
> I have been trying to build the Python wheel as advised on
>
> https://www.quantlib.org/install/windows-python.shtml
>
> I used latest Quantlib 1.41 and Quantlib-SWIG 1.41 as well.
>
> 1) I set up the environment variables
>
> [image: Inline image]
>
> 2) This works fine
> [image: Inline image]
>
> 3) I get an error message which I have attached in Error.txt but its along
> the line of incompatible Quantlib /SWIG versions as some of the below have
> been deprecated.
>
> C:\local\QuantLib-SWIG-1.41\Python>python -m build --wheel --no-isolation
>
> [image: Inline image]
> Any help pls ?
> Thank you
> Chirag
>
>
>
>
>
>

Hi 
I have been trying to build the Python wheel as advised on 
https://www.quantlib.org/install/windows-python.shtml 
I used latest Quantlib 1.41 and Quantlib-SWIG 1.41 as well.
1) I set up the environment variables 


2) This works fine 

3) I get an error message which I have attached in Error.txt but its along the line of incompatible Quantlib /SWIG versions as some of the below have been deprecated.
C:\local\QuantLib-SWIG-1.41\Python>python -m build --wheel --no-isolation


Any help pls ?Thank you Chirag

As I and Peter wrote earlier, you do not need native OIS support to 
price a Bermudan OIS option. You can use the QuantLib type 
VanillaSwaption. It references an underlying ibor swap with a fixed 
maturity date. If you need an OIS underlying, you can equivalently use 
a VanillaSwap that references a custom ibor of which the tenor equals 
the period of the fixed leg of the OIS. Then you will get the exact same 
price.

On 3/9/2026 4:18 AM, Rich Amaya via QuantLib-users wrote:
> Hi Peter and Daniel,
>
> Thanks for the clarification Peter. I’ve opened a GitHub issue to 
> track adding native OIS support to the FD Bermudan swaption engines.
>
> Best,
> Rich
>
>> On Mar 8, 2026, at 1:23 PM, Peter Caspers <pca...@gm...> wrote:
>>
>> Hi Rich and Daniel,
>>
>> Apologies, I misunderstood the trade terms - I thought we were 
>> talking about a swaption exercising into an underlying swap with 
>> constant maturity measured from the respective exercise date!
>>
>> Thanks for clarifying.
>>
>> Best
>> Peter
>>
>> On Sun, 8 Mar 2026 at 18:25, Rich Amaya <ric...@ma...> wrote:
>>
>>     Hi Daniel,
>>
>>     As Peter says, QuantLib doesn’t have a Bermudan swaption with an
>>     OIS underlying. However, you can use a VanillaSwap as a proxy for
>>     the underlying and price it with the existing Bermudan
>>     infrastructure.
>>
>>     The existing QuantLib examples are actually the co-terminal case
>>     you need - a single swap with a fixed maturity date, with
>>     exercise dates at each fixed coupon accrual start. When exercised
>>     at a later date, only the remaining coupons contribute to the
>>     payoff, so the effective swap tenor is shorter while the maturity
>>     date stays the same. See
>>     Examples/BermudanSwaption/BermudanSwaption.cpp (line 248 onward)
>>     and test-suite/bermudanswaption.cpp.
>>
>>     The setup is: create a VanillaSwap with your fixed maturity date,
>>     build a BermudanExercise from the fixed leg accrual start dates
>>     (your 5 exercise dates), and price with FdHullWhiteSwaptionEngine.
>>
>>     Under a one-factor Hull-White model with a single forwarding
>>     curve, this VanillaSwap proxy is exact - the compound of daily
>>     overnight forwards equals the period forward rate on the same
>>     curve, so VanillaSwap and OIS floating legs produce identical NPVs.
>>
>>     *_References_*
>>     - Brigo & Mercurio, “Interest Rate Model — Theory and Practice”
>>     (Ch. 3 for HW model, tree-based pricing)
>>     - Hull, “Options, Futures, and Other Derivatives,” 11th ed. (Ch.
>>     31-32 for short-rate models and trinomial trees)
>>
>>     I hope that helps!
>>
>>     Best,
>>     Rich
>>
>>
>>>     On Mar 8, 2026, at 6:53 AM, Daniel Lobo
>>>     <dan...@gm...> wrote:
>>>
>>>     Hi Peter,
>>>
>>>     Thanks for your response.
>>>
>>>     Do you know if there is any online resource available to get
>>>     guidance
>>>     on this pricing and if QuantLib has any pipeline to implement this
>>>     Instrument?
>>>
>>>     BR,
>>>
>>>     On Sun, 8 Mar 2026 at 00:15, Peter Caspers
>>>     <pca...@gm...> wrote:
>>>>
>>>>     Hi Daniel,
>>>>
>>>>     I don't think we have this variant of a Bermudan swaption in
>>>>     QuantLib.
>>>>
>>>>     Best
>>>>     Peter
>>>>
>>>>
>>>>     On Sat, 7 Mar 2026 at 09:55, Daniel Lobo
>>>>     <dan...@gm...> wrote:
>>>>>
>>>>>     Hi,
>>>>>
>>>>>     I need to price a Bermudian type swaption which has multiple
>>>>>     maturity
>>>>>     dates (total number 5) however underlying swap is OIS, which has a
>>>>>     fixed maturity date.
>>>>>
>>>>>     I found some swaption examples, where underlying swap has only
>>>>>     fixed
>>>>>     maturity term, not fixed maturity date. Therefore in my case,
>>>>>     at eah
>>>>>     exercise date, underlying swap's maturity term is lesser.
>>>>>
>>>>>     Can you please point if there any such quantlib implementation or
>>>>>     example to price such swaption based on hull white model?
>>>>>
>>>>>
>>>>>     _______________________________________________
>>>>>     QuantLib-users mailing list
>>>>>     Qua...@li...
>>>>>     https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>>
>>>
>>>     _______________________________________________
>>>     QuantLib-users mailing list
>>>     Qua...@li...
>>>     https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>
>
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users

-- 
This email has been checked for viruses by Avast antivirus software.
www.avast.com

Hi Peter and Daniel,

Thanks for the clarification Peter. I’ve opened a GitHub issue to track adding native OIS support to the FD Bermudan swaption engines.

Best,
Rich

> On Mar 8, 2026, at 1:23 PM, Peter Caspers <pca...@gm...> wrote:
> 
> Hi Rich and Daniel,
> 
> Apologies, I misunderstood the trade terms - I thought we were talking about a swaption exercising into an underlying swap with constant maturity measured from the respective exercise date!
> 
> Thanks for clarifying.
> 
> Best
> Peter
> 
> On Sun, 8 Mar 2026 at 18:25, Rich Amaya <ric...@ma... <mailto:ric...@ma...>> wrote:
>> Hi Daniel,
>> 
>> As Peter says, QuantLib doesn’t have a Bermudan swaption with an OIS underlying. However, you can use a VanillaSwap as a proxy for the underlying and price it with the existing Bermudan infrastructure.
>> 
>> The existing QuantLib examples are actually the co-terminal case you need - a single swap with a fixed maturity date, with exercise dates at each fixed coupon accrual start. When exercised at a later date, only the remaining coupons contribute to the payoff, so the effective swap tenor is shorter while the maturity date stays the same. See Examples/BermudanSwaption/BermudanSwaption.cpp (line 248 onward) and test-suite/bermudanswaption.cpp.
>> 
>> The setup is: create a VanillaSwap with your fixed maturity date, build a BermudanExercise from the fixed leg accrual start dates (your 5 exercise dates), and price with FdHullWhiteSwaptionEngine.
>> 
>> Under a one-factor Hull-White model with a single forwarding curve, this VanillaSwap proxy is exact - the compound of daily overnight forwards equals the period forward rate on the same curve, so VanillaSwap and OIS floating legs produce identical NPVs.
>> 
>> References
>> - Brigo & Mercurio, “Interest Rate Model — Theory and Practice” (Ch. 3 for HW model, tree-based pricing)
>> - Hull, “Options, Futures, and Other Derivatives,” 11th ed. (Ch. 31-32 for short-rate models and trinomial trees)
>> 
>> I hope that helps!
>> 
>> Best,
>> Rich
>> 
>> 
>>> On Mar 8, 2026, at 6:53 AM, Daniel Lobo <dan...@gm... <mailto:dan...@gm...>> wrote:
>>> 
>>> Hi Peter,
>>> 
>>> Thanks for your response.
>>> 
>>> Do you know if there is any online resource available to get guidance
>>> on this pricing and if QuantLib has any pipeline to implement this
>>> Instrument?
>>> 
>>> BR,
>>> 
>>> On Sun, 8 Mar 2026 at 00:15, Peter Caspers <pca...@gm... <mailto:pca...@gm...>> wrote:
>>>> 
>>>> Hi Daniel,
>>>> 
>>>> I don't think we have this variant of a Bermudan swaption in QuantLib.
>>>> 
>>>> Best
>>>> Peter
>>>> 
>>>> 
>>>> On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm... <mailto:dan...@gm...>> wrote:
>>>>> 
>>>>> Hi,
>>>>> 
>>>>> I need to price a Bermudian type swaption which has multiple maturity
>>>>> dates (total number 5) however underlying swap is OIS, which has a
>>>>> fixed maturity date.
>>>>> 
>>>>> I found some swaption examples, where underlying swap has only fixed
>>>>> maturity term, not fixed maturity date. Therefore in my case, at eah
>>>>> exercise date, underlying swap's maturity term is lesser.
>>>>> 
>>>>> Can you please point if there any such quantlib implementation or
>>>>> example to price such swaption based on hull white model?
>>>>> 
>>>>> 
>>>>> _______________________________________________
>>>>> QuantLib-users mailing list
>>>>> Qua...@li... <mailto:Qua...@li...>
>>>>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>> 
>>> 
>>> _______________________________________________
>>> QuantLib-users mailing list
>>> Qua...@li... <mailto:Qua...@li...>
>>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>> 

Hi Rich and Daniel,

Apologies, I misunderstood the trade terms - I thought we were talking
about a swaption exercising into an underlying swap with constant maturity
measured from the respective exercise date!

Thanks for clarifying.

Best
Peter

On Sun, 8 Mar 2026 at 18:25, Rich Amaya <ric...@ma...> wrote:

> Hi Daniel,
>
> As Peter says, QuantLib doesn’t have a Bermudan swaption with an OIS
> underlying. However, you can use a VanillaSwap as a proxy for the
> underlying and price it with the existing Bermudan infrastructure.
>
> The existing QuantLib examples are actually the co-terminal case you need
> - a single swap with a fixed maturity date, with exercise dates at each
> fixed coupon accrual start. When exercised at a later date, only the
> remaining coupons contribute to the payoff, so the effective swap tenor is
> shorter while the maturity date stays the same. See
> Examples/BermudanSwaption/BermudanSwaption.cpp (line 248 onward) and
> test-suite/bermudanswaption.cpp.
>
> The setup is: create a VanillaSwap with your fixed maturity date, build a
> BermudanExercise from the fixed leg accrual start dates (your 5 exercise
> dates), and price with FdHullWhiteSwaptionEngine.
>
> Under a one-factor Hull-White model with a single forwarding curve, this
> VanillaSwap proxy is exact - the compound of daily overnight forwards
> equals the period forward rate on the same curve, so VanillaSwap and OIS
> floating legs produce identical NPVs.
>
> *References*
> - Brigo & Mercurio, “Interest Rate Model — Theory and Practice” (Ch. 3 for
> HW model, tree-based pricing)
> - Hull, “Options, Futures, and Other Derivatives,” 11th ed. (Ch. 31-32 for
> short-rate models and trinomial trees)
>
> I hope that helps!
>
> Best,
> Rich
>
>
> On Mar 8, 2026, at 6:53 AM, Daniel Lobo <dan...@gm...> wrote:
>
> Hi Peter,
>
> Thanks for your response.
>
> Do you know if there is any online resource available to get guidance
> on this pricing and if QuantLib has any pipeline to implement this
> Instrument?
>
> BR,
>
> On Sun, 8 Mar 2026 at 00:15, Peter Caspers <pca...@gm...> wrote:
>
>
> Hi Daniel,
>
> I don't think we have this variant of a Bermudan swaption in QuantLib.
>
> Best
> Peter
>
>
> On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm...> wrote:
>
>
> Hi,
>
> I need to price a Bermudian type swaption which has multiple maturity
> dates (total number 5) however underlying swap is OIS, which has a
> fixed maturity date.
>
> I found some swaption examples, where underlying swap has only fixed
> maturity term, not fixed maturity date. Therefore in my case, at eah
> exercise date, underlying swap's maturity term is lesser.
>
> Can you please point if there any such quantlib implementation or
> example to price such swaption based on hull white model?
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>
>
>

Hi Daniel,

As Peter says, QuantLib doesn’t have a Bermudan swaption with an OIS underlying. However, you can use a VanillaSwap as a proxy for the underlying and price it with the existing Bermudan infrastructure.

The existing QuantLib examples are actually the co-terminal case you need - a single swap with a fixed maturity date, with exercise dates at each fixed coupon accrual start. When exercised at a later date, only the remaining coupons contribute to the payoff, so the effective swap tenor is shorter while the maturity date stays the same. See Examples/BermudanSwaption/BermudanSwaption.cpp (line 248 onward) and test-suite/bermudanswaption.cpp.

The setup is: create a VanillaSwap with your fixed maturity date, build a BermudanExercise from the fixed leg accrual start dates (your 5 exercise dates), and price with FdHullWhiteSwaptionEngine.

Under a one-factor Hull-White model with a single forwarding curve, this VanillaSwap proxy is exact - the compound of daily overnight forwards equals the period forward rate on the same curve, so VanillaSwap and OIS floating legs produce identical NPVs.

References
- Brigo & Mercurio, “Interest Rate Model — Theory and Practice” (Ch. 3 for HW model, tree-based pricing)
- Hull, “Options, Futures, and Other Derivatives,” 11th ed. (Ch. 31-32 for short-rate models and trinomial trees)

I hope that helps!

Best,
Rich


> On Mar 8, 2026, at 6:53 AM, Daniel Lobo <dan...@gm...> wrote:
> 
> Hi Peter,
> 
> Thanks for your response.
> 
> Do you know if there is any online resource available to get guidance
> on this pricing and if QuantLib has any pipeline to implement this
> Instrument?
> 
> BR,
> 
> On Sun, 8 Mar 2026 at 00:15, Peter Caspers <pca...@gm...> wrote:
>> 
>> Hi Daniel,
>> 
>> I don't think we have this variant of a Bermudan swaption in QuantLib.
>> 
>> Best
>> Peter
>> 
>> 
>> On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm...> wrote:
>>> 
>>> Hi,
>>> 
>>> I need to price a Bermudian type swaption which has multiple maturity
>>> dates (total number 5) however underlying swap is OIS, which has a
>>> fixed maturity date.
>>> 
>>> I found some swaption examples, where underlying swap has only fixed
>>> maturity term, not fixed maturity date. Therefore in my case, at eah
>>> exercise date, underlying swap's maturity term is lesser.
>>> 
>>> Can you please point if there any such quantlib implementation or
>>> example to price such swaption based on hull white model?
>>> 
>>> 
>>> _______________________________________________
>>> QuantLib-users mailing list
>>> Qua...@li...
>>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
> 
> 
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users

You can use the QuantLib type VanillaSwaption. It references an 
underlying ibor swap with a fixed maturity date. If you need an OIS 
underlying, you can use a custom ibor of which the tenor equals the 
period of the fixed leg of the OIS.

On 3/7/2026 7:45 PM, Peter Caspers wrote:
> Hi Daniel,
>
> I don't think we have this variant of a Bermudan swaption in QuantLib.
>
> Best
> Peter
>
>
> On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm...> wrote:
>
>     Hi,
>
>     I need to price a Bermudian type swaption which has multiple maturity
>     dates (total number 5) however underlying swap is OIS, which has a
>     fixed maturity date.
>
>     I found some swaption examples, where underlying swap has only fixed
>     maturity term, not fixed maturity date. Therefore in my case, at eah
>     exercise date, underlying swap's maturity term is lesser.
>
>     Can you please point if there any such quantlib implementation or
>     example to price such swaption based on hull white model?
>
>
>     _______________________________________________
>     QuantLib-users mailing list
>     Qua...@li...
>     https://lists.sourceforge.net/lists/listinfo/quantlib-users
>
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users

-- 
This email has been checked for viruses by Avast antivirus software.
www.avast.com

Hi Peter,

Thanks for your response.

Do you know if there is any online resource available to get guidance
on this pricing and if QuantLib has any pipeline to implement this
Instrument?

BR,

On Sun, 8 Mar 2026 at 00:15, Peter Caspers <pca...@gm...> wrote:
>
> Hi Daniel,
>
> I don't think we have this variant of a Bermudan swaption in QuantLib.
>
> Best
> Peter
>
>
> On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm...> wrote:
>>
>> Hi,
>>
>> I need to price a Bermudian type swaption which has multiple maturity
>> dates (total number 5) however underlying swap is OIS, which has a
>> fixed maturity date.
>>
>> I found some swaption examples, where underlying swap has only fixed
>> maturity term, not fixed maturity date. Therefore in my case, at eah
>> exercise date, underlying swap's maturity term is lesser.
>>
>> Can you please point if there any such quantlib implementation or
>> example to price such swaption based on hull white model?
>>
>>
>> _______________________________________________
>> QuantLib-users mailing list
>> Qua...@li...
>> https://lists.sourceforge.net/lists/listinfo/quantlib-users

Hi Daniel,

I don't think we have this variant of a Bermudan swaption in QuantLib.

Best
Peter


On Sat, 7 Mar 2026 at 09:55, Daniel Lobo <dan...@gm...> wrote:

> Hi,
>
> I need to price a Bermudian type swaption which has multiple maturity
> dates (total number 5) however underlying swap is OIS, which has a
> fixed maturity date.
>
> I found some swaption examples, where underlying swap has only fixed
> maturity term, not fixed maturity date. Therefore in my case, at eah
> exercise date, underlying swap's maturity term is lesser.
>
> Can you please point if there any such quantlib implementation or
> example to price such swaption based on hull white model?
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>

Hi,

I need to price a Bermudian type swaption which has multiple maturity
dates (total number 5) however underlying swap is OIS, which has a
fixed maturity date.

I found some swaption examples, where underlying swap has only fixed
maturity term, not fixed maturity date. Therefore in my case, at eah
exercise date, underlying swap's maturity term is lesser.

Can you please point if there any such quantlib implementation or
example to price such swaption based on hull white model?

Hello Brian,
    they're called lockout days in our implementation.  The corresponding
method is withLockoutDays.

Hope this helps,
    Luigi


On Thu, Mar 5, 2026 at 11:48 AM Brian Smith <bri...@gm...>
wrote:

> Hi,
>
> I am using OvernightLeg constructor to create float leg for a OIS.
>
> Leg floatLeg = OvernightLeg(myschedule, rates)
> .withNotionals(notionals)
> .withSpreads(spread)
> .withRateCutoffDays(2)
>
> However above fails with error
>
> no member named 'withRateCutoffDays' in 'QuantLib::OvernightLeg'
>
> Could you please help with a fix to correctly pass rate cutoff days
> information
>
>
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>

Hi,

I am using OvernightLeg constructor to create float leg for a OIS.

Leg floatLeg = OvernightLeg(myschedule, rates)
.withNotionals(notionals)
.withSpreads(spread)
.withRateCutoffDays(2)

However above fails with error

no member named 'withRateCutoffDays' in 'QuantLib::OvernightLeg'

Could you please help with a fix to correctly pass rate cutoff days information

Hi all,

A while ago I started a side project to expose QuantLib as a backend
service.

The idea is to run it as a separate pricing engine and access it via API.

I recently picked it up again and now have a working version:

   - Distributed pricing engine
   - JSON and gRPC interfaces
   - Basic web frontend to interact with it


Project:
https://github.com/joseprupi/quantraserver

Demo:
https://app.quantra.io/

The motivation is to make QuantLib easier to integrate with modern systems
(web apps, services, etc.), without having to wrap C++ code in each project.

Any feedback is welcome.

Thanks!

Josep

Hello Magnus,
    one of our contributors just examined the problem and opened an issue
at <https://github.com/lballabio/QuantLib/issues/2454> — let's continue the
discussion there.

Regards,
    Luigi


On Tue, Feb 24, 2026 at 2:28 PM Magnus Gretton <mag...@ho...>
wrote:

> Hi all,
>
> I am using QuantLib across python and excel (the latter of which has had
> all inflation related classes and any required processes updated to 1.39 as
> a hybrid build) and currently experiencing some issues on building
> inflation curves.
> My issue is that when the months change, for the first few days of each
> month, calculations using the inflation curve fail due to the "root is not
> bracketed"-error.
> For instance, on February 3rd my setup failed although it was fully
> functional at the end of January.
> I've tried to broaden the bands for the guesses without luck in
> inflationtraits.hpp:  *constexpr double maxInflation = 0.5; *
> The error is the same in both my tests in python and excel.
>
> Ive attached my python code, for reference!
>
> *The errors in excel/Python:*
> Excel: "ZeroInflationTSZeroRate - 1st iteration: failed at 3rd alive
> instrument, pillar May 1st, 2026, maturity May 1st, 2026, reference date
> December 1st, 2025: root not bracketed: f[-0.5,0.5] ->
> [-2.184665e-01,-2.960285e-01]"
> Python: "RuntimeError: 1st iteration: failed at 3rd alive instrument,
> pillar May 1st, 2026, maturity May 1st, 2026, reference date December 1st,
> 2025: root not bracketed: f[-0.5,0.5] -> [-2.184665e-01,-2.960285e-01]"
> Note, the same error is produced when valuing swaps using the curve.
>
> *Observations:*
>
>    - During debugging, values seem reasonable across the board. No
>    unexpected anomalies in forecasted index fixings and corresponding rate
>    calculations. (Excel)
>    - When I change the settlement date to the 13th of Feb the
>    calculations work just fine. (Excel)
>    - Removing the first 7 ratehelpers (and reducing noisy short term
>    data) makes calculations work again. (Excel)
>    - Flat interpolation works fine, but using linear as I intend causes
>    issues. (Python / excel)
>    - Reducing curve accuracy has no effect (fails at 1st iteration).
>    (excel)
>
>
> Please find details on my current setup below:
>
> *Inflation setup:*
> *Index:* EUHICPXT
> *Base date: *Dec25 @ 128.89
> *Frequency:* Monthly
> *Curve:* PiecewiseZeroInflationCurve
> *Calendar:* Target
> *DayCount:* Simple
> *Convention:* Modified Following
> *Settlement days:* 0
> *Settlement date:* 03. Feb 2026
> *Lag:* 3m
> *Seasonality:* Omitted for testing purposes / or set to 1 for all months
> *Interpolation: *Linear (Flat does not produce an error interestingly
> enough)
> *Curve Accuracy:* 1.00E-09
> *ZCISratehelpers Tenor & Example Prices:*
>
> Tenor
> Rate
> 3m
> -2.81%
> 4m
> -0.73%
> 5m
> 1.17%
> 6m
> 2.27%
> 7m
> 2.19%
> 8m
> 2.22%
> 9m
> 1.75%
> 10m
> 1.86%
> 11m
> 1.74%
> 1y
> 1.82%
> 15m
> 1.46%
> 18m
> 2.19%
> 21m
> 2.08%
> 2y
> 1.78%
> 3y
> 1.84%
> 4y
> 1.88%
> 5y
> 1.90%
> 6y
> 1.92%
> 7y
> 1.95%
> 8y
> 1.97%
> 9y
> 1.99%
> 10y
> 2.01%
> 12y
> 2.06%
> 15y
> 2.11%
> 20y
> 2.19%
> 25y
> 2.24%
> 30y
> 2.29%
>
> Any help or insights would be greatly appreciated!
> Have a great week, everyone.
>
> Kind regards,
> Magnus
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>

Hi all,

I am using QuantLib across python and excel (the latter of which has had all inflation related classes and any required processes updated to 1.39 as a hybrid build) and currently experiencing some issues on building inflation curves.
My issue is that when the months change, for the first few days of each month, calculations using the inflation curve fail due to the "root is not bracketed"-error.
For instance, on February 3rd my setup failed although it was fully functional at the end of January.
I've tried to broaden the bands for the guesses without luck in inflationtraits.hpp:     constexpr double maxInflation = 0.5;
The error is the same in both my tests in python and excel.

Ive attached my python code, for reference!

The errors in excel/Python:
Excel: "ZeroInflationTSZeroRate - 1st iteration: failed at 3rd alive instrument, pillar May 1st, 2026, maturity May 1st, 2026, reference date December 1st, 2025: root not bracketed: f[-0.5,0.5] -> [-2.184665e-01,-2.960285e-01]"
Python: "RuntimeError: 1st iteration: failed at 3rd alive instrument, pillar May 1st, 2026, maturity May 1st, 2026, reference date December 1st, 2025: root not bracketed: f[-0.5,0.5] -> [-2.184665e-01,-2.960285e-01]"
Note, the same error is produced when valuing swaps using the curve.

Observations:

  *
During debugging, values seem reasonable across the board. No unexpected anomalies in forecasted index fixings and corresponding rate calculations. (Excel)
  *
When I change the settlement date to the 13th of Feb the calculations work just fine. (Excel)
  *
Removing the first 7 ratehelpers (and reducing noisy short term data) makes calculations work again. (Excel)
  *
Flat interpolation works fine, but using linear as I intend causes issues. (Python / excel)
  *
Reducing curve accuracy has no effect (fails at 1st iteration). (excel)

Please find details on my current setup below:

Inflation setup:
Index: EUHICPXT
Base date: Dec25 @ 128.89
Frequency: Monthly
Curve: PiecewiseZeroInflationCurve
Calendar: Target
DayCount: Simple
Convention: Modified Following
Settlement days: 0
Settlement date: 03. Feb 2026
Lag: 3m
Seasonality: Omitted for testing purposes / or set to 1 for all months
Interpolation: Linear (Flat does not produce an error interestingly enough)
Curve Accuracy: 1.00E-09
ZCISratehelpers Tenor & Example Prices:

Tenor
Rate
3m
-2.81%
4m
-0.73%
5m
1.17%
6m
2.27%
7m
2.19%
8m
2.22%
9m
1.75%
10m
1.86%
11m
1.74%
1y
1.82%
15m
1.46%
18m
2.19%
21m
2.08%
2y
1.78%
3y
1.84%
4y
1.88%
5y
1.90%
6y
1.92%
7y
1.95%
8y
1.97%
9y
1.99%
10y
2.01%
12y
2.06%
15y
2.11%
20y
2.19%
25y
2.24%
30y
2.29%

Any help or insights would be greatly appreciated!
Have a great week, everyone.

Kind regards,
Magnus

Hi QuantLib Community,

I recently discovered an interesting framework—Plotly/Dash—which allows you to build interactive websites using just Python (Flask + React). I put together two demo sites: one for equity options and another for rates.

Options: https://options.plotly.app <https://options.plotly.app/>
Rates: https://rates.plotly.app <https://rates.plotly.app/>
Source Code: https://github.com/mkipnis/DashQL
Dev guide (Options): https://mkipnis.substack.com/p/plotly-dash-and-quantlib-vanilla

Can you please suggest any features or other products I should add?

Best Regards,
Mike

Hi all,

We would like to share an update on Automatic Differentiation (AAD) support
in QuantLib under the project name QuantLibAAD (formerly
QuantLib-Risks-Cpp). QuantLib can be used with AAD via the open-source XAD
library and a dedicated integration module, allowing sensitivities to be
computed directly through QuantLib code without modifying model logic.

Recent work by da-roth (https://github.com/da-roth/) adds optional
JIT-based execution support, enabling record-once / replay-many workflows
for selected parts of a valuation. This is particularly relevant for Monte
Carlo-style inner loops.

In this setup:

* A representative execution of a code region is recorded once
* Optimised code is generated and compiled once
* The compiled code is replayed efficiently across Monte Carlo paths

This is not an all-or-nothing switch. For selected code regions that are
evaluated repeatedly with different inputs, such as expensive Monte Carlo
or PDE pricing engines, a recording mode can be activated. The overloaded
operators then capture a computation graph, including branches, that can be
JIT-compiled and replayed efficiently. The rest of the valuation simply
runs through the overloaded operators as usual. The result is a hybrid
workflow combining tape-based AAD with replay-based JIT-compiled execution.

Example: Monte Carlo sensitivities

A representative QuantLib Monte Carlo example applies replay-based
execution to the MC loop while retaining tape-based AAD for curve
construction and setup, and compares results against finite-difference
sensitivities.

The application prices a European swaption in a realistic production-style
setup, with separate forecasting and OIS discounting curves, CVA/DVA,
bootstrapped interest-rate and credit curves, Monte Carlo pricing, and
sensitivities to all market inputs.

Key result: a native QuantLib double valuation with 10,000 Monte Carlo
paths and no sensitivities takes ~306 ms. With XAD and JIT enabled,
computing all 90 sensitivities on the same 10,000 paths takes ~520 ms.*

This illustrates that selectively applying replay-based execution can
significantly reduce Monte Carlo sensitivity runtimes while retaining full
AAD capabilities across the valuation pipeline.

* QuantLib integration: https://github.com/auto-differentiation/QuantLibAAD
* XAD library: https://github.com/auto-differentiation/xad

We would be very interested in feedback on where this execution model fits
(or does not fit) typical QuantLib Monte Carlo use cases. Questions and
comments are very welcome.

Best regards,
Jorg

* Timings are indicative only and depend on product structure and where
replay-based execution can be applied. Full benchmark details are available
here:
https://gist.github.com/auto-differentiation-dev/9e6c472dcf913ffa00136d4b16423d16

QuantLib 1.41 is available for download at <
https://www.quantlib.org/download.shtml>; precompiled binaries are also
available from PyPI and NuGet for Python and C# respectively.

The list of changes for this release is at <
https://github.com/lballabio/QuantLib/releases/tag/v1.41>.

If you have any problems with this release, please report them here on the
QuantLib mailing list (<qua...@li...>) or open a
GitHub issue at <https://github.com/lballabio/quantlib/issues>.

Hi all,
   a release candidate for QuantLib 1.41 is available at <
https://github.com/lballabio/QuantLib/releases/tag/v1.41-rc>.  Python
wheels are also available at <
https://test.pypi.org/project/QuantLib/1.41rc0/>, and a C# NuGet package is
at <https://int.nugettest.org/packages/QuantLib/1.41.0-rc>.  If you have
some time, please try it out and report any issues on GitHub (or here on
the mailing list).  Thanks!

Luigi

Hi Luigi,

Thank you very much for the clarification.

I was not aware of ql.CustomRegion, but after creating a CustomRegion for
Japan and passing it to the ZeroInflationIndex constructor, everything
worked as expected.

I really appreciate your help.

By the way, I am based in Japan and have published a book here related to
QuantLib-Python.
Its ISBN-13 is *978-4320096530*.

Thank you again for your support.

Best regards,
Kenji Ogawa

2026年1月5日(月) 17:36 Luigi Ballabio <lui...@gm...>:

> Hi,
>     ql.Japan() is a calendar, not an instance of Region.  You can create a
> region for Japan using the ql.CustomRegion class.  Once you pass that to
> the ZeroInflationIndex constructor, it should work.
>
> Hope this helps,
>     Luigi
>
>
> On Sun, Jan 4, 2026 at 1:33 AM Kenji Ogawa <for...@gm...> wrote:
>
>> Hi there,
>>
>> I am unable to construct a ZeroInflationIndex from Python using QuantLib
>> version 1.40 and the current constructor.
>>
>> The following Python code fails on my side:
>>
>> import QuantLib as ql
>> jpCPI = ql.ZeroInflationIndex(
>>     "Japan CPI",
>>     ql.Japan(),
>>     False,
>>     ql.Monthly,
>>     ql.Period(3, ql.Months),
>>     ql.JPYCurrency()
>> )
>>
>> Could you please point me to the specific place where this should be
>> fixed?
>>
>> Regards, Kenji
>> _______________________________________________
>> QuantLib-users mailing list
>> Qua...@li...
>> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>>
>

Hi,
    ql.Japan() is a calendar, not an instance of Region.  You can create a
region for Japan using the ql.CustomRegion class.  Once you pass that to
the ZeroInflationIndex constructor, it should work.

Hope this helps,
    Luigi


On Sun, Jan 4, 2026 at 1:33 AM Kenji Ogawa <for...@gm...> wrote:

> Hi there,
>
> I am unable to construct a ZeroInflationIndex from Python using QuantLib
> version 1.40 and the current constructor.
>
> The following Python code fails on my side:
>
> import QuantLib as ql
> jpCPI = ql.ZeroInflationIndex(
>     "Japan CPI",
>     ql.Japan(),
>     False,
>     ql.Monthly,
>     ql.Period(3, ql.Months),
>     ql.JPYCurrency()
> )
>
> Could you please point me to the specific place where this should be fixed?
>
> Regards, Kenji
> _______________________________________________
> QuantLib-users mailing list
> Qua...@li...
> https://lists.sourceforge.net/lists/listinfo/quantlib-users
>

Thank you for your suggestion.

My intention is to evaluate a Japanese inflation-linked bond using the
constructor of ql.CPIBond, which I find very powerful and convenient.

In order to do so, I need to construct a ZeroInflationIndex for Japan.
However, with my current setup, I am unable to successfully create the
Japanese CPI index, as shown below.

I am not questioning the CPI figures themselves; rather, I am trying to
understand the correct way to construct the ZeroInflationIndex in
QuantLib-python for this use case.

I would appreciate it if you could clarify whether my usage of the
ZeroInflationIndex constructor is incorrect, or if there is a known issue
or limitation in the current implementation. Any guidance would be very
helpful.

Kenji

<<  my code  >>

import QuantLib as ql

print(ql.__version__)

yieldHDL = ql.YieldTermStructureHandle(
    ql.FlatForward(
    ql.Date(1, ql.January, 2024),
    0.02,
    ql.Actual365Fixed() ))

jpCPI = ql.ZeroInflationIndex(
    "Japan CPI",
    ql.Japan(),
    False,
    ql.Monthly,
    ql.Period(3, ql.Months),
    ql.JPYCurrency(),
    yieldHDL
)

1.40
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_10428\3520687904.py in ?()
      7     ql.Date(1, ql.January, 2024),
      8     0.02,
      9     ql.Actual365Fixed() ))
     10
---> 11 jpCPI = ql.ZeroInflationIndex(
     12     "Japan CPI",
     13     ql.Japan(),
     14     False,

e:\local\anaconda3\Lib\site-packages\QuantLib\QuantLib.py in ?(self, *args)
  23445     def __init__(self, *args):
  23446         r"""__init__(ZeroInflationIndex self, std::string const &
familyName, Region region, bool revised, Frequency frequency, Period
availabilityLag, Currency currency, ZeroInflationTermStructureHandle h={})
-> ZeroInflationIndex"""
> 23447         _QuantLib.ZeroInflationIndex_swiginit(self,
_QuantLib.new_ZeroInflationIndex(*args))

TypeError: Wrong number or type of arguments for overloaded function
'new_ZeroInflationIndex'.
  Possible C/C++ prototypes are:
    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const
&,bool,Frequency,Period const &,Currency const &,Handle<
ZeroInflationTermStructure > const &)
    ZeroInflationIndex::ZeroInflationIndex(std::string const &,Region const
&,bool,Frequency,Period const &,Currency const &)



2026年1月4日(日) 10:10 dandalerovivaciously <dan...@gm...>:

> +Qua...@li...
> <Qua...@li...>
>
> On Sun, Jan 4, 2026 at 10:08 AM dandalerovivaciously <
> dan...@gm...> wrote:
>
>> Ogawa san,
>>
>> Why are you creating your own inflation Index, you dont trust the CPI
>> figures published?
>>
>> Try the following:
>>
>> import QuantLib as ql
>>
>> # Create the term structure first (you'll need to provide your inflation
>> data)
>> # For demonstration, I'll create a flat forward curve
>> today = ql.Date(1, ql.January, 2024)
>> ql.Settings.instance().evaluationDate = today
>>
>> # Create a flat forward term structure for CPI
>> rate = 0.02  # 2% inflation
>> observationLag = ql.Period(3, ql.Months)
>> cpiTermStructure = ql.FlatForward(
>>     today,
>>     rate,
>>     ql.ActualActual(),
>>     ql.Continuous
>> )
>>
>> # Create the ZeroInflationIndex
>> jpCPI = ql.ZeroInflationIndex(
>>     "Japan CPI",  # family name
>>     ql.Japan(),   # region
>>     False,        # revised
>>     ql.Monthly,   # frequency
>>     observationLag,  # availability lag
>>     ql.JPYCurrency(),  # currency
>>     cpiTermStructure  # term structure (required parameter)
>> )
>>
>> print(f"Created ZeroInflationIndex: {jpCPI.name()}")
>>
>>
>>
>>
>>
>> or this:
>>
>>
>> import QuantLib as ql
>>
>> # Create CPI fixing data
>> cpi_fixings = {
>>     ql.Date(1, 1, 2023): 100.0,
>>     ql.Date(1, 2, 2023): 100.2,
>>     ql.Date(1, 3, 2023): 100.5,
>>     # Add more historical data
>> }
>>
>> # Create term structure with interpolated data
>> today = ql.Date(1, ql.January, 2024)
>> ql.Settings.instance().evaluationDate = today
>>
>> # Create dates and rates for term structure
>> dates = [ql.Date(1, 1, 2023), ql.Date(1, 1, 2025), ql.Date(1, 1, 2030)]
>> rates = [0.02, 0.025, 0.03]  # Inflation rates
>>
>> # Create interpolated term structure
>> cpiTermStructure = ql.ZeroInflationCurve(
>>     today,
>>     dates,
>>     rates,
>>     ql.ActualActual(),
>>     ql.Japan(),
>>     ql.Monthly,
>>     ql.Period(3, ql.Months),
>>     ql.Linear()
>> )
>>
>> # Create the index
>> jpCPI = ql.ZeroInflationIndex(
>>     "Japan CPI",
>>     ql.Japan(),
>>     False,
>>     ql.Monthly,
>>     ql.Period(3, ql.Months),
>>     ql.JPYCurrency(),
>>     cpiTermStructure
>> )
>>
>> # Add historical fixings
>> for date, fixing in cpi_fixings.items():
>>     jpCPI.addFixing(date, fixing)
>>
>> print(f"ZeroInflationIndex created successfully")
>> print(f"Evaluation date: {today}")
>> print(f"Index has term structure: {jpCPI.zeroInflationTermStructure() is
>> not None}")
>>
>>
>>
>>
>>
>>
>>
>>

Hi there,

I am unable to construct a ZeroInflationIndex from Python using QuantLib
version 1.40 and the current constructor.

The following Python code fails on my side:

import QuantLib as ql
jpCPI = ql.ZeroInflationIndex(
    "Japan CPI",
    ql.Japan(),
    False,
    ql.Monthly,
    ql.Period(3, ql.Months),
    ql.JPYCurrency()
)

Could you please point me to the specific place where this should be fixed?

Regards, Kenji

CORPORATE

Hi Brian,

indeed,  you can build that using QuantLib components.
Our take is in ORE, https://github.com/OpenSourceRisk/Engine using the scripted trade framework, see example https://github.com/OpenSourceRisk/Engine/tree/master/Examples/ScriptedTrade, that has an equity accumulator.

Best wishes,
Roland

From: Luigi Ballabio <lui...@gm...>
Date: Monday, 17 November 2025 at 15:18
To: Brian Smith <bri...@gm...>
Cc: QuantLib Users <qua...@li...>
Subject: Re: [Quantlib-users] Derivative pricing using Quantlib

*** EXTERNAL EMAIL ***

Hello Brian,
    first of all, apologies for the delay.  No, equity accumulators are not supported directly.  In C++, it should be possible to build something using the Monte Carlo framework; see chapter 6 in Implementing QuantLib, or the corresponding posts at <https://www.implementingquantlib.com/posts/implementing-quantlib.html<https://www.implementingquantlib.com/posts/implementing-quantlib.html>>.

Hope this helps,
    Luigi


On Thu, Oct 23, 2025 at 12:50 PM Brian Smith <bri...@gm...<mailto:bri...@gm...>> wrote:
Hi,

I wonder if Quantlib has any function or method to price Equity
Accumulator derivative pricing?

Any guidance would be greatly appreciated.

Thanks and regards,


_______________________________________________
QuantLib-users mailing list
Qua...@li...<mailto:Qua...@li...>
https://lists.sourceforge.net/lists/listinfo/quantlib-users<https://lists.sourceforge.net/lists/listinfo/quantlib-users>
------------------------------------------------------------------------------------------------------------
 
Please read these warnings and restrictions:
This e-mail transmission is strictly confidential and intended solely for the ordinary user of the e-mail address to which it was addressed. It may contain legally privileged and/or CONFIDENTIAL information.
The unauthorised use, disclosure, distribution and/or copying of this e-mail or any information it contains is prohibited and could, in certain circumstances, constitute a criminal offence.
If you have received this e-mail in error or are not an intended recipient please inform London Stock Exchange Group (“LSEG”) immediately by return e-mail or telephone 020 7797 1000.
LSEG may collect, process and retain your personal information for its business purposes. For more information please see our Privacy Policy.
We advise that in keeping with good computing practice the recipient of this e-mail should ensure that it is virus free. We do not accept responsibility for any virus that may be transferred by way of this e-mail.
E-mail may be susceptible to data corruption, interception and unauthorised amendment, and we do not accept liability for any such corruption, interception or amendment or any consequences thereof. 
Calls to London Stock Exchange Group may be recorded to enable LSEG to carry out its regulatory responsibilities.
For more details on the LSEG group of companies click here 
London Stock Exchange Group plc
10 Paternoster Square
London 
EC4M 7LS
Registered in England and Wales No 05369106
 
------------------------------------------------------------------------------------------------------------